
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0 (log (sqrt (+ (* x.re x.re) (* x.im x.im))))))
(*
(exp (- (* t_0 y.re) (* (atan2 x.im x.re) y.im)))
(sin (+ (* t_0 y.im) (* (atan2 x.im x.re) y.re))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = log(sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))));
return exp(((t_0 * y_46_re) - (atan2(x_46_im, x_46_re) * y_46_im))) * sin(((t_0 * y_46_im) + (atan2(x_46_im, x_46_re) * y_46_re)));
}
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(x_46re, x_46im, y_46re, y_46im)
use fmin_fmax_functions
real(8), intent (in) :: x_46re
real(8), intent (in) :: x_46im
real(8), intent (in) :: y_46re
real(8), intent (in) :: y_46im
real(8) :: t_0
t_0 = log(sqrt(((x_46re * x_46re) + (x_46im * x_46im))))
code = exp(((t_0 * y_46re) - (atan2(x_46im, x_46re) * y_46im))) * sin(((t_0 * y_46im) + (atan2(x_46im, x_46re) * y_46re)))
end function
public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = Math.log(Math.sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))));
return Math.exp(((t_0 * y_46_re) - (Math.atan2(x_46_im, x_46_re) * y_46_im))) * Math.sin(((t_0 * y_46_im) + (Math.atan2(x_46_im, x_46_re) * y_46_re)));
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): t_0 = math.log(math.sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im)))) return math.exp(((t_0 * y_46_re) - (math.atan2(x_46_im, x_46_re) * y_46_im))) * math.sin(((t_0 * y_46_im) + (math.atan2(x_46_im, x_46_re) * y_46_re)))
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = log(sqrt(Float64(Float64(x_46_re * x_46_re) + Float64(x_46_im * x_46_im)))) return Float64(exp(Float64(Float64(t_0 * y_46_re) - Float64(atan(x_46_im, x_46_re) * y_46_im))) * sin(Float64(Float64(t_0 * y_46_im) + Float64(atan(x_46_im, x_46_re) * y_46_re)))) end
function tmp = code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = log(sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im)))); tmp = exp(((t_0 * y_46_re) - (atan2(x_46_im, x_46_re) * y_46_im))) * sin(((t_0 * y_46_im) + (atan2(x_46_im, x_46_re) * y_46_re))); end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[Log[N[Sqrt[N[(N[(x$46$re * x$46$re), $MachinePrecision] + N[(x$46$im * x$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]}, N[(N[Exp[N[(N[(t$95$0 * y$46$re), $MachinePrecision] - N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(N[(t$95$0 * y$46$im), $MachinePrecision] + N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \log \left(\sqrt{x.re \cdot x.re + x.im \cdot x.im}\right)\\
e^{t\_0 \cdot y.re - \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im} \cdot \sin \left(t\_0 \cdot y.im + \tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\right)
\end{array}
\end{array}
Herbie found 21 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0 (log (sqrt (+ (* x.re x.re) (* x.im x.im))))))
(*
(exp (- (* t_0 y.re) (* (atan2 x.im x.re) y.im)))
(sin (+ (* t_0 y.im) (* (atan2 x.im x.re) y.re))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = log(sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))));
return exp(((t_0 * y_46_re) - (atan2(x_46_im, x_46_re) * y_46_im))) * sin(((t_0 * y_46_im) + (atan2(x_46_im, x_46_re) * y_46_re)));
}
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(x_46re, x_46im, y_46re, y_46im)
use fmin_fmax_functions
real(8), intent (in) :: x_46re
real(8), intent (in) :: x_46im
real(8), intent (in) :: y_46re
real(8), intent (in) :: y_46im
real(8) :: t_0
t_0 = log(sqrt(((x_46re * x_46re) + (x_46im * x_46im))))
code = exp(((t_0 * y_46re) - (atan2(x_46im, x_46re) * y_46im))) * sin(((t_0 * y_46im) + (atan2(x_46im, x_46re) * y_46re)))
end function
public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = Math.log(Math.sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))));
return Math.exp(((t_0 * y_46_re) - (Math.atan2(x_46_im, x_46_re) * y_46_im))) * Math.sin(((t_0 * y_46_im) + (Math.atan2(x_46_im, x_46_re) * y_46_re)));
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): t_0 = math.log(math.sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im)))) return math.exp(((t_0 * y_46_re) - (math.atan2(x_46_im, x_46_re) * y_46_im))) * math.sin(((t_0 * y_46_im) + (math.atan2(x_46_im, x_46_re) * y_46_re)))
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = log(sqrt(Float64(Float64(x_46_re * x_46_re) + Float64(x_46_im * x_46_im)))) return Float64(exp(Float64(Float64(t_0 * y_46_re) - Float64(atan(x_46_im, x_46_re) * y_46_im))) * sin(Float64(Float64(t_0 * y_46_im) + Float64(atan(x_46_im, x_46_re) * y_46_re)))) end
function tmp = code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = log(sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im)))); tmp = exp(((t_0 * y_46_re) - (atan2(x_46_im, x_46_re) * y_46_im))) * sin(((t_0 * y_46_im) + (atan2(x_46_im, x_46_re) * y_46_re))); end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[Log[N[Sqrt[N[(N[(x$46$re * x$46$re), $MachinePrecision] + N[(x$46$im * x$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]}, N[(N[Exp[N[(N[(t$95$0 * y$46$re), $MachinePrecision] - N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(N[(t$95$0 * y$46$im), $MachinePrecision] + N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \log \left(\sqrt{x.re \cdot x.re + x.im \cdot x.im}\right)\\
e^{t\_0 \cdot y.re - \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im} \cdot \sin \left(t\_0 \cdot y.im + \tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\right)
\end{array}
\end{array}
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0 (log (hypot x.re x.im))))
(if (<= y.im 2e+207)
(*
(exp (- (* t_0 y.re) (* (atan2 x.im x.re) y.im)))
(sin (+ (* t_0 y.im) (* (atan2 x.im x.re) y.re))))
(*
(exp (- (* y.im (atan2 x.im x.re))))
(sin (* y.re (atan2 x.im x.re)))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = log(hypot(x_46_re, x_46_im));
double tmp;
if (y_46_im <= 2e+207) {
tmp = exp(((t_0 * y_46_re) - (atan2(x_46_im, x_46_re) * y_46_im))) * sin(((t_0 * y_46_im) + (atan2(x_46_im, x_46_re) * y_46_re)));
} else {
tmp = exp(-(y_46_im * atan2(x_46_im, x_46_re))) * sin((y_46_re * atan2(x_46_im, x_46_re)));
}
return tmp;
}
public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = Math.log(Math.hypot(x_46_re, x_46_im));
double tmp;
if (y_46_im <= 2e+207) {
tmp = Math.exp(((t_0 * y_46_re) - (Math.atan2(x_46_im, x_46_re) * y_46_im))) * Math.sin(((t_0 * y_46_im) + (Math.atan2(x_46_im, x_46_re) * y_46_re)));
} else {
tmp = Math.exp(-(y_46_im * Math.atan2(x_46_im, x_46_re))) * Math.sin((y_46_re * Math.atan2(x_46_im, x_46_re)));
}
return tmp;
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): t_0 = math.log(math.hypot(x_46_re, x_46_im)) tmp = 0 if y_46_im <= 2e+207: tmp = math.exp(((t_0 * y_46_re) - (math.atan2(x_46_im, x_46_re) * y_46_im))) * math.sin(((t_0 * y_46_im) + (math.atan2(x_46_im, x_46_re) * y_46_re))) else: tmp = math.exp(-(y_46_im * math.atan2(x_46_im, x_46_re))) * math.sin((y_46_re * math.atan2(x_46_im, x_46_re))) return tmp
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = log(hypot(x_46_re, x_46_im)) tmp = 0.0 if (y_46_im <= 2e+207) tmp = Float64(exp(Float64(Float64(t_0 * y_46_re) - Float64(atan(x_46_im, x_46_re) * y_46_im))) * sin(Float64(Float64(t_0 * y_46_im) + Float64(atan(x_46_im, x_46_re) * y_46_re)))); else tmp = Float64(exp(Float64(-Float64(y_46_im * atan(x_46_im, x_46_re)))) * sin(Float64(y_46_re * atan(x_46_im, x_46_re)))); end return tmp end
function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = log(hypot(x_46_re, x_46_im)); tmp = 0.0; if (y_46_im <= 2e+207) tmp = exp(((t_0 * y_46_re) - (atan2(x_46_im, x_46_re) * y_46_im))) * sin(((t_0 * y_46_im) + (atan2(x_46_im, x_46_re) * y_46_re))); else tmp = exp(-(y_46_im * atan2(x_46_im, x_46_re))) * sin((y_46_re * atan2(x_46_im, x_46_re))); end tmp_2 = tmp; end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[Log[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y$46$im, 2e+207], N[(N[Exp[N[(N[(t$95$0 * y$46$re), $MachinePrecision] - N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(N[(t$95$0 * y$46$im), $MachinePrecision] + N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[Exp[(-N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision])], $MachinePrecision] * N[Sin[N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \log \left(\mathsf{hypot}\left(x.re, x.im\right)\right)\\
\mathbf{if}\;y.im \leq 2 \cdot 10^{+207}:\\
\;\;\;\;e^{t\_0 \cdot y.re - \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im} \cdot \sin \left(t\_0 \cdot y.im + \tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\right)\\
\mathbf{else}:\\
\;\;\;\;e^{-y.im \cdot \tan^{-1}_* \frac{x.im}{x.re}} \cdot \sin \left(y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\right)\\
\end{array}
\end{array}
if y.im < 2.0000000000000001e207Initial program 40.5%
lift-sqrt.f64N/A
lift-+.f64N/A
lift-*.f64N/A
sqr-neg-revN/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
distribute-lft-neg-inN/A
distribute-rgt-neg-outN/A
sqr-neg-revN/A
sqr-neg-revN/A
lower-hypot.f6440.5
Applied rewrites40.5%
lift-sqrt.f64N/A
lift-+.f64N/A
lift-*.f64N/A
sqr-neg-revN/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
distribute-lft-neg-inN/A
distribute-rgt-neg-outN/A
sqr-neg-revN/A
sqr-neg-revN/A
lower-hypot.f6480.1
Applied rewrites80.1%
if 2.0000000000000001e207 < y.im Initial program 40.5%
Taylor expanded in y.im around 0
lower-sin.f64N/A
lower-*.f64N/A
lower-atan2.f6453.6
Applied rewrites53.6%
lift-+.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
sqr-neg-revN/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
remove-double-negN/A
sqr-neg-revN/A
lift-*.f64N/A
lower-fma.f6453.6
Applied rewrites53.6%
Taylor expanded in y.re around 0
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f6440.2
Applied rewrites40.2%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0 (* (atan2 x.im x.re) y.im))
(t_1 (* (atan2 x.im x.re) y.re))
(t_2 (log (* -1.0 x.re)))
(t_3 (log (- x.im))))
(if (<= x.re -1e-310)
(* (exp (- (* t_2 y.re) t_0)) (sin (+ (* t_2 y.im) t_1)))
(if (<= x.re 4.6e-161)
(* (exp (- (* t_3 y.re) t_0)) (sin (+ (* t_3 y.im) t_1)))
(/
(sin (fma (atan2 x.im x.re) y.re (* (log x.re) y.im)))
(exp (- (* y.im (atan2 x.im x.re)) (* (log x.re) y.re))))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = atan2(x_46_im, x_46_re) * y_46_im;
double t_1 = atan2(x_46_im, x_46_re) * y_46_re;
double t_2 = log((-1.0 * x_46_re));
double t_3 = log(-x_46_im);
double tmp;
if (x_46_re <= -1e-310) {
tmp = exp(((t_2 * y_46_re) - t_0)) * sin(((t_2 * y_46_im) + t_1));
} else if (x_46_re <= 4.6e-161) {
tmp = exp(((t_3 * y_46_re) - t_0)) * sin(((t_3 * y_46_im) + t_1));
} else {
tmp = sin(fma(atan2(x_46_im, x_46_re), y_46_re, (log(x_46_re) * y_46_im))) / exp(((y_46_im * atan2(x_46_im, x_46_re)) - (log(x_46_re) * y_46_re)));
}
return tmp;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = Float64(atan(x_46_im, x_46_re) * y_46_im) t_1 = Float64(atan(x_46_im, x_46_re) * y_46_re) t_2 = log(Float64(-1.0 * x_46_re)) t_3 = log(Float64(-x_46_im)) tmp = 0.0 if (x_46_re <= -1e-310) tmp = Float64(exp(Float64(Float64(t_2 * y_46_re) - t_0)) * sin(Float64(Float64(t_2 * y_46_im) + t_1))); elseif (x_46_re <= 4.6e-161) tmp = Float64(exp(Float64(Float64(t_3 * y_46_re) - t_0)) * sin(Float64(Float64(t_3 * y_46_im) + t_1))); else tmp = Float64(sin(fma(atan(x_46_im, x_46_re), y_46_re, Float64(log(x_46_re) * y_46_im))) / exp(Float64(Float64(y_46_im * atan(x_46_im, x_46_re)) - Float64(log(x_46_re) * y_46_re)))); end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]}, Block[{t$95$1 = N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]}, Block[{t$95$2 = N[Log[N[(-1.0 * x$46$re), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[Log[(-x$46$im)], $MachinePrecision]}, If[LessEqual[x$46$re, -1e-310], N[(N[Exp[N[(N[(t$95$2 * y$46$re), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(N[(t$95$2 * y$46$im), $MachinePrecision] + t$95$1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[x$46$re, 4.6e-161], N[(N[Exp[N[(N[(t$95$3 * y$46$re), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(N[(t$95$3 * y$46$im), $MachinePrecision] + t$95$1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[Sin[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re + N[(N[Log[x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[Exp[N[(N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision] - N[(N[Log[x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im\\
t_1 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\\
t_2 := \log \left(-1 \cdot x.re\right)\\
t_3 := \log \left(-x.im\right)\\
\mathbf{if}\;x.re \leq -1 \cdot 10^{-310}:\\
\;\;\;\;e^{t\_2 \cdot y.re - t\_0} \cdot \sin \left(t\_2 \cdot y.im + t\_1\right)\\
\mathbf{elif}\;x.re \leq 4.6 \cdot 10^{-161}:\\
\;\;\;\;e^{t\_3 \cdot y.re - t\_0} \cdot \sin \left(t\_3 \cdot y.im + t\_1\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\sin \left(\mathsf{fma}\left(\tan^{-1}_* \frac{x.im}{x.re}, y.re, \log x.re \cdot y.im\right)\right)}{e^{y.im \cdot \tan^{-1}_* \frac{x.im}{x.re} - \log x.re \cdot y.re}}\\
\end{array}
\end{array}
if x.re < -9.999999999999969e-311Initial program 40.5%
Taylor expanded in x.re around -inf
lower-*.f6418.5
Applied rewrites18.5%
Taylor expanded in x.re around -inf
lower-*.f6434.1
Applied rewrites34.1%
if -9.999999999999969e-311 < x.re < 4.6e-161Initial program 40.5%
Taylor expanded in x.im around -inf
lower-*.f6417.8
Applied rewrites17.8%
Taylor expanded in x.im around -inf
lower-*.f6431.1
Applied rewrites31.1%
lift-*.f64N/A
mul-1-negN/A
lower-neg.f6431.1
Applied rewrites31.1%
lift-*.f64N/A
mul-1-negN/A
lower-neg.f6431.1
Applied rewrites31.1%
if 4.6e-161 < x.re Initial program 40.5%
Taylor expanded in x.re around inf
lower-*.f64N/A
Applied rewrites32.3%
Applied rewrites32.3%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0 (* (atan2 x.im x.re) y.im))
(t_1 (* y.im (atan2 x.im x.re)))
(t_2 (log (- x.im)))
(t_3 (* (atan2 x.im x.re) y.re)))
(if (<= x.re -1.4e-184)
(*
(exp (- (* (log (* -1.0 x.re)) y.re) t_0))
(sin (* y.re (atan2 x.im x.re))))
(if (<= x.re 6.8e-307)
(* (sin (fma (log x.im) y.im t_3)) (exp (- (* (log x.im) y.re) t_1)))
(if (<= x.re 4.6e-161)
(* (exp (- (* t_2 y.re) t_0)) (sin (+ (* t_2 y.im) t_3)))
(/
(sin (fma (atan2 x.im x.re) y.re (* (log x.re) y.im)))
(exp (- t_1 (* (log x.re) y.re)))))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = atan2(x_46_im, x_46_re) * y_46_im;
double t_1 = y_46_im * atan2(x_46_im, x_46_re);
double t_2 = log(-x_46_im);
double t_3 = atan2(x_46_im, x_46_re) * y_46_re;
double tmp;
if (x_46_re <= -1.4e-184) {
tmp = exp(((log((-1.0 * x_46_re)) * y_46_re) - t_0)) * sin((y_46_re * atan2(x_46_im, x_46_re)));
} else if (x_46_re <= 6.8e-307) {
tmp = sin(fma(log(x_46_im), y_46_im, t_3)) * exp(((log(x_46_im) * y_46_re) - t_1));
} else if (x_46_re <= 4.6e-161) {
tmp = exp(((t_2 * y_46_re) - t_0)) * sin(((t_2 * y_46_im) + t_3));
} else {
tmp = sin(fma(atan2(x_46_im, x_46_re), y_46_re, (log(x_46_re) * y_46_im))) / exp((t_1 - (log(x_46_re) * y_46_re)));
}
return tmp;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = Float64(atan(x_46_im, x_46_re) * y_46_im) t_1 = Float64(y_46_im * atan(x_46_im, x_46_re)) t_2 = log(Float64(-x_46_im)) t_3 = Float64(atan(x_46_im, x_46_re) * y_46_re) tmp = 0.0 if (x_46_re <= -1.4e-184) tmp = Float64(exp(Float64(Float64(log(Float64(-1.0 * x_46_re)) * y_46_re) - t_0)) * sin(Float64(y_46_re * atan(x_46_im, x_46_re)))); elseif (x_46_re <= 6.8e-307) tmp = Float64(sin(fma(log(x_46_im), y_46_im, t_3)) * exp(Float64(Float64(log(x_46_im) * y_46_re) - t_1))); elseif (x_46_re <= 4.6e-161) tmp = Float64(exp(Float64(Float64(t_2 * y_46_re) - t_0)) * sin(Float64(Float64(t_2 * y_46_im) + t_3))); else tmp = Float64(sin(fma(atan(x_46_im, x_46_re), y_46_re, Float64(log(x_46_re) * y_46_im))) / exp(Float64(t_1 - Float64(log(x_46_re) * y_46_re)))); end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]}, Block[{t$95$1 = N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Log[(-x$46$im)], $MachinePrecision]}, Block[{t$95$3 = N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]}, If[LessEqual[x$46$re, -1.4e-184], N[(N[Exp[N[(N[(N[Log[N[(-1.0 * x$46$re), $MachinePrecision]], $MachinePrecision] * y$46$re), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[x$46$re, 6.8e-307], N[(N[Sin[N[(N[Log[x$46$im], $MachinePrecision] * y$46$im + t$95$3), $MachinePrecision]], $MachinePrecision] * N[Exp[N[(N[(N[Log[x$46$im], $MachinePrecision] * y$46$re), $MachinePrecision] - t$95$1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[x$46$re, 4.6e-161], N[(N[Exp[N[(N[(t$95$2 * y$46$re), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(N[(t$95$2 * y$46$im), $MachinePrecision] + t$95$3), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[Sin[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re + N[(N[Log[x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[Exp[N[(t$95$1 - N[(N[Log[x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im\\
t_1 := y.im \cdot \tan^{-1}_* \frac{x.im}{x.re}\\
t_2 := \log \left(-x.im\right)\\
t_3 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\\
\mathbf{if}\;x.re \leq -1.4 \cdot 10^{-184}:\\
\;\;\;\;e^{\log \left(-1 \cdot x.re\right) \cdot y.re - t\_0} \cdot \sin \left(y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\right)\\
\mathbf{elif}\;x.re \leq 6.8 \cdot 10^{-307}:\\
\;\;\;\;\sin \left(\mathsf{fma}\left(\log x.im, y.im, t\_3\right)\right) \cdot e^{\log x.im \cdot y.re - t\_1}\\
\mathbf{elif}\;x.re \leq 4.6 \cdot 10^{-161}:\\
\;\;\;\;e^{t\_2 \cdot y.re - t\_0} \cdot \sin \left(t\_2 \cdot y.im + t\_3\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\sin \left(\mathsf{fma}\left(\tan^{-1}_* \frac{x.im}{x.re}, y.re, \log x.re \cdot y.im\right)\right)}{e^{t\_1 - \log x.re \cdot y.re}}\\
\end{array}
\end{array}
if x.re < -1.3999999999999999e-184Initial program 40.5%
Taylor expanded in y.im around 0
lower-sin.f64N/A
lower-*.f64N/A
lower-atan2.f6453.6
Applied rewrites53.6%
lift-+.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
sqr-neg-revN/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
remove-double-negN/A
sqr-neg-revN/A
lift-*.f64N/A
lower-fma.f6453.6
Applied rewrites53.6%
Taylor expanded in x.re around -inf
lower-*.f6431.0
Applied rewrites31.0%
if -1.3999999999999999e-184 < x.re < 6.79999999999999978e-307Initial program 40.5%
Taylor expanded in x.im around inf
lower-*.f64N/A
Applied rewrites32.3%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6432.3
Applied rewrites32.3%
if 6.79999999999999978e-307 < x.re < 4.6e-161Initial program 40.5%
Taylor expanded in x.im around -inf
lower-*.f6417.8
Applied rewrites17.8%
Taylor expanded in x.im around -inf
lower-*.f6431.1
Applied rewrites31.1%
lift-*.f64N/A
mul-1-negN/A
lower-neg.f6431.1
Applied rewrites31.1%
lift-*.f64N/A
mul-1-negN/A
lower-neg.f6431.1
Applied rewrites31.1%
if 4.6e-161 < x.re Initial program 40.5%
Taylor expanded in x.re around inf
lower-*.f64N/A
Applied rewrites32.3%
Applied rewrites32.3%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0 (* y.im (atan2 x.im x.re)))
(t_1 (log (- x.im)))
(t_2 (* (atan2 x.im x.re) y.re)))
(if (<= x.re -1.4e-184)
(*
(exp (- (* (log (* -1.0 x.re)) y.re) (* (atan2 x.im x.re) y.im)))
(sin (* y.re (atan2 x.im x.re))))
(if (<= x.re 6.8e-307)
(* (sin (fma (log x.im) y.im t_2)) (exp (- (* (log x.im) y.re) t_0)))
(if (<= x.re 4.6e-161)
(* (exp (- (* t_1 y.re) t_0)) (sin (fma t_1 y.im t_2)))
(/
(sin (fma (atan2 x.im x.re) y.re (* (log x.re) y.im)))
(exp (- t_0 (* (log x.re) y.re)))))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = y_46_im * atan2(x_46_im, x_46_re);
double t_1 = log(-x_46_im);
double t_2 = atan2(x_46_im, x_46_re) * y_46_re;
double tmp;
if (x_46_re <= -1.4e-184) {
tmp = exp(((log((-1.0 * x_46_re)) * y_46_re) - (atan2(x_46_im, x_46_re) * y_46_im))) * sin((y_46_re * atan2(x_46_im, x_46_re)));
} else if (x_46_re <= 6.8e-307) {
tmp = sin(fma(log(x_46_im), y_46_im, t_2)) * exp(((log(x_46_im) * y_46_re) - t_0));
} else if (x_46_re <= 4.6e-161) {
tmp = exp(((t_1 * y_46_re) - t_0)) * sin(fma(t_1, y_46_im, t_2));
} else {
tmp = sin(fma(atan2(x_46_im, x_46_re), y_46_re, (log(x_46_re) * y_46_im))) / exp((t_0 - (log(x_46_re) * y_46_re)));
}
return tmp;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = Float64(y_46_im * atan(x_46_im, x_46_re)) t_1 = log(Float64(-x_46_im)) t_2 = Float64(atan(x_46_im, x_46_re) * y_46_re) tmp = 0.0 if (x_46_re <= -1.4e-184) tmp = Float64(exp(Float64(Float64(log(Float64(-1.0 * x_46_re)) * y_46_re) - Float64(atan(x_46_im, x_46_re) * y_46_im))) * sin(Float64(y_46_re * atan(x_46_im, x_46_re)))); elseif (x_46_re <= 6.8e-307) tmp = Float64(sin(fma(log(x_46_im), y_46_im, t_2)) * exp(Float64(Float64(log(x_46_im) * y_46_re) - t_0))); elseif (x_46_re <= 4.6e-161) tmp = Float64(exp(Float64(Float64(t_1 * y_46_re) - t_0)) * sin(fma(t_1, y_46_im, t_2))); else tmp = Float64(sin(fma(atan(x_46_im, x_46_re), y_46_re, Float64(log(x_46_re) * y_46_im))) / exp(Float64(t_0 - Float64(log(x_46_re) * y_46_re)))); end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Log[(-x$46$im)], $MachinePrecision]}, Block[{t$95$2 = N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]}, If[LessEqual[x$46$re, -1.4e-184], N[(N[Exp[N[(N[(N[Log[N[(-1.0 * x$46$re), $MachinePrecision]], $MachinePrecision] * y$46$re), $MachinePrecision] - N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[x$46$re, 6.8e-307], N[(N[Sin[N[(N[Log[x$46$im], $MachinePrecision] * y$46$im + t$95$2), $MachinePrecision]], $MachinePrecision] * N[Exp[N[(N[(N[Log[x$46$im], $MachinePrecision] * y$46$re), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[x$46$re, 4.6e-161], N[(N[Exp[N[(N[(t$95$1 * y$46$re), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(t$95$1 * y$46$im + t$95$2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[Sin[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re + N[(N[Log[x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[Exp[N[(t$95$0 - N[(N[Log[x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := y.im \cdot \tan^{-1}_* \frac{x.im}{x.re}\\
t_1 := \log \left(-x.im\right)\\
t_2 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\\
\mathbf{if}\;x.re \leq -1.4 \cdot 10^{-184}:\\
\;\;\;\;e^{\log \left(-1 \cdot x.re\right) \cdot y.re - \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im} \cdot \sin \left(y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\right)\\
\mathbf{elif}\;x.re \leq 6.8 \cdot 10^{-307}:\\
\;\;\;\;\sin \left(\mathsf{fma}\left(\log x.im, y.im, t\_2\right)\right) \cdot e^{\log x.im \cdot y.re - t\_0}\\
\mathbf{elif}\;x.re \leq 4.6 \cdot 10^{-161}:\\
\;\;\;\;e^{t\_1 \cdot y.re - t\_0} \cdot \sin \left(\mathsf{fma}\left(t\_1, y.im, t\_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\sin \left(\mathsf{fma}\left(\tan^{-1}_* \frac{x.im}{x.re}, y.re, \log x.re \cdot y.im\right)\right)}{e^{t\_0 - \log x.re \cdot y.re}}\\
\end{array}
\end{array}
if x.re < -1.3999999999999999e-184Initial program 40.5%
Taylor expanded in y.im around 0
lower-sin.f64N/A
lower-*.f64N/A
lower-atan2.f6453.6
Applied rewrites53.6%
lift-+.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
sqr-neg-revN/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
remove-double-negN/A
sqr-neg-revN/A
lift-*.f64N/A
lower-fma.f6453.6
Applied rewrites53.6%
Taylor expanded in x.re around -inf
lower-*.f6431.0
Applied rewrites31.0%
if -1.3999999999999999e-184 < x.re < 6.79999999999999978e-307Initial program 40.5%
Taylor expanded in x.im around inf
lower-*.f64N/A
Applied rewrites32.3%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6432.3
Applied rewrites32.3%
if 6.79999999999999978e-307 < x.re < 4.6e-161Initial program 40.5%
Taylor expanded in x.im around -inf
lower-*.f6417.8
Applied rewrites17.8%
Taylor expanded in x.im around -inf
lower-*.f6431.1
Applied rewrites31.1%
lift-*.f64N/A
mul-1-negN/A
lower-neg.f6431.1
lower-neg.f64N/A
lower-neg.f64N/A
lower-neg.f64N/A
lower-neg.f64N/A
lower-neg.f64N/A
lower-neg.f64N/A
lower-neg.f64N/A
lower-neg.f64N/A
Applied rewrites31.2%
if 4.6e-161 < x.re Initial program 40.5%
Taylor expanded in x.re around inf
lower-*.f64N/A
Applied rewrites32.3%
Applied rewrites32.3%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0 (* y.im (atan2 x.im x.re))))
(if (<= x.re -1.4e-184)
(*
(exp (- (* (log (* -1.0 x.re)) y.re) (* (atan2 x.im x.re) y.im)))
(sin (* y.re (atan2 x.im x.re))))
(if (<= x.re -1e-310)
(*
(sin (fma (log x.im) y.im (* (atan2 x.im x.re) y.re)))
(exp (- (* (log x.im) y.re) t_0)))
(/
(sin (fma (atan2 x.im x.re) y.re (* (log x.re) y.im)))
(exp (- t_0 (* (log x.re) y.re))))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = y_46_im * atan2(x_46_im, x_46_re);
double tmp;
if (x_46_re <= -1.4e-184) {
tmp = exp(((log((-1.0 * x_46_re)) * y_46_re) - (atan2(x_46_im, x_46_re) * y_46_im))) * sin((y_46_re * atan2(x_46_im, x_46_re)));
} else if (x_46_re <= -1e-310) {
tmp = sin(fma(log(x_46_im), y_46_im, (atan2(x_46_im, x_46_re) * y_46_re))) * exp(((log(x_46_im) * y_46_re) - t_0));
} else {
tmp = sin(fma(atan2(x_46_im, x_46_re), y_46_re, (log(x_46_re) * y_46_im))) / exp((t_0 - (log(x_46_re) * y_46_re)));
}
return tmp;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = Float64(y_46_im * atan(x_46_im, x_46_re)) tmp = 0.0 if (x_46_re <= -1.4e-184) tmp = Float64(exp(Float64(Float64(log(Float64(-1.0 * x_46_re)) * y_46_re) - Float64(atan(x_46_im, x_46_re) * y_46_im))) * sin(Float64(y_46_re * atan(x_46_im, x_46_re)))); elseif (x_46_re <= -1e-310) tmp = Float64(sin(fma(log(x_46_im), y_46_im, Float64(atan(x_46_im, x_46_re) * y_46_re))) * exp(Float64(Float64(log(x_46_im) * y_46_re) - t_0))); else tmp = Float64(sin(fma(atan(x_46_im, x_46_re), y_46_re, Float64(log(x_46_re) * y_46_im))) / exp(Float64(t_0 - Float64(log(x_46_re) * y_46_re)))); end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x$46$re, -1.4e-184], N[(N[Exp[N[(N[(N[Log[N[(-1.0 * x$46$re), $MachinePrecision]], $MachinePrecision] * y$46$re), $MachinePrecision] - N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[x$46$re, -1e-310], N[(N[Sin[N[(N[Log[x$46$im], $MachinePrecision] * y$46$im + N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Exp[N[(N[(N[Log[x$46$im], $MachinePrecision] * y$46$re), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[Sin[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re + N[(N[Log[x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[Exp[N[(t$95$0 - N[(N[Log[x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := y.im \cdot \tan^{-1}_* \frac{x.im}{x.re}\\
\mathbf{if}\;x.re \leq -1.4 \cdot 10^{-184}:\\
\;\;\;\;e^{\log \left(-1 \cdot x.re\right) \cdot y.re - \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im} \cdot \sin \left(y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\right)\\
\mathbf{elif}\;x.re \leq -1 \cdot 10^{-310}:\\
\;\;\;\;\sin \left(\mathsf{fma}\left(\log x.im, y.im, \tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\right)\right) \cdot e^{\log x.im \cdot y.re - t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sin \left(\mathsf{fma}\left(\tan^{-1}_* \frac{x.im}{x.re}, y.re, \log x.re \cdot y.im\right)\right)}{e^{t\_0 - \log x.re \cdot y.re}}\\
\end{array}
\end{array}
if x.re < -1.3999999999999999e-184Initial program 40.5%
Taylor expanded in y.im around 0
lower-sin.f64N/A
lower-*.f64N/A
lower-atan2.f6453.6
Applied rewrites53.6%
lift-+.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
sqr-neg-revN/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
remove-double-negN/A
sqr-neg-revN/A
lift-*.f64N/A
lower-fma.f6453.6
Applied rewrites53.6%
Taylor expanded in x.re around -inf
lower-*.f6431.0
Applied rewrites31.0%
if -1.3999999999999999e-184 < x.re < -9.999999999999969e-311Initial program 40.5%
Taylor expanded in x.im around inf
lower-*.f64N/A
Applied rewrites32.3%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6432.3
Applied rewrites32.3%
if -9.999999999999969e-311 < x.re Initial program 40.5%
Taylor expanded in x.re around inf
lower-*.f64N/A
Applied rewrites32.3%
Applied rewrites32.3%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0 (* (atan2 x.im x.re) y.im))
(t_1 (log (/ 1.0 x.re)))
(t_2 (* y.re (atan2 x.im x.re)))
(t_3 (sin t_2)))
(if (<= x.re -1.4e-184)
(* (exp (- (* (log (* -1.0 x.re)) y.re) t_0)) t_3)
(if (<= x.re -2.9e-295)
(*
(sin (fma (log x.im) y.im (* (atan2 x.im x.re) y.re)))
(exp (- (* (log x.im) y.re) (* y.im (atan2 x.im x.re)))))
(if (<= x.re 7.5e-10)
(*
(exp (- (* (log (sqrt (fma x.re x.re (* x.im x.im)))) y.re) t_0))
t_3)
(* (exp (* -1.0 (* y.re t_1))) (sin (fma -1.0 (* y.im t_1) t_2))))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = atan2(x_46_im, x_46_re) * y_46_im;
double t_1 = log((1.0 / x_46_re));
double t_2 = y_46_re * atan2(x_46_im, x_46_re);
double t_3 = sin(t_2);
double tmp;
if (x_46_re <= -1.4e-184) {
tmp = exp(((log((-1.0 * x_46_re)) * y_46_re) - t_0)) * t_3;
} else if (x_46_re <= -2.9e-295) {
tmp = sin(fma(log(x_46_im), y_46_im, (atan2(x_46_im, x_46_re) * y_46_re))) * exp(((log(x_46_im) * y_46_re) - (y_46_im * atan2(x_46_im, x_46_re))));
} else if (x_46_re <= 7.5e-10) {
tmp = exp(((log(sqrt(fma(x_46_re, x_46_re, (x_46_im * x_46_im)))) * y_46_re) - t_0)) * t_3;
} else {
tmp = exp((-1.0 * (y_46_re * t_1))) * sin(fma(-1.0, (y_46_im * t_1), t_2));
}
return tmp;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = Float64(atan(x_46_im, x_46_re) * y_46_im) t_1 = log(Float64(1.0 / x_46_re)) t_2 = Float64(y_46_re * atan(x_46_im, x_46_re)) t_3 = sin(t_2) tmp = 0.0 if (x_46_re <= -1.4e-184) tmp = Float64(exp(Float64(Float64(log(Float64(-1.0 * x_46_re)) * y_46_re) - t_0)) * t_3); elseif (x_46_re <= -2.9e-295) tmp = Float64(sin(fma(log(x_46_im), y_46_im, Float64(atan(x_46_im, x_46_re) * y_46_re))) * exp(Float64(Float64(log(x_46_im) * y_46_re) - Float64(y_46_im * atan(x_46_im, x_46_re))))); elseif (x_46_re <= 7.5e-10) tmp = Float64(exp(Float64(Float64(log(sqrt(fma(x_46_re, x_46_re, Float64(x_46_im * x_46_im)))) * y_46_re) - t_0)) * t_3); else tmp = Float64(exp(Float64(-1.0 * Float64(y_46_re * t_1))) * sin(fma(-1.0, Float64(y_46_im * t_1), t_2))); end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]}, Block[{t$95$1 = N[Log[N[(1.0 / x$46$re), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[Sin[t$95$2], $MachinePrecision]}, If[LessEqual[x$46$re, -1.4e-184], N[(N[Exp[N[(N[(N[Log[N[(-1.0 * x$46$re), $MachinePrecision]], $MachinePrecision] * y$46$re), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision] * t$95$3), $MachinePrecision], If[LessEqual[x$46$re, -2.9e-295], N[(N[Sin[N[(N[Log[x$46$im], $MachinePrecision] * y$46$im + N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Exp[N[(N[(N[Log[x$46$im], $MachinePrecision] * y$46$re), $MachinePrecision] - N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[x$46$re, 7.5e-10], N[(N[Exp[N[(N[(N[Log[N[Sqrt[N[(x$46$re * x$46$re + N[(x$46$im * x$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * y$46$re), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision] * t$95$3), $MachinePrecision], N[(N[Exp[N[(-1.0 * N[(y$46$re * t$95$1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(-1.0 * N[(y$46$im * t$95$1), $MachinePrecision] + t$95$2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im\\
t_1 := \log \left(\frac{1}{x.re}\right)\\
t_2 := y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\\
t_3 := \sin t\_2\\
\mathbf{if}\;x.re \leq -1.4 \cdot 10^{-184}:\\
\;\;\;\;e^{\log \left(-1 \cdot x.re\right) \cdot y.re - t\_0} \cdot t\_3\\
\mathbf{elif}\;x.re \leq -2.9 \cdot 10^{-295}:\\
\;\;\;\;\sin \left(\mathsf{fma}\left(\log x.im, y.im, \tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\right)\right) \cdot e^{\log x.im \cdot y.re - y.im \cdot \tan^{-1}_* \frac{x.im}{x.re}}\\
\mathbf{elif}\;x.re \leq 7.5 \cdot 10^{-10}:\\
\;\;\;\;e^{\log \left(\sqrt{\mathsf{fma}\left(x.re, x.re, x.im \cdot x.im\right)}\right) \cdot y.re - t\_0} \cdot t\_3\\
\mathbf{else}:\\
\;\;\;\;e^{-1 \cdot \left(y.re \cdot t\_1\right)} \cdot \sin \left(\mathsf{fma}\left(-1, y.im \cdot t\_1, t\_2\right)\right)\\
\end{array}
\end{array}
if x.re < -1.3999999999999999e-184Initial program 40.5%
Taylor expanded in y.im around 0
lower-sin.f64N/A
lower-*.f64N/A
lower-atan2.f6453.6
Applied rewrites53.6%
lift-+.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
sqr-neg-revN/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
remove-double-negN/A
sqr-neg-revN/A
lift-*.f64N/A
lower-fma.f6453.6
Applied rewrites53.6%
Taylor expanded in x.re around -inf
lower-*.f6431.0
Applied rewrites31.0%
if -1.3999999999999999e-184 < x.re < -2.90000000000000015e-295Initial program 40.5%
Taylor expanded in x.im around inf
lower-*.f64N/A
Applied rewrites32.3%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6432.3
Applied rewrites32.3%
if -2.90000000000000015e-295 < x.re < 7.49999999999999995e-10Initial program 40.5%
Taylor expanded in y.im around 0
lower-sin.f64N/A
lower-*.f64N/A
lower-atan2.f6453.6
Applied rewrites53.6%
lift-+.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
sqr-neg-revN/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
remove-double-negN/A
sqr-neg-revN/A
lift-*.f64N/A
lower-fma.f6453.6
Applied rewrites53.6%
if 7.49999999999999995e-10 < x.re Initial program 40.5%
Taylor expanded in x.re around inf
lower-*.f64N/A
Applied rewrites32.3%
Taylor expanded in y.im around 0
lower-exp.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f6424.7
Applied rewrites24.7%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0 (* (atan2 x.im x.re) y.im))
(t_1 (* y.re (atan2 x.im x.re)))
(t_2 (sin t_1))
(t_3 (* (log (sqrt (fma x.re x.re (* x.im x.im)))) y.re))
(t_4 (log (/ 1.0 x.re))))
(if (<= x.re -1.1e-180)
(* (exp (- (* (log (* -1.0 x.re)) y.re) t_0)) t_2)
(if (<= x.re 5.8e-132)
(*
(sin (* (- (atan2 x.im x.re)) y.re))
(exp (- t_3 (* y.im (atan2 x.im x.re)))))
(if (<= x.re 7.5e-10)
(* (exp (- t_3 t_0)) t_2)
(* (exp (* -1.0 (* y.re t_4))) (sin (fma -1.0 (* y.im t_4) t_1))))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = atan2(x_46_im, x_46_re) * y_46_im;
double t_1 = y_46_re * atan2(x_46_im, x_46_re);
double t_2 = sin(t_1);
double t_3 = log(sqrt(fma(x_46_re, x_46_re, (x_46_im * x_46_im)))) * y_46_re;
double t_4 = log((1.0 / x_46_re));
double tmp;
if (x_46_re <= -1.1e-180) {
tmp = exp(((log((-1.0 * x_46_re)) * y_46_re) - t_0)) * t_2;
} else if (x_46_re <= 5.8e-132) {
tmp = sin((-atan2(x_46_im, x_46_re) * y_46_re)) * exp((t_3 - (y_46_im * atan2(x_46_im, x_46_re))));
} else if (x_46_re <= 7.5e-10) {
tmp = exp((t_3 - t_0)) * t_2;
} else {
tmp = exp((-1.0 * (y_46_re * t_4))) * sin(fma(-1.0, (y_46_im * t_4), t_1));
}
return tmp;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = Float64(atan(x_46_im, x_46_re) * y_46_im) t_1 = Float64(y_46_re * atan(x_46_im, x_46_re)) t_2 = sin(t_1) t_3 = Float64(log(sqrt(fma(x_46_re, x_46_re, Float64(x_46_im * x_46_im)))) * y_46_re) t_4 = log(Float64(1.0 / x_46_re)) tmp = 0.0 if (x_46_re <= -1.1e-180) tmp = Float64(exp(Float64(Float64(log(Float64(-1.0 * x_46_re)) * y_46_re) - t_0)) * t_2); elseif (x_46_re <= 5.8e-132) tmp = Float64(sin(Float64(Float64(-atan(x_46_im, x_46_re)) * y_46_re)) * exp(Float64(t_3 - Float64(y_46_im * atan(x_46_im, x_46_re))))); elseif (x_46_re <= 7.5e-10) tmp = Float64(exp(Float64(t_3 - t_0)) * t_2); else tmp = Float64(exp(Float64(-1.0 * Float64(y_46_re * t_4))) * sin(fma(-1.0, Float64(y_46_im * t_4), t_1))); end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]}, Block[{t$95$1 = N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Sin[t$95$1], $MachinePrecision]}, Block[{t$95$3 = N[(N[Log[N[Sqrt[N[(x$46$re * x$46$re + N[(x$46$im * x$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * y$46$re), $MachinePrecision]}, Block[{t$95$4 = N[Log[N[(1.0 / x$46$re), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[x$46$re, -1.1e-180], N[(N[Exp[N[(N[(N[Log[N[(-1.0 * x$46$re), $MachinePrecision]], $MachinePrecision] * y$46$re), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision] * t$95$2), $MachinePrecision], If[LessEqual[x$46$re, 5.8e-132], N[(N[Sin[N[((-N[ArcTan[x$46$im / x$46$re], $MachinePrecision]) * y$46$re), $MachinePrecision]], $MachinePrecision] * N[Exp[N[(t$95$3 - N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[x$46$re, 7.5e-10], N[(N[Exp[N[(t$95$3 - t$95$0), $MachinePrecision]], $MachinePrecision] * t$95$2), $MachinePrecision], N[(N[Exp[N[(-1.0 * N[(y$46$re * t$95$4), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(-1.0 * N[(y$46$im * t$95$4), $MachinePrecision] + t$95$1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im\\
t_1 := y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\\
t_2 := \sin t\_1\\
t_3 := \log \left(\sqrt{\mathsf{fma}\left(x.re, x.re, x.im \cdot x.im\right)}\right) \cdot y.re\\
t_4 := \log \left(\frac{1}{x.re}\right)\\
\mathbf{if}\;x.re \leq -1.1 \cdot 10^{-180}:\\
\;\;\;\;e^{\log \left(-1 \cdot x.re\right) \cdot y.re - t\_0} \cdot t\_2\\
\mathbf{elif}\;x.re \leq 5.8 \cdot 10^{-132}:\\
\;\;\;\;\sin \left(\left(-\tan^{-1}_* \frac{x.im}{x.re}\right) \cdot y.re\right) \cdot e^{t\_3 - y.im \cdot \tan^{-1}_* \frac{x.im}{x.re}}\\
\mathbf{elif}\;x.re \leq 7.5 \cdot 10^{-10}:\\
\;\;\;\;e^{t\_3 - t\_0} \cdot t\_2\\
\mathbf{else}:\\
\;\;\;\;e^{-1 \cdot \left(y.re \cdot t\_4\right)} \cdot \sin \left(\mathsf{fma}\left(-1, y.im \cdot t\_4, t\_1\right)\right)\\
\end{array}
\end{array}
if x.re < -1.10000000000000007e-180Initial program 40.5%
Taylor expanded in y.im around 0
lower-sin.f64N/A
lower-*.f64N/A
lower-atan2.f6453.6
Applied rewrites53.6%
lift-+.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
sqr-neg-revN/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
remove-double-negN/A
sqr-neg-revN/A
lift-*.f64N/A
lower-fma.f6453.6
Applied rewrites53.6%
Taylor expanded in x.re around -inf
lower-*.f6431.0
Applied rewrites31.0%
if -1.10000000000000007e-180 < x.re < 5.79999999999999967e-132Initial program 40.5%
lift-sin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
fp-cancel-sign-sub-invN/A
sub-negate-revN/A
sin-negN/A
sin-+PI-revN/A
lower-sin.f64N/A
lower-+.f64N/A
Applied rewrites29.0%
Taylor expanded in y.re around inf
lower-*.f64N/A
lower-*.f64N/A
lower-atan2.f6447.1
Applied rewrites47.1%
Applied rewrites47.1%
if 5.79999999999999967e-132 < x.re < 7.49999999999999995e-10Initial program 40.5%
Taylor expanded in y.im around 0
lower-sin.f64N/A
lower-*.f64N/A
lower-atan2.f6453.6
Applied rewrites53.6%
lift-+.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
sqr-neg-revN/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
remove-double-negN/A
sqr-neg-revN/A
lift-*.f64N/A
lower-fma.f6453.6
Applied rewrites53.6%
if 7.49999999999999995e-10 < x.re Initial program 40.5%
Taylor expanded in x.re around inf
lower-*.f64N/A
Applied rewrites32.3%
Taylor expanded in y.im around 0
lower-exp.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f6424.7
Applied rewrites24.7%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0 (* (atan2 x.im x.re) y.im))
(t_1 (* y.re (atan2 x.im x.re)))
(t_2 (sin t_1))
(t_3 (log (/ 1.0 x.re))))
(if (<= x.re -2.9e-142)
(* (exp (- (* (log (* -1.0 x.re)) y.re) t_0)) t_2)
(if (<= x.re 7.5e-10)
(*
(exp (- (* (log (sqrt (fma x.re x.re (* x.im x.im)))) y.re) t_0))
t_2)
(* (exp (* -1.0 (* y.re t_3))) (sin (fma -1.0 (* y.im t_3) t_1)))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = atan2(x_46_im, x_46_re) * y_46_im;
double t_1 = y_46_re * atan2(x_46_im, x_46_re);
double t_2 = sin(t_1);
double t_3 = log((1.0 / x_46_re));
double tmp;
if (x_46_re <= -2.9e-142) {
tmp = exp(((log((-1.0 * x_46_re)) * y_46_re) - t_0)) * t_2;
} else if (x_46_re <= 7.5e-10) {
tmp = exp(((log(sqrt(fma(x_46_re, x_46_re, (x_46_im * x_46_im)))) * y_46_re) - t_0)) * t_2;
} else {
tmp = exp((-1.0 * (y_46_re * t_3))) * sin(fma(-1.0, (y_46_im * t_3), t_1));
}
return tmp;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = Float64(atan(x_46_im, x_46_re) * y_46_im) t_1 = Float64(y_46_re * atan(x_46_im, x_46_re)) t_2 = sin(t_1) t_3 = log(Float64(1.0 / x_46_re)) tmp = 0.0 if (x_46_re <= -2.9e-142) tmp = Float64(exp(Float64(Float64(log(Float64(-1.0 * x_46_re)) * y_46_re) - t_0)) * t_2); elseif (x_46_re <= 7.5e-10) tmp = Float64(exp(Float64(Float64(log(sqrt(fma(x_46_re, x_46_re, Float64(x_46_im * x_46_im)))) * y_46_re) - t_0)) * t_2); else tmp = Float64(exp(Float64(-1.0 * Float64(y_46_re * t_3))) * sin(fma(-1.0, Float64(y_46_im * t_3), t_1))); end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]}, Block[{t$95$1 = N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Sin[t$95$1], $MachinePrecision]}, Block[{t$95$3 = N[Log[N[(1.0 / x$46$re), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[x$46$re, -2.9e-142], N[(N[Exp[N[(N[(N[Log[N[(-1.0 * x$46$re), $MachinePrecision]], $MachinePrecision] * y$46$re), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision] * t$95$2), $MachinePrecision], If[LessEqual[x$46$re, 7.5e-10], N[(N[Exp[N[(N[(N[Log[N[Sqrt[N[(x$46$re * x$46$re + N[(x$46$im * x$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * y$46$re), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision] * t$95$2), $MachinePrecision], N[(N[Exp[N[(-1.0 * N[(y$46$re * t$95$3), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(-1.0 * N[(y$46$im * t$95$3), $MachinePrecision] + t$95$1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im\\
t_1 := y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\\
t_2 := \sin t\_1\\
t_3 := \log \left(\frac{1}{x.re}\right)\\
\mathbf{if}\;x.re \leq -2.9 \cdot 10^{-142}:\\
\;\;\;\;e^{\log \left(-1 \cdot x.re\right) \cdot y.re - t\_0} \cdot t\_2\\
\mathbf{elif}\;x.re \leq 7.5 \cdot 10^{-10}:\\
\;\;\;\;e^{\log \left(\sqrt{\mathsf{fma}\left(x.re, x.re, x.im \cdot x.im\right)}\right) \cdot y.re - t\_0} \cdot t\_2\\
\mathbf{else}:\\
\;\;\;\;e^{-1 \cdot \left(y.re \cdot t\_3\right)} \cdot \sin \left(\mathsf{fma}\left(-1, y.im \cdot t\_3, t\_1\right)\right)\\
\end{array}
\end{array}
if x.re < -2.8999999999999999e-142Initial program 40.5%
Taylor expanded in y.im around 0
lower-sin.f64N/A
lower-*.f64N/A
lower-atan2.f6453.6
Applied rewrites53.6%
lift-+.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
sqr-neg-revN/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
remove-double-negN/A
sqr-neg-revN/A
lift-*.f64N/A
lower-fma.f6453.6
Applied rewrites53.6%
Taylor expanded in x.re around -inf
lower-*.f6431.0
Applied rewrites31.0%
if -2.8999999999999999e-142 < x.re < 7.49999999999999995e-10Initial program 40.5%
Taylor expanded in y.im around 0
lower-sin.f64N/A
lower-*.f64N/A
lower-atan2.f6453.6
Applied rewrites53.6%
lift-+.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
sqr-neg-revN/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
remove-double-negN/A
sqr-neg-revN/A
lift-*.f64N/A
lower-fma.f6453.6
Applied rewrites53.6%
if 7.49999999999999995e-10 < x.re Initial program 40.5%
Taylor expanded in x.re around inf
lower-*.f64N/A
Applied rewrites32.3%
Taylor expanded in y.im around 0
lower-exp.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f6424.7
Applied rewrites24.7%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0 (* (atan2 x.im x.re) y.im))
(t_1 (* y.re (atan2 x.im x.re)))
(t_2 (log (/ 1.0 x.re))))
(if (<= x.re -2e-148)
(* (exp (- (* (log (* -1.0 x.re)) y.re) t_0)) (sin t_1))
(if (<= x.re 3.9e-118)
(*
(exp (- (* (log (sqrt (+ (* x.re x.re) (* x.im x.im)))) y.re) t_0))
(sin PI))
(* (exp (* -1.0 (* y.re t_2))) (sin (fma -1.0 (* y.im t_2) t_1)))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = atan2(x_46_im, x_46_re) * y_46_im;
double t_1 = y_46_re * atan2(x_46_im, x_46_re);
double t_2 = log((1.0 / x_46_re));
double tmp;
if (x_46_re <= -2e-148) {
tmp = exp(((log((-1.0 * x_46_re)) * y_46_re) - t_0)) * sin(t_1);
} else if (x_46_re <= 3.9e-118) {
tmp = exp(((log(sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im)))) * y_46_re) - t_0)) * sin(((double) M_PI));
} else {
tmp = exp((-1.0 * (y_46_re * t_2))) * sin(fma(-1.0, (y_46_im * t_2), t_1));
}
return tmp;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = Float64(atan(x_46_im, x_46_re) * y_46_im) t_1 = Float64(y_46_re * atan(x_46_im, x_46_re)) t_2 = log(Float64(1.0 / x_46_re)) tmp = 0.0 if (x_46_re <= -2e-148) tmp = Float64(exp(Float64(Float64(log(Float64(-1.0 * x_46_re)) * y_46_re) - t_0)) * sin(t_1)); elseif (x_46_re <= 3.9e-118) tmp = Float64(exp(Float64(Float64(log(sqrt(Float64(Float64(x_46_re * x_46_re) + Float64(x_46_im * x_46_im)))) * y_46_re) - t_0)) * sin(pi)); else tmp = Float64(exp(Float64(-1.0 * Float64(y_46_re * t_2))) * sin(fma(-1.0, Float64(y_46_im * t_2), t_1))); end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]}, Block[{t$95$1 = N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Log[N[(1.0 / x$46$re), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[x$46$re, -2e-148], N[(N[Exp[N[(N[(N[Log[N[(-1.0 * x$46$re), $MachinePrecision]], $MachinePrecision] * y$46$re), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision], If[LessEqual[x$46$re, 3.9e-118], N[(N[Exp[N[(N[(N[Log[N[Sqrt[N[(N[(x$46$re * x$46$re), $MachinePrecision] + N[(x$46$im * x$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * y$46$re), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision] * N[Sin[Pi], $MachinePrecision]), $MachinePrecision], N[(N[Exp[N[(-1.0 * N[(y$46$re * t$95$2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(-1.0 * N[(y$46$im * t$95$2), $MachinePrecision] + t$95$1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im\\
t_1 := y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\\
t_2 := \log \left(\frac{1}{x.re}\right)\\
\mathbf{if}\;x.re \leq -2 \cdot 10^{-148}:\\
\;\;\;\;e^{\log \left(-1 \cdot x.re\right) \cdot y.re - t\_0} \cdot \sin t\_1\\
\mathbf{elif}\;x.re \leq 3.9 \cdot 10^{-118}:\\
\;\;\;\;e^{\log \left(\sqrt{x.re \cdot x.re + x.im \cdot x.im}\right) \cdot y.re - t\_0} \cdot \sin \pi\\
\mathbf{else}:\\
\;\;\;\;e^{-1 \cdot \left(y.re \cdot t\_2\right)} \cdot \sin \left(\mathsf{fma}\left(-1, y.im \cdot t\_2, t\_1\right)\right)\\
\end{array}
\end{array}
if x.re < -1.99999999999999987e-148Initial program 40.5%
Taylor expanded in y.im around 0
lower-sin.f64N/A
lower-*.f64N/A
lower-atan2.f6453.6
Applied rewrites53.6%
lift-+.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
sqr-neg-revN/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
remove-double-negN/A
sqr-neg-revN/A
lift-*.f64N/A
lower-fma.f6453.6
Applied rewrites53.6%
Taylor expanded in x.re around -inf
lower-*.f6431.0
Applied rewrites31.0%
if -1.99999999999999987e-148 < x.re < 3.90000000000000001e-118Initial program 40.5%
lift-sin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
fp-cancel-sign-sub-invN/A
sub-negate-revN/A
sin-negN/A
sin-+PI-revN/A
lower-sin.f64N/A
lower-+.f64N/A
Applied rewrites29.0%
Taylor expanded in y.im around 0
lower--.f64N/A
lower-PI.f64N/A
lower-*.f64N/A
lower-atan2.f6449.7
Applied rewrites49.7%
Taylor expanded in y.re around 0
lower-PI.f6449.3
Applied rewrites49.3%
if 3.90000000000000001e-118 < x.re Initial program 40.5%
Taylor expanded in x.re around inf
lower-*.f64N/A
Applied rewrites32.3%
Taylor expanded in y.im around 0
lower-exp.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f6424.7
Applied rewrites24.7%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0
(*
(exp
(-
(* (log (sqrt (+ (* x.re x.re) (* x.im x.im)))) y.re)
(* (atan2 x.im x.re) y.im)))
(sin PI))))
(if (<= y.re -135000.0)
t_0
(if (<= y.re 1.58e-18)
(*
(exp (- (* y.im (atan2 x.im x.re))))
(sin (* y.re (atan2 x.im x.re))))
t_0))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = exp(((log(sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im)))) * y_46_re) - (atan2(x_46_im, x_46_re) * y_46_im))) * sin(((double) M_PI));
double tmp;
if (y_46_re <= -135000.0) {
tmp = t_0;
} else if (y_46_re <= 1.58e-18) {
tmp = exp(-(y_46_im * atan2(x_46_im, x_46_re))) * sin((y_46_re * atan2(x_46_im, x_46_re)));
} else {
tmp = t_0;
}
return tmp;
}
public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = Math.exp(((Math.log(Math.sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im)))) * y_46_re) - (Math.atan2(x_46_im, x_46_re) * y_46_im))) * Math.sin(Math.PI);
double tmp;
if (y_46_re <= -135000.0) {
tmp = t_0;
} else if (y_46_re <= 1.58e-18) {
tmp = Math.exp(-(y_46_im * Math.atan2(x_46_im, x_46_re))) * Math.sin((y_46_re * Math.atan2(x_46_im, x_46_re)));
} else {
tmp = t_0;
}
return tmp;
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): t_0 = math.exp(((math.log(math.sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im)))) * y_46_re) - (math.atan2(x_46_im, x_46_re) * y_46_im))) * math.sin(math.pi) tmp = 0 if y_46_re <= -135000.0: tmp = t_0 elif y_46_re <= 1.58e-18: tmp = math.exp(-(y_46_im * math.atan2(x_46_im, x_46_re))) * math.sin((y_46_re * math.atan2(x_46_im, x_46_re))) else: tmp = t_0 return tmp
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = Float64(exp(Float64(Float64(log(sqrt(Float64(Float64(x_46_re * x_46_re) + Float64(x_46_im * x_46_im)))) * y_46_re) - Float64(atan(x_46_im, x_46_re) * y_46_im))) * sin(pi)) tmp = 0.0 if (y_46_re <= -135000.0) tmp = t_0; elseif (y_46_re <= 1.58e-18) tmp = Float64(exp(Float64(-Float64(y_46_im * atan(x_46_im, x_46_re)))) * sin(Float64(y_46_re * atan(x_46_im, x_46_re)))); else tmp = t_0; end return tmp end
function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = exp(((log(sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im)))) * y_46_re) - (atan2(x_46_im, x_46_re) * y_46_im))) * sin(pi); tmp = 0.0; if (y_46_re <= -135000.0) tmp = t_0; elseif (y_46_re <= 1.58e-18) tmp = exp(-(y_46_im * atan2(x_46_im, x_46_re))) * sin((y_46_re * atan2(x_46_im, x_46_re))); else tmp = t_0; end tmp_2 = tmp; end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(N[Exp[N[(N[(N[Log[N[Sqrt[N[(N[(x$46$re * x$46$re), $MachinePrecision] + N[(x$46$im * x$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * y$46$re), $MachinePrecision] - N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sin[Pi], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y$46$re, -135000.0], t$95$0, If[LessEqual[y$46$re, 1.58e-18], N[(N[Exp[(-N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision])], $MachinePrecision] * N[Sin[N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := e^{\log \left(\sqrt{x.re \cdot x.re + x.im \cdot x.im}\right) \cdot y.re - \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im} \cdot \sin \pi\\
\mathbf{if}\;y.re \leq -135000:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y.re \leq 1.58 \cdot 10^{-18}:\\
\;\;\;\;e^{-y.im \cdot \tan^{-1}_* \frac{x.im}{x.re}} \cdot \sin \left(y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if y.re < -135000 or 1.5800000000000001e-18 < y.re Initial program 40.5%
lift-sin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
fp-cancel-sign-sub-invN/A
sub-negate-revN/A
sin-negN/A
sin-+PI-revN/A
lower-sin.f64N/A
lower-+.f64N/A
Applied rewrites29.0%
Taylor expanded in y.im around 0
lower--.f64N/A
lower-PI.f64N/A
lower-*.f64N/A
lower-atan2.f6449.7
Applied rewrites49.7%
Taylor expanded in y.re around 0
lower-PI.f6449.3
Applied rewrites49.3%
if -135000 < y.re < 1.5800000000000001e-18Initial program 40.5%
Taylor expanded in y.im around 0
lower-sin.f64N/A
lower-*.f64N/A
lower-atan2.f6453.6
Applied rewrites53.6%
lift-+.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
sqr-neg-revN/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
remove-double-negN/A
sqr-neg-revN/A
lift-*.f64N/A
lower-fma.f6453.6
Applied rewrites53.6%
Taylor expanded in y.re around 0
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f6440.2
Applied rewrites40.2%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0 (sin (* y.re (atan2 x.im x.re)))))
(if (<= y.re -8e+64)
(* (pow x.im y.re) t_0)
(if (<= y.re 6e+44)
(* (exp (- (* y.im (atan2 x.im x.re)))) t_0)
(log (pow (sqrt (fma x.im x.im (* x.re x.re))) y.im))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = sin((y_46_re * atan2(x_46_im, x_46_re)));
double tmp;
if (y_46_re <= -8e+64) {
tmp = pow(x_46_im, y_46_re) * t_0;
} else if (y_46_re <= 6e+44) {
tmp = exp(-(y_46_im * atan2(x_46_im, x_46_re))) * t_0;
} else {
tmp = log(pow(sqrt(fma(x_46_im, x_46_im, (x_46_re * x_46_re))), y_46_im));
}
return tmp;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = sin(Float64(y_46_re * atan(x_46_im, x_46_re))) tmp = 0.0 if (y_46_re <= -8e+64) tmp = Float64((x_46_im ^ y_46_re) * t_0); elseif (y_46_re <= 6e+44) tmp = Float64(exp(Float64(-Float64(y_46_im * atan(x_46_im, x_46_re)))) * t_0); else tmp = log((sqrt(fma(x_46_im, x_46_im, Float64(x_46_re * x_46_re))) ^ y_46_im)); end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[Sin[N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y$46$re, -8e+64], N[(N[Power[x$46$im, y$46$re], $MachinePrecision] * t$95$0), $MachinePrecision], If[LessEqual[y$46$re, 6e+44], N[(N[Exp[(-N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision])], $MachinePrecision] * t$95$0), $MachinePrecision], N[Log[N[Power[N[Sqrt[N[(x$46$im * x$46$im + N[(x$46$re * x$46$re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], y$46$im], $MachinePrecision]], $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sin \left(y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\right)\\
\mathbf{if}\;y.re \leq -8 \cdot 10^{+64}:\\
\;\;\;\;{x.im}^{y.re} \cdot t\_0\\
\mathbf{elif}\;y.re \leq 6 \cdot 10^{+44}:\\
\;\;\;\;e^{-y.im \cdot \tan^{-1}_* \frac{x.im}{x.re}} \cdot t\_0\\
\mathbf{else}:\\
\;\;\;\;\log \left({\left(\sqrt{\mathsf{fma}\left(x.im, x.im, x.re \cdot x.re\right)}\right)}^{y.im}\right)\\
\end{array}
\end{array}
if y.re < -8.00000000000000017e64Initial program 40.5%
Taylor expanded in x.im around inf
lower-*.f64N/A
Applied rewrites32.3%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-atan2.f6419.2
Applied rewrites19.2%
Taylor expanded in x.im around 0
lower-pow.f6431.5
Applied rewrites31.5%
if -8.00000000000000017e64 < y.re < 5.99999999999999974e44Initial program 40.5%
Taylor expanded in y.im around 0
lower-sin.f64N/A
lower-*.f64N/A
lower-atan2.f6453.6
Applied rewrites53.6%
lift-+.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
sqr-neg-revN/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
remove-double-negN/A
sqr-neg-revN/A
lift-*.f64N/A
lower-fma.f6453.6
Applied rewrites53.6%
Taylor expanded in y.re around 0
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f6440.2
Applied rewrites40.2%
if 5.99999999999999974e44 < y.re Initial program 40.5%
Taylor expanded in y.re around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6422.6
Applied rewrites22.6%
lift-*.f64N/A
*-commutativeN/A
lift-exp.f64N/A
lift-neg.f64N/A
exp-negN/A
mult-flip-revN/A
lower-/.f64N/A
Applied rewrites22.6%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6418.3
Applied rewrites18.3%
lift-*.f64N/A
lift-log.f64N/A
log-pow-revN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
lift-pow.f64N/A
pow2N/A
lift-pow.f64N/A
pow2N/A
pow1/2N/A
lower-log.f64N/A
pow1/2N/A
+-commutativeN/A
lift-+.f64N/A
lift-*.f64N/A
lift-*.f64N/A
pow1/2N/A
lift-sqrt.f64N/A
Applied rewrites23.0%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0 (exp (* y.im (atan2 x.im x.re))))
(t_1 (* (pow x.im y.re) (sin (* y.re (atan2 x.im x.re)))))
(t_2 (/ (sin (* -1.0 (* y.im (log (/ -1.0 x.im))))) t_0)))
(if (<= x.im -9e+62)
t_2
(if (<= x.im -1.2e+16)
t_1
(if (<= x.im -9.5e-202)
t_2
(if (<= x.im 1.45e-252)
(log (pow (sqrt (fma x.im x.im (* x.re x.re))) y.im))
(if (<= x.im 1.65e+218)
(/ (sin (* -1.0 (* y.im (log (/ 1.0 x.im))))) t_0)
t_1)))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = exp((y_46_im * atan2(x_46_im, x_46_re)));
double t_1 = pow(x_46_im, y_46_re) * sin((y_46_re * atan2(x_46_im, x_46_re)));
double t_2 = sin((-1.0 * (y_46_im * log((-1.0 / x_46_im))))) / t_0;
double tmp;
if (x_46_im <= -9e+62) {
tmp = t_2;
} else if (x_46_im <= -1.2e+16) {
tmp = t_1;
} else if (x_46_im <= -9.5e-202) {
tmp = t_2;
} else if (x_46_im <= 1.45e-252) {
tmp = log(pow(sqrt(fma(x_46_im, x_46_im, (x_46_re * x_46_re))), y_46_im));
} else if (x_46_im <= 1.65e+218) {
tmp = sin((-1.0 * (y_46_im * log((1.0 / x_46_im))))) / t_0;
} else {
tmp = t_1;
}
return tmp;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = exp(Float64(y_46_im * atan(x_46_im, x_46_re))) t_1 = Float64((x_46_im ^ y_46_re) * sin(Float64(y_46_re * atan(x_46_im, x_46_re)))) t_2 = Float64(sin(Float64(-1.0 * Float64(y_46_im * log(Float64(-1.0 / x_46_im))))) / t_0) tmp = 0.0 if (x_46_im <= -9e+62) tmp = t_2; elseif (x_46_im <= -1.2e+16) tmp = t_1; elseif (x_46_im <= -9.5e-202) tmp = t_2; elseif (x_46_im <= 1.45e-252) tmp = log((sqrt(fma(x_46_im, x_46_im, Float64(x_46_re * x_46_re))) ^ y_46_im)); elseif (x_46_im <= 1.65e+218) tmp = Float64(sin(Float64(-1.0 * Float64(y_46_im * log(Float64(1.0 / x_46_im))))) / t_0); else tmp = t_1; end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[Exp[N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(N[Power[x$46$im, y$46$re], $MachinePrecision] * N[Sin[N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Sin[N[(-1.0 * N[(y$46$im * N[Log[N[(-1.0 / x$46$im), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision]}, If[LessEqual[x$46$im, -9e+62], t$95$2, If[LessEqual[x$46$im, -1.2e+16], t$95$1, If[LessEqual[x$46$im, -9.5e-202], t$95$2, If[LessEqual[x$46$im, 1.45e-252], N[Log[N[Power[N[Sqrt[N[(x$46$im * x$46$im + N[(x$46$re * x$46$re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], y$46$im], $MachinePrecision]], $MachinePrecision], If[LessEqual[x$46$im, 1.65e+218], N[(N[Sin[N[(-1.0 * N[(y$46$im * N[Log[N[(1.0 / x$46$im), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := e^{y.im \cdot \tan^{-1}_* \frac{x.im}{x.re}}\\
t_1 := {x.im}^{y.re} \cdot \sin \left(y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\right)\\
t_2 := \frac{\sin \left(-1 \cdot \left(y.im \cdot \log \left(\frac{-1}{x.im}\right)\right)\right)}{t\_0}\\
\mathbf{if}\;x.im \leq -9 \cdot 10^{+62}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x.im \leq -1.2 \cdot 10^{+16}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x.im \leq -9.5 \cdot 10^{-202}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x.im \leq 1.45 \cdot 10^{-252}:\\
\;\;\;\;\log \left({\left(\sqrt{\mathsf{fma}\left(x.im, x.im, x.re \cdot x.re\right)}\right)}^{y.im}\right)\\
\mathbf{elif}\;x.im \leq 1.65 \cdot 10^{+218}:\\
\;\;\;\;\frac{\sin \left(-1 \cdot \left(y.im \cdot \log \left(\frac{1}{x.im}\right)\right)\right)}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x.im < -8.99999999999999997e62 or -1.2e16 < x.im < -9.5000000000000001e-202Initial program 40.5%
Taylor expanded in y.re around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6422.6
Applied rewrites22.6%
lift-*.f64N/A
*-commutativeN/A
lift-exp.f64N/A
lift-neg.f64N/A
exp-negN/A
mult-flip-revN/A
lower-/.f64N/A
Applied rewrites22.6%
Taylor expanded in x.im around -inf
lower-*.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f6417.8
Applied rewrites17.8%
if -8.99999999999999997e62 < x.im < -1.2e16 or 1.64999999999999999e218 < x.im Initial program 40.5%
Taylor expanded in x.im around inf
lower-*.f64N/A
Applied rewrites32.3%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-atan2.f6419.2
Applied rewrites19.2%
Taylor expanded in x.im around 0
lower-pow.f6431.5
Applied rewrites31.5%
if -9.5000000000000001e-202 < x.im < 1.45e-252Initial program 40.5%
Taylor expanded in y.re around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6422.6
Applied rewrites22.6%
lift-*.f64N/A
*-commutativeN/A
lift-exp.f64N/A
lift-neg.f64N/A
exp-negN/A
mult-flip-revN/A
lower-/.f64N/A
Applied rewrites22.6%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6418.3
Applied rewrites18.3%
lift-*.f64N/A
lift-log.f64N/A
log-pow-revN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
lift-pow.f64N/A
pow2N/A
lift-pow.f64N/A
pow2N/A
pow1/2N/A
lower-log.f64N/A
pow1/2N/A
+-commutativeN/A
lift-+.f64N/A
lift-*.f64N/A
lift-*.f64N/A
pow1/2N/A
lift-sqrt.f64N/A
Applied rewrites23.0%
if 1.45e-252 < x.im < 1.64999999999999999e218Initial program 40.5%
Taylor expanded in y.re around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6422.6
Applied rewrites22.6%
lift-*.f64N/A
*-commutativeN/A
lift-exp.f64N/A
lift-neg.f64N/A
exp-negN/A
mult-flip-revN/A
lower-/.f64N/A
Applied rewrites22.6%
Taylor expanded in x.im around inf
lower-*.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f6418.9
Applied rewrites18.9%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0 (sin (* y.re (atan2 x.im x.re))))
(t_1 (sqrt (fma x.im x.im (* x.re x.re)))))
(if (<= y.re -220000.0)
(* (pow x.im y.re) t_0)
(if (<= y.re -7.6e-109)
(* 1.0 t_0)
(if (<= y.re 130000000000.0)
(/ (sin (* (log t_1) y.im)) (exp (* y.im (atan2 x.im x.re))))
(log (pow t_1 y.im)))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = sin((y_46_re * atan2(x_46_im, x_46_re)));
double t_1 = sqrt(fma(x_46_im, x_46_im, (x_46_re * x_46_re)));
double tmp;
if (y_46_re <= -220000.0) {
tmp = pow(x_46_im, y_46_re) * t_0;
} else if (y_46_re <= -7.6e-109) {
tmp = 1.0 * t_0;
} else if (y_46_re <= 130000000000.0) {
tmp = sin((log(t_1) * y_46_im)) / exp((y_46_im * atan2(x_46_im, x_46_re)));
} else {
tmp = log(pow(t_1, y_46_im));
}
return tmp;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = sin(Float64(y_46_re * atan(x_46_im, x_46_re))) t_1 = sqrt(fma(x_46_im, x_46_im, Float64(x_46_re * x_46_re))) tmp = 0.0 if (y_46_re <= -220000.0) tmp = Float64((x_46_im ^ y_46_re) * t_0); elseif (y_46_re <= -7.6e-109) tmp = Float64(1.0 * t_0); elseif (y_46_re <= 130000000000.0) tmp = Float64(sin(Float64(log(t_1) * y_46_im)) / exp(Float64(y_46_im * atan(x_46_im, x_46_re)))); else tmp = log((t_1 ^ y_46_im)); end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[Sin[N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[Sqrt[N[(x$46$im * x$46$im + N[(x$46$re * x$46$re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y$46$re, -220000.0], N[(N[Power[x$46$im, y$46$re], $MachinePrecision] * t$95$0), $MachinePrecision], If[LessEqual[y$46$re, -7.6e-109], N[(1.0 * t$95$0), $MachinePrecision], If[LessEqual[y$46$re, 130000000000.0], N[(N[Sin[N[(N[Log[t$95$1], $MachinePrecision] * y$46$im), $MachinePrecision]], $MachinePrecision] / N[Exp[N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[Log[N[Power[t$95$1, y$46$im], $MachinePrecision]], $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sin \left(y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\right)\\
t_1 := \sqrt{\mathsf{fma}\left(x.im, x.im, x.re \cdot x.re\right)}\\
\mathbf{if}\;y.re \leq -220000:\\
\;\;\;\;{x.im}^{y.re} \cdot t\_0\\
\mathbf{elif}\;y.re \leq -7.6 \cdot 10^{-109}:\\
\;\;\;\;1 \cdot t\_0\\
\mathbf{elif}\;y.re \leq 130000000000:\\
\;\;\;\;\frac{\sin \left(\log t\_1 \cdot y.im\right)}{e^{y.im \cdot \tan^{-1}_* \frac{x.im}{x.re}}}\\
\mathbf{else}:\\
\;\;\;\;\log \left({t\_1}^{y.im}\right)\\
\end{array}
\end{array}
if y.re < -2.2e5Initial program 40.5%
Taylor expanded in x.im around inf
lower-*.f64N/A
Applied rewrites32.3%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-atan2.f6419.2
Applied rewrites19.2%
Taylor expanded in x.im around 0
lower-pow.f6431.5
Applied rewrites31.5%
if -2.2e5 < y.re < -7.60000000000000003e-109Initial program 40.5%
Taylor expanded in x.im around inf
lower-*.f64N/A
Applied rewrites32.3%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-atan2.f6419.2
Applied rewrites19.2%
Taylor expanded in y.re around 0
Applied rewrites13.8%
if -7.60000000000000003e-109 < y.re < 1.3e11Initial program 40.5%
Taylor expanded in y.re around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6422.6
Applied rewrites22.6%
lift-*.f64N/A
*-commutativeN/A
lift-exp.f64N/A
lift-neg.f64N/A
exp-negN/A
mult-flip-revN/A
lower-/.f64N/A
Applied rewrites22.6%
if 1.3e11 < y.re Initial program 40.5%
Taylor expanded in y.re around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6422.6
Applied rewrites22.6%
lift-*.f64N/A
*-commutativeN/A
lift-exp.f64N/A
lift-neg.f64N/A
exp-negN/A
mult-flip-revN/A
lower-/.f64N/A
Applied rewrites22.6%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6418.3
Applied rewrites18.3%
lift-*.f64N/A
lift-log.f64N/A
log-pow-revN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
lift-pow.f64N/A
pow2N/A
lift-pow.f64N/A
pow2N/A
pow1/2N/A
lower-log.f64N/A
pow1/2N/A
+-commutativeN/A
lift-+.f64N/A
lift-*.f64N/A
lift-*.f64N/A
pow1/2N/A
lift-sqrt.f64N/A
Applied rewrites23.0%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0 (sqrt (fma x.im x.im (* x.re x.re))))
(t_1 (sin (* y.re (atan2 x.im x.re))))
(t_2 (* 1.0 t_1)))
(if (<= y.re -220000.0)
(* (pow x.im y.re) t_1)
(if (<= y.re -2.8e-109)
t_2
(if (<= y.re 7e-168)
(* (log t_0) y.im)
(if (<= y.re 1.58e-18) t_2 (log (pow t_0 y.im))))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = sqrt(fma(x_46_im, x_46_im, (x_46_re * x_46_re)));
double t_1 = sin((y_46_re * atan2(x_46_im, x_46_re)));
double t_2 = 1.0 * t_1;
double tmp;
if (y_46_re <= -220000.0) {
tmp = pow(x_46_im, y_46_re) * t_1;
} else if (y_46_re <= -2.8e-109) {
tmp = t_2;
} else if (y_46_re <= 7e-168) {
tmp = log(t_0) * y_46_im;
} else if (y_46_re <= 1.58e-18) {
tmp = t_2;
} else {
tmp = log(pow(t_0, y_46_im));
}
return tmp;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = sqrt(fma(x_46_im, x_46_im, Float64(x_46_re * x_46_re))) t_1 = sin(Float64(y_46_re * atan(x_46_im, x_46_re))) t_2 = Float64(1.0 * t_1) tmp = 0.0 if (y_46_re <= -220000.0) tmp = Float64((x_46_im ^ y_46_re) * t_1); elseif (y_46_re <= -2.8e-109) tmp = t_2; elseif (y_46_re <= 7e-168) tmp = Float64(log(t_0) * y_46_im); elseif (y_46_re <= 1.58e-18) tmp = t_2; else tmp = log((t_0 ^ y_46_im)); end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[Sqrt[N[(x$46$im * x$46$im + N[(x$46$re * x$46$re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[Sin[N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(1.0 * t$95$1), $MachinePrecision]}, If[LessEqual[y$46$re, -220000.0], N[(N[Power[x$46$im, y$46$re], $MachinePrecision] * t$95$1), $MachinePrecision], If[LessEqual[y$46$re, -2.8e-109], t$95$2, If[LessEqual[y$46$re, 7e-168], N[(N[Log[t$95$0], $MachinePrecision] * y$46$im), $MachinePrecision], If[LessEqual[y$46$re, 1.58e-18], t$95$2, N[Log[N[Power[t$95$0, y$46$im], $MachinePrecision]], $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt{\mathsf{fma}\left(x.im, x.im, x.re \cdot x.re\right)}\\
t_1 := \sin \left(y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\right)\\
t_2 := 1 \cdot t\_1\\
\mathbf{if}\;y.re \leq -220000:\\
\;\;\;\;{x.im}^{y.re} \cdot t\_1\\
\mathbf{elif}\;y.re \leq -2.8 \cdot 10^{-109}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y.re \leq 7 \cdot 10^{-168}:\\
\;\;\;\;\log t\_0 \cdot y.im\\
\mathbf{elif}\;y.re \leq 1.58 \cdot 10^{-18}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;\log \left({t\_0}^{y.im}\right)\\
\end{array}
\end{array}
if y.re < -2.2e5Initial program 40.5%
Taylor expanded in x.im around inf
lower-*.f64N/A
Applied rewrites32.3%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-atan2.f6419.2
Applied rewrites19.2%
Taylor expanded in x.im around 0
lower-pow.f6431.5
Applied rewrites31.5%
if -2.2e5 < y.re < -2.79999999999999979e-109 or 6.99999999999999964e-168 < y.re < 1.5800000000000001e-18Initial program 40.5%
Taylor expanded in x.im around inf
lower-*.f64N/A
Applied rewrites32.3%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-atan2.f6419.2
Applied rewrites19.2%
Taylor expanded in y.re around 0
Applied rewrites13.8%
if -2.79999999999999979e-109 < y.re < 6.99999999999999964e-168Initial program 40.5%
Taylor expanded in y.re around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6422.6
Applied rewrites22.6%
lift-*.f64N/A
*-commutativeN/A
lift-exp.f64N/A
lift-neg.f64N/A
exp-negN/A
mult-flip-revN/A
lower-/.f64N/A
Applied rewrites22.6%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6418.3
Applied rewrites18.3%
Applied rewrites18.3%
if 1.5800000000000001e-18 < y.re Initial program 40.5%
Taylor expanded in y.re around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6422.6
Applied rewrites22.6%
lift-*.f64N/A
*-commutativeN/A
lift-exp.f64N/A
lift-neg.f64N/A
exp-negN/A
mult-flip-revN/A
lower-/.f64N/A
Applied rewrites22.6%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6418.3
Applied rewrites18.3%
lift-*.f64N/A
lift-log.f64N/A
log-pow-revN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
lift-pow.f64N/A
pow2N/A
lift-pow.f64N/A
pow2N/A
pow1/2N/A
lower-log.f64N/A
pow1/2N/A
+-commutativeN/A
lift-+.f64N/A
lift-*.f64N/A
lift-*.f64N/A
pow1/2N/A
lift-sqrt.f64N/A
Applied rewrites23.0%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0 (* 1.0 (sin (* y.re (atan2 x.im x.re)))))
(t_1 (sqrt (fma x.im x.im (* x.re x.re))))
(t_2 (log (pow t_1 y.im))))
(if (<= y.re -1.15e-49)
t_2
(if (<= y.re -2.8e-109)
t_0
(if (<= y.re 7e-168)
(* (log t_1) y.im)
(if (<= y.re 1.58e-18) t_0 t_2))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = 1.0 * sin((y_46_re * atan2(x_46_im, x_46_re)));
double t_1 = sqrt(fma(x_46_im, x_46_im, (x_46_re * x_46_re)));
double t_2 = log(pow(t_1, y_46_im));
double tmp;
if (y_46_re <= -1.15e-49) {
tmp = t_2;
} else if (y_46_re <= -2.8e-109) {
tmp = t_0;
} else if (y_46_re <= 7e-168) {
tmp = log(t_1) * y_46_im;
} else if (y_46_re <= 1.58e-18) {
tmp = t_0;
} else {
tmp = t_2;
}
return tmp;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = Float64(1.0 * sin(Float64(y_46_re * atan(x_46_im, x_46_re)))) t_1 = sqrt(fma(x_46_im, x_46_im, Float64(x_46_re * x_46_re))) t_2 = log((t_1 ^ y_46_im)) tmp = 0.0 if (y_46_re <= -1.15e-49) tmp = t_2; elseif (y_46_re <= -2.8e-109) tmp = t_0; elseif (y_46_re <= 7e-168) tmp = Float64(log(t_1) * y_46_im); elseif (y_46_re <= 1.58e-18) tmp = t_0; else tmp = t_2; end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(1.0 * N[Sin[N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Sqrt[N[(x$46$im * x$46$im + N[(x$46$re * x$46$re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[Log[N[Power[t$95$1, y$46$im], $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y$46$re, -1.15e-49], t$95$2, If[LessEqual[y$46$re, -2.8e-109], t$95$0, If[LessEqual[y$46$re, 7e-168], N[(N[Log[t$95$1], $MachinePrecision] * y$46$im), $MachinePrecision], If[LessEqual[y$46$re, 1.58e-18], t$95$0, t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 1 \cdot \sin \left(y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\right)\\
t_1 := \sqrt{\mathsf{fma}\left(x.im, x.im, x.re \cdot x.re\right)}\\
t_2 := \log \left({t\_1}^{y.im}\right)\\
\mathbf{if}\;y.re \leq -1.15 \cdot 10^{-49}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y.re \leq -2.8 \cdot 10^{-109}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y.re \leq 7 \cdot 10^{-168}:\\
\;\;\;\;\log t\_1 \cdot y.im\\
\mathbf{elif}\;y.re \leq 1.58 \cdot 10^{-18}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if y.re < -1.15e-49 or 1.5800000000000001e-18 < y.re Initial program 40.5%
Taylor expanded in y.re around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6422.6
Applied rewrites22.6%
lift-*.f64N/A
*-commutativeN/A
lift-exp.f64N/A
lift-neg.f64N/A
exp-negN/A
mult-flip-revN/A
lower-/.f64N/A
Applied rewrites22.6%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6418.3
Applied rewrites18.3%
lift-*.f64N/A
lift-log.f64N/A
log-pow-revN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
lift-pow.f64N/A
pow2N/A
lift-pow.f64N/A
pow2N/A
pow1/2N/A
lower-log.f64N/A
pow1/2N/A
+-commutativeN/A
lift-+.f64N/A
lift-*.f64N/A
lift-*.f64N/A
pow1/2N/A
lift-sqrt.f64N/A
Applied rewrites23.0%
if -1.15e-49 < y.re < -2.79999999999999979e-109 or 6.99999999999999964e-168 < y.re < 1.5800000000000001e-18Initial program 40.5%
Taylor expanded in x.im around inf
lower-*.f64N/A
Applied rewrites32.3%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-atan2.f6419.2
Applied rewrites19.2%
Taylor expanded in y.re around 0
Applied rewrites13.8%
if -2.79999999999999979e-109 < y.re < 6.99999999999999964e-168Initial program 40.5%
Taylor expanded in y.re around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6422.6
Applied rewrites22.6%
lift-*.f64N/A
*-commutativeN/A
lift-exp.f64N/A
lift-neg.f64N/A
exp-negN/A
mult-flip-revN/A
lower-/.f64N/A
Applied rewrites22.6%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6418.3
Applied rewrites18.3%
Applied rewrites18.3%
(FPCore (x.re x.im y.re y.im) :precision binary64 (let* ((t_0 (sqrt (fma x.im x.im (* x.re x.re)))) (t_1 (log (pow t_0 y.im)))) (if (<= y.re -2.15e-78) t_1 (if (<= y.re 7e-28) (* (log t_0) y.im) t_1))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = sqrt(fma(x_46_im, x_46_im, (x_46_re * x_46_re)));
double t_1 = log(pow(t_0, y_46_im));
double tmp;
if (y_46_re <= -2.15e-78) {
tmp = t_1;
} else if (y_46_re <= 7e-28) {
tmp = log(t_0) * y_46_im;
} else {
tmp = t_1;
}
return tmp;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = sqrt(fma(x_46_im, x_46_im, Float64(x_46_re * x_46_re))) t_1 = log((t_0 ^ y_46_im)) tmp = 0.0 if (y_46_re <= -2.15e-78) tmp = t_1; elseif (y_46_re <= 7e-28) tmp = Float64(log(t_0) * y_46_im); else tmp = t_1; end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[Sqrt[N[(x$46$im * x$46$im + N[(x$46$re * x$46$re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[Log[N[Power[t$95$0, y$46$im], $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y$46$re, -2.15e-78], t$95$1, If[LessEqual[y$46$re, 7e-28], N[(N[Log[t$95$0], $MachinePrecision] * y$46$im), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt{\mathsf{fma}\left(x.im, x.im, x.re \cdot x.re\right)}\\
t_1 := \log \left({t\_0}^{y.im}\right)\\
\mathbf{if}\;y.re \leq -2.15 \cdot 10^{-78}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y.re \leq 7 \cdot 10^{-28}:\\
\;\;\;\;\log t\_0 \cdot y.im\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y.re < -2.14999999999999997e-78 or 6.9999999999999999e-28 < y.re Initial program 40.5%
Taylor expanded in y.re around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6422.6
Applied rewrites22.6%
lift-*.f64N/A
*-commutativeN/A
lift-exp.f64N/A
lift-neg.f64N/A
exp-negN/A
mult-flip-revN/A
lower-/.f64N/A
Applied rewrites22.6%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6418.3
Applied rewrites18.3%
lift-*.f64N/A
lift-log.f64N/A
log-pow-revN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
lift-pow.f64N/A
pow2N/A
lift-pow.f64N/A
pow2N/A
pow1/2N/A
lower-log.f64N/A
pow1/2N/A
+-commutativeN/A
lift-+.f64N/A
lift-*.f64N/A
lift-*.f64N/A
pow1/2N/A
lift-sqrt.f64N/A
Applied rewrites23.0%
if -2.14999999999999997e-78 < y.re < 6.9999999999999999e-28Initial program 40.5%
Taylor expanded in y.re around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6422.6
Applied rewrites22.6%
lift-*.f64N/A
*-commutativeN/A
lift-exp.f64N/A
lift-neg.f64N/A
exp-negN/A
mult-flip-revN/A
lower-/.f64N/A
Applied rewrites22.6%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6418.3
Applied rewrites18.3%
Applied rewrites18.3%
(FPCore (x.re x.im y.re y.im) :precision binary64 (* (log (sqrt (fma x.im x.im (* x.re x.re)))) y.im))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
return log(sqrt(fma(x_46_im, x_46_im, (x_46_re * x_46_re)))) * y_46_im;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) return Float64(log(sqrt(fma(x_46_im, x_46_im, Float64(x_46_re * x_46_re)))) * y_46_im) end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := N[(N[Log[N[Sqrt[N[(x$46$im * x$46$im + N[(x$46$re * x$46$re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * y$46$im), $MachinePrecision]
\begin{array}{l}
\\
\log \left(\sqrt{\mathsf{fma}\left(x.im, x.im, x.re \cdot x.re\right)}\right) \cdot y.im
\end{array}
Initial program 40.5%
Taylor expanded in y.re around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6422.6
Applied rewrites22.6%
lift-*.f64N/A
*-commutativeN/A
lift-exp.f64N/A
lift-neg.f64N/A
exp-negN/A
mult-flip-revN/A
lower-/.f64N/A
Applied rewrites22.6%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6418.3
Applied rewrites18.3%
Applied rewrites18.3%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(if (<= x.re -4.3e-141)
(* -1.0 (* y.im (log (/ -1.0 x.re))))
(if (<= x.re 7.8e-91)
(* -1.0 (* y.im (log (/ -1.0 x.im))))
(* -1.0 (* y.im (log (/ 1.0 x.re)))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double tmp;
if (x_46_re <= -4.3e-141) {
tmp = -1.0 * (y_46_im * log((-1.0 / x_46_re)));
} else if (x_46_re <= 7.8e-91) {
tmp = -1.0 * (y_46_im * log((-1.0 / x_46_im)));
} else {
tmp = -1.0 * (y_46_im * log((1.0 / x_46_re)));
}
return tmp;
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x_46re, x_46im, y_46re, y_46im)
use fmin_fmax_functions
real(8), intent (in) :: x_46re
real(8), intent (in) :: x_46im
real(8), intent (in) :: y_46re
real(8), intent (in) :: y_46im
real(8) :: tmp
if (x_46re <= (-4.3d-141)) then
tmp = (-1.0d0) * (y_46im * log(((-1.0d0) / x_46re)))
else if (x_46re <= 7.8d-91) then
tmp = (-1.0d0) * (y_46im * log(((-1.0d0) / x_46im)))
else
tmp = (-1.0d0) * (y_46im * log((1.0d0 / x_46re)))
end if
code = tmp
end function
public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double tmp;
if (x_46_re <= -4.3e-141) {
tmp = -1.0 * (y_46_im * Math.log((-1.0 / x_46_re)));
} else if (x_46_re <= 7.8e-91) {
tmp = -1.0 * (y_46_im * Math.log((-1.0 / x_46_im)));
} else {
tmp = -1.0 * (y_46_im * Math.log((1.0 / x_46_re)));
}
return tmp;
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): tmp = 0 if x_46_re <= -4.3e-141: tmp = -1.0 * (y_46_im * math.log((-1.0 / x_46_re))) elif x_46_re <= 7.8e-91: tmp = -1.0 * (y_46_im * math.log((-1.0 / x_46_im))) else: tmp = -1.0 * (y_46_im * math.log((1.0 / x_46_re))) return tmp
function code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = 0.0 if (x_46_re <= -4.3e-141) tmp = Float64(-1.0 * Float64(y_46_im * log(Float64(-1.0 / x_46_re)))); elseif (x_46_re <= 7.8e-91) tmp = Float64(-1.0 * Float64(y_46_im * log(Float64(-1.0 / x_46_im)))); else tmp = Float64(-1.0 * Float64(y_46_im * log(Float64(1.0 / x_46_re)))); end return tmp end
function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = 0.0; if (x_46_re <= -4.3e-141) tmp = -1.0 * (y_46_im * log((-1.0 / x_46_re))); elseif (x_46_re <= 7.8e-91) tmp = -1.0 * (y_46_im * log((-1.0 / x_46_im))); else tmp = -1.0 * (y_46_im * log((1.0 / x_46_re))); end tmp_2 = tmp; end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := If[LessEqual[x$46$re, -4.3e-141], N[(-1.0 * N[(y$46$im * N[Log[N[(-1.0 / x$46$re), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x$46$re, 7.8e-91], N[(-1.0 * N[(y$46$im * N[Log[N[(-1.0 / x$46$im), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-1.0 * N[(y$46$im * N[Log[N[(1.0 / x$46$re), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x.re \leq -4.3 \cdot 10^{-141}:\\
\;\;\;\;-1 \cdot \left(y.im \cdot \log \left(\frac{-1}{x.re}\right)\right)\\
\mathbf{elif}\;x.re \leq 7.8 \cdot 10^{-91}:\\
\;\;\;\;-1 \cdot \left(y.im \cdot \log \left(\frac{-1}{x.im}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;-1 \cdot \left(y.im \cdot \log \left(\frac{1}{x.re}\right)\right)\\
\end{array}
\end{array}
if x.re < -4.29999999999999974e-141Initial program 40.5%
Taylor expanded in y.re around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6422.6
Applied rewrites22.6%
lift-*.f64N/A
*-commutativeN/A
lift-exp.f64N/A
lift-neg.f64N/A
exp-negN/A
mult-flip-revN/A
lower-/.f64N/A
Applied rewrites22.6%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6418.3
Applied rewrites18.3%
Taylor expanded in x.re around -inf
lower-*.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f644.7
Applied rewrites4.7%
if -4.29999999999999974e-141 < x.re < 7.79999999999999987e-91Initial program 40.5%
Taylor expanded in y.re around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6422.6
Applied rewrites22.6%
lift-*.f64N/A
*-commutativeN/A
lift-exp.f64N/A
lift-neg.f64N/A
exp-negN/A
mult-flip-revN/A
lower-/.f64N/A
Applied rewrites22.6%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6418.3
Applied rewrites18.3%
Taylor expanded in x.im around -inf
lower-*.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f644.5
Applied rewrites4.5%
if 7.79999999999999987e-91 < x.re Initial program 40.5%
Taylor expanded in y.re around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6422.6
Applied rewrites22.6%
lift-*.f64N/A
*-commutativeN/A
lift-exp.f64N/A
lift-neg.f64N/A
exp-negN/A
mult-flip-revN/A
lower-/.f64N/A
Applied rewrites22.6%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6418.3
Applied rewrites18.3%
Taylor expanded in x.re around inf
lower-*.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f646.8
Applied rewrites6.8%
(FPCore (x.re x.im y.re y.im) :precision binary64 (if (<= x.im -4e-310) (* -1.0 (* y.im (log (/ -1.0 x.im)))) (* -1.0 (* y.im (log (/ 1.0 x.im))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double tmp;
if (x_46_im <= -4e-310) {
tmp = -1.0 * (y_46_im * log((-1.0 / x_46_im)));
} else {
tmp = -1.0 * (y_46_im * log((1.0 / x_46_im)));
}
return tmp;
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x_46re, x_46im, y_46re, y_46im)
use fmin_fmax_functions
real(8), intent (in) :: x_46re
real(8), intent (in) :: x_46im
real(8), intent (in) :: y_46re
real(8), intent (in) :: y_46im
real(8) :: tmp
if (x_46im <= (-4d-310)) then
tmp = (-1.0d0) * (y_46im * log(((-1.0d0) / x_46im)))
else
tmp = (-1.0d0) * (y_46im * log((1.0d0 / x_46im)))
end if
code = tmp
end function
public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double tmp;
if (x_46_im <= -4e-310) {
tmp = -1.0 * (y_46_im * Math.log((-1.0 / x_46_im)));
} else {
tmp = -1.0 * (y_46_im * Math.log((1.0 / x_46_im)));
}
return tmp;
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): tmp = 0 if x_46_im <= -4e-310: tmp = -1.0 * (y_46_im * math.log((-1.0 / x_46_im))) else: tmp = -1.0 * (y_46_im * math.log((1.0 / x_46_im))) return tmp
function code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = 0.0 if (x_46_im <= -4e-310) tmp = Float64(-1.0 * Float64(y_46_im * log(Float64(-1.0 / x_46_im)))); else tmp = Float64(-1.0 * Float64(y_46_im * log(Float64(1.0 / x_46_im)))); end return tmp end
function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = 0.0; if (x_46_im <= -4e-310) tmp = -1.0 * (y_46_im * log((-1.0 / x_46_im))); else tmp = -1.0 * (y_46_im * log((1.0 / x_46_im))); end tmp_2 = tmp; end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := If[LessEqual[x$46$im, -4e-310], N[(-1.0 * N[(y$46$im * N[Log[N[(-1.0 / x$46$im), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-1.0 * N[(y$46$im * N[Log[N[(1.0 / x$46$im), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x.im \leq -4 \cdot 10^{-310}:\\
\;\;\;\;-1 \cdot \left(y.im \cdot \log \left(\frac{-1}{x.im}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;-1 \cdot \left(y.im \cdot \log \left(\frac{1}{x.im}\right)\right)\\
\end{array}
\end{array}
if x.im < -3.999999999999988e-310Initial program 40.5%
Taylor expanded in y.re around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6422.6
Applied rewrites22.6%
lift-*.f64N/A
*-commutativeN/A
lift-exp.f64N/A
lift-neg.f64N/A
exp-negN/A
mult-flip-revN/A
lower-/.f64N/A
Applied rewrites22.6%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6418.3
Applied rewrites18.3%
Taylor expanded in x.im around -inf
lower-*.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f644.5
Applied rewrites4.5%
if -3.999999999999988e-310 < x.im Initial program 40.5%
Taylor expanded in y.re around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6422.6
Applied rewrites22.6%
lift-*.f64N/A
*-commutativeN/A
lift-exp.f64N/A
lift-neg.f64N/A
exp-negN/A
mult-flip-revN/A
lower-/.f64N/A
Applied rewrites22.6%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6418.3
Applied rewrites18.3%
Taylor expanded in x.im around inf
lower-*.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f644.4
Applied rewrites4.4%
(FPCore (x.re x.im y.re y.im) :precision binary64 (if (<= x.re -4.3e-141) (* -1.0 (* y.im (log (/ -1.0 x.re)))) (* -1.0 (* y.im (log (/ -1.0 x.im))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double tmp;
if (x_46_re <= -4.3e-141) {
tmp = -1.0 * (y_46_im * log((-1.0 / x_46_re)));
} else {
tmp = -1.0 * (y_46_im * log((-1.0 / x_46_im)));
}
return tmp;
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x_46re, x_46im, y_46re, y_46im)
use fmin_fmax_functions
real(8), intent (in) :: x_46re
real(8), intent (in) :: x_46im
real(8), intent (in) :: y_46re
real(8), intent (in) :: y_46im
real(8) :: tmp
if (x_46re <= (-4.3d-141)) then
tmp = (-1.0d0) * (y_46im * log(((-1.0d0) / x_46re)))
else
tmp = (-1.0d0) * (y_46im * log(((-1.0d0) / x_46im)))
end if
code = tmp
end function
public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double tmp;
if (x_46_re <= -4.3e-141) {
tmp = -1.0 * (y_46_im * Math.log((-1.0 / x_46_re)));
} else {
tmp = -1.0 * (y_46_im * Math.log((-1.0 / x_46_im)));
}
return tmp;
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): tmp = 0 if x_46_re <= -4.3e-141: tmp = -1.0 * (y_46_im * math.log((-1.0 / x_46_re))) else: tmp = -1.0 * (y_46_im * math.log((-1.0 / x_46_im))) return tmp
function code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = 0.0 if (x_46_re <= -4.3e-141) tmp = Float64(-1.0 * Float64(y_46_im * log(Float64(-1.0 / x_46_re)))); else tmp = Float64(-1.0 * Float64(y_46_im * log(Float64(-1.0 / x_46_im)))); end return tmp end
function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = 0.0; if (x_46_re <= -4.3e-141) tmp = -1.0 * (y_46_im * log((-1.0 / x_46_re))); else tmp = -1.0 * (y_46_im * log((-1.0 / x_46_im))); end tmp_2 = tmp; end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := If[LessEqual[x$46$re, -4.3e-141], N[(-1.0 * N[(y$46$im * N[Log[N[(-1.0 / x$46$re), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-1.0 * N[(y$46$im * N[Log[N[(-1.0 / x$46$im), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x.re \leq -4.3 \cdot 10^{-141}:\\
\;\;\;\;-1 \cdot \left(y.im \cdot \log \left(\frac{-1}{x.re}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;-1 \cdot \left(y.im \cdot \log \left(\frac{-1}{x.im}\right)\right)\\
\end{array}
\end{array}
if x.re < -4.29999999999999974e-141Initial program 40.5%
Taylor expanded in y.re around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6422.6
Applied rewrites22.6%
lift-*.f64N/A
*-commutativeN/A
lift-exp.f64N/A
lift-neg.f64N/A
exp-negN/A
mult-flip-revN/A
lower-/.f64N/A
Applied rewrites22.6%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6418.3
Applied rewrites18.3%
Taylor expanded in x.re around -inf
lower-*.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f644.7
Applied rewrites4.7%
if -4.29999999999999974e-141 < x.re Initial program 40.5%
Taylor expanded in y.re around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6422.6
Applied rewrites22.6%
lift-*.f64N/A
*-commutativeN/A
lift-exp.f64N/A
lift-neg.f64N/A
exp-negN/A
mult-flip-revN/A
lower-/.f64N/A
Applied rewrites22.6%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6418.3
Applied rewrites18.3%
Taylor expanded in x.im around -inf
lower-*.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f644.5
Applied rewrites4.5%
(FPCore (x.re x.im y.re y.im) :precision binary64 (* -1.0 (* y.im (log (/ -1.0 x.im)))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
return -1.0 * (y_46_im * log((-1.0 / x_46_im)));
}
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(x_46re, x_46im, y_46re, y_46im)
use fmin_fmax_functions
real(8), intent (in) :: x_46re
real(8), intent (in) :: x_46im
real(8), intent (in) :: y_46re
real(8), intent (in) :: y_46im
code = (-1.0d0) * (y_46im * log(((-1.0d0) / x_46im)))
end function
public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
return -1.0 * (y_46_im * Math.log((-1.0 / x_46_im)));
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): return -1.0 * (y_46_im * math.log((-1.0 / x_46_im)))
function code(x_46_re, x_46_im, y_46_re, y_46_im) return Float64(-1.0 * Float64(y_46_im * log(Float64(-1.0 / x_46_im)))) end
function tmp = code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = -1.0 * (y_46_im * log((-1.0 / x_46_im))); end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := N[(-1.0 * N[(y$46$im * N[Log[N[(-1.0 / x$46$im), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
-1 \cdot \left(y.im \cdot \log \left(\frac{-1}{x.im}\right)\right)
\end{array}
Initial program 40.5%
Taylor expanded in y.re around 0
lower-*.f64N/A
lower-exp.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
lower-atan2.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6422.6
Applied rewrites22.6%
lift-*.f64N/A
*-commutativeN/A
lift-exp.f64N/A
lift-neg.f64N/A
exp-negN/A
mult-flip-revN/A
lower-/.f64N/A
Applied rewrites22.6%
Taylor expanded in y.im around 0
lower-*.f64N/A
lower-log.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-pow.f64N/A
lower-pow.f6418.3
Applied rewrites18.3%
Taylor expanded in x.im around -inf
lower-*.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f644.5
Applied rewrites4.5%
herbie shell --seed 2025156
(FPCore (x.re x.im y.re y.im)
:name "powComplex, imaginary part"
:precision binary64
(* (exp (- (* (log (sqrt (+ (* x.re x.re) (* x.im x.im)))) y.re) (* (atan2 x.im x.re) y.im))) (sin (+ (* (log (sqrt (+ (* x.re x.re) (* x.im x.im)))) y.im) (* (atan2 x.im x.re) y.re)))))