
(FPCore (re im) :precision binary64 (* (exp re) (cos im)))
double code(double re, double im) {
return exp(re) * cos(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(re, im)
use fmin_fmax_functions
real(8), intent (in) :: re
real(8), intent (in) :: im
code = exp(re) * cos(im)
end function
public static double code(double re, double im) {
return Math.exp(re) * Math.cos(im);
}
def code(re, im): return math.exp(re) * math.cos(im)
function code(re, im) return Float64(exp(re) * cos(im)) end
function tmp = code(re, im) tmp = exp(re) * cos(im); end
code[re_, im_] := N[(N[Exp[re], $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
e^{re} \cdot \cos im
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 20 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (re im) :precision binary64 (* (exp re) (cos im)))
double code(double re, double im) {
return exp(re) * cos(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(re, im)
use fmin_fmax_functions
real(8), intent (in) :: re
real(8), intent (in) :: im
code = exp(re) * cos(im)
end function
public static double code(double re, double im) {
return Math.exp(re) * Math.cos(im);
}
def code(re, im): return math.exp(re) * math.cos(im)
function code(re, im) return Float64(exp(re) * cos(im)) end
function tmp = code(re, im) tmp = exp(re) * cos(im); end
code[re_, im_] := N[(N[Exp[re], $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
e^{re} \cdot \cos im
\end{array}
(FPCore (re im) :precision binary64 (* (exp re) (cos im)))
double code(double re, double im) {
return exp(re) * cos(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(re, im)
use fmin_fmax_functions
real(8), intent (in) :: re
real(8), intent (in) :: im
code = exp(re) * cos(im)
end function
public static double code(double re, double im) {
return Math.exp(re) * Math.cos(im);
}
def code(re, im): return math.exp(re) * math.cos(im)
function code(re, im) return Float64(exp(re) * cos(im)) end
function tmp = code(re, im) tmp = exp(re) * cos(im); end
code[re_, im_] := N[(N[Exp[re], $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
e^{re} \cdot \cos im
\end{array}
Initial program 100.0%
(FPCore (re im)
:precision binary64
(let* ((t_0 (* (exp re) (cos im))) (t_1 (* (+ 1.0 re) (cos im))))
(if (<= t_0 (- INFINITY))
(*
(* (fma 0.16666666666666666 re 0.5) (* re re))
(fma (* im im) -0.5 1.0))
(if (<= t_0 -0.04)
t_1
(if (<= t_0 0.0)
(* (exp re) (* (* im im) -0.5))
(if (<= t_0 0.999)
t_1
(*
(fma (fma (fma 0.16666666666666666 re 0.5) re 1.0) re 1.0)
(fma
(- (* 0.041666666666666664 (* im im)) 0.5)
(* im im)
1.0))))))))
double code(double re, double im) {
double t_0 = exp(re) * cos(im);
double t_1 = (1.0 + re) * cos(im);
double tmp;
if (t_0 <= -((double) INFINITY)) {
tmp = (fma(0.16666666666666666, re, 0.5) * (re * re)) * fma((im * im), -0.5, 1.0);
} else if (t_0 <= -0.04) {
tmp = t_1;
} else if (t_0 <= 0.0) {
tmp = exp(re) * ((im * im) * -0.5);
} else if (t_0 <= 0.999) {
tmp = t_1;
} else {
tmp = fma(fma(fma(0.16666666666666666, re, 0.5), re, 1.0), re, 1.0) * fma(((0.041666666666666664 * (im * im)) - 0.5), (im * im), 1.0);
}
return tmp;
}
function code(re, im) t_0 = Float64(exp(re) * cos(im)) t_1 = Float64(Float64(1.0 + re) * cos(im)) tmp = 0.0 if (t_0 <= Float64(-Inf)) tmp = Float64(Float64(fma(0.16666666666666666, re, 0.5) * Float64(re * re)) * fma(Float64(im * im), -0.5, 1.0)); elseif (t_0 <= -0.04) tmp = t_1; elseif (t_0 <= 0.0) tmp = Float64(exp(re) * Float64(Float64(im * im) * -0.5)); elseif (t_0 <= 0.999) tmp = t_1; else tmp = Float64(fma(fma(fma(0.16666666666666666, re, 0.5), re, 1.0), re, 1.0) * fma(Float64(Float64(0.041666666666666664 * Float64(im * im)) - 0.5), Float64(im * im), 1.0)); end return tmp end
code[re_, im_] := Block[{t$95$0 = N[(N[Exp[re], $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(1.0 + re), $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, (-Infinity)], N[(N[(N[(0.16666666666666666 * re + 0.5), $MachinePrecision] * N[(re * re), $MachinePrecision]), $MachinePrecision] * N[(N[(im * im), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, -0.04], t$95$1, If[LessEqual[t$95$0, 0.0], N[(N[Exp[re], $MachinePrecision] * N[(N[(im * im), $MachinePrecision] * -0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 0.999], t$95$1, N[(N[(N[(N[(0.16666666666666666 * re + 0.5), $MachinePrecision] * re + 1.0), $MachinePrecision] * re + 1.0), $MachinePrecision] * N[(N[(N[(0.041666666666666664 * N[(im * im), $MachinePrecision]), $MachinePrecision] - 0.5), $MachinePrecision] * N[(im * im), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := e^{re} \cdot \cos im\\
t_1 := \left(1 + re\right) \cdot \cos im\\
\mathbf{if}\;t\_0 \leq -\infty:\\
\;\;\;\;\left(\mathsf{fma}\left(0.16666666666666666, re, 0.5\right) \cdot \left(re \cdot re\right)\right) \cdot \mathsf{fma}\left(im \cdot im, -0.5, 1\right)\\
\mathbf{elif}\;t\_0 \leq -0.04:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;e^{re} \cdot \left(\left(im \cdot im\right) \cdot -0.5\right)\\
\mathbf{elif}\;t\_0 \leq 0.999:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(0.16666666666666666, re, 0.5\right), re, 1\right), re, 1\right) \cdot \mathsf{fma}\left(0.041666666666666664 \cdot \left(im \cdot im\right) - 0.5, im \cdot im, 1\right)\\
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (cos.f64 im)) < -inf.0Initial program 100.0%
Taylor expanded in im around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64100.0
Applied rewrites100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites100.0%
Applied rewrites100.0%
Taylor expanded in re around inf
Applied rewrites100.0%
if -inf.0 < (*.f64 (exp.f64 re) (cos.f64 im)) < -0.0400000000000000008 or 0.0 < (*.f64 (exp.f64 re) (cos.f64 im)) < 0.998999999999999999Initial program 100.0%
Taylor expanded in re around 0
lower-+.f6496.8
Applied rewrites96.8%
if -0.0400000000000000008 < (*.f64 (exp.f64 re) (cos.f64 im)) < 0.0Initial program 100.0%
Taylor expanded in im around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6473.8
Applied rewrites73.8%
Taylor expanded in im around inf
Applied rewrites73.8%
if 0.998999999999999999 < (*.f64 (exp.f64 re) (cos.f64 im)) Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6484.7
Applied rewrites84.7%
Taylor expanded in im around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6490.9
Applied rewrites90.9%
(FPCore (re im)
:precision binary64
(let* ((t_0 (* (exp re) (cos im))) (t_1 (* (+ 1.0 re) (cos im))))
(if (<= t_0 (- INFINITY))
(*
(* (fma 0.16666666666666666 re 0.5) (* re re))
(fma (* im im) -0.5 1.0))
(if (<= t_0 -0.04)
t_1
(if (<= t_0 0.0)
(* (* -0.5 im) im)
(if (<= t_0 0.999)
t_1
(*
(fma (fma (fma 0.16666666666666666 re 0.5) re 1.0) re 1.0)
(fma
(- (* 0.041666666666666664 (* im im)) 0.5)
(* im im)
1.0))))))))
double code(double re, double im) {
double t_0 = exp(re) * cos(im);
double t_1 = (1.0 + re) * cos(im);
double tmp;
if (t_0 <= -((double) INFINITY)) {
tmp = (fma(0.16666666666666666, re, 0.5) * (re * re)) * fma((im * im), -0.5, 1.0);
} else if (t_0 <= -0.04) {
tmp = t_1;
} else if (t_0 <= 0.0) {
tmp = (-0.5 * im) * im;
} else if (t_0 <= 0.999) {
tmp = t_1;
} else {
tmp = fma(fma(fma(0.16666666666666666, re, 0.5), re, 1.0), re, 1.0) * fma(((0.041666666666666664 * (im * im)) - 0.5), (im * im), 1.0);
}
return tmp;
}
function code(re, im) t_0 = Float64(exp(re) * cos(im)) t_1 = Float64(Float64(1.0 + re) * cos(im)) tmp = 0.0 if (t_0 <= Float64(-Inf)) tmp = Float64(Float64(fma(0.16666666666666666, re, 0.5) * Float64(re * re)) * fma(Float64(im * im), -0.5, 1.0)); elseif (t_0 <= -0.04) tmp = t_1; elseif (t_0 <= 0.0) tmp = Float64(Float64(-0.5 * im) * im); elseif (t_0 <= 0.999) tmp = t_1; else tmp = Float64(fma(fma(fma(0.16666666666666666, re, 0.5), re, 1.0), re, 1.0) * fma(Float64(Float64(0.041666666666666664 * Float64(im * im)) - 0.5), Float64(im * im), 1.0)); end return tmp end
code[re_, im_] := Block[{t$95$0 = N[(N[Exp[re], $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(1.0 + re), $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, (-Infinity)], N[(N[(N[(0.16666666666666666 * re + 0.5), $MachinePrecision] * N[(re * re), $MachinePrecision]), $MachinePrecision] * N[(N[(im * im), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, -0.04], t$95$1, If[LessEqual[t$95$0, 0.0], N[(N[(-0.5 * im), $MachinePrecision] * im), $MachinePrecision], If[LessEqual[t$95$0, 0.999], t$95$1, N[(N[(N[(N[(0.16666666666666666 * re + 0.5), $MachinePrecision] * re + 1.0), $MachinePrecision] * re + 1.0), $MachinePrecision] * N[(N[(N[(0.041666666666666664 * N[(im * im), $MachinePrecision]), $MachinePrecision] - 0.5), $MachinePrecision] * N[(im * im), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := e^{re} \cdot \cos im\\
t_1 := \left(1 + re\right) \cdot \cos im\\
\mathbf{if}\;t\_0 \leq -\infty:\\
\;\;\;\;\left(\mathsf{fma}\left(0.16666666666666666, re, 0.5\right) \cdot \left(re \cdot re\right)\right) \cdot \mathsf{fma}\left(im \cdot im, -0.5, 1\right)\\
\mathbf{elif}\;t\_0 \leq -0.04:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;\left(-0.5 \cdot im\right) \cdot im\\
\mathbf{elif}\;t\_0 \leq 0.999:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(0.16666666666666666, re, 0.5\right), re, 1\right), re, 1\right) \cdot \mathsf{fma}\left(0.041666666666666664 \cdot \left(im \cdot im\right) - 0.5, im \cdot im, 1\right)\\
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (cos.f64 im)) < -inf.0Initial program 100.0%
Taylor expanded in im around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64100.0
Applied rewrites100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites100.0%
Applied rewrites100.0%
Taylor expanded in re around inf
Applied rewrites100.0%
if -inf.0 < (*.f64 (exp.f64 re) (cos.f64 im)) < -0.0400000000000000008 or 0.0 < (*.f64 (exp.f64 re) (cos.f64 im)) < 0.998999999999999999Initial program 100.0%
Taylor expanded in re around 0
lower-+.f6496.8
Applied rewrites96.8%
if -0.0400000000000000008 < (*.f64 (exp.f64 re) (cos.f64 im)) < 0.0Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f643.1
Applied rewrites3.1%
Taylor expanded in im around 0
Applied rewrites2.5%
Taylor expanded in im around inf
Applied rewrites29.8%
Applied rewrites29.8%
if 0.998999999999999999 < (*.f64 (exp.f64 re) (cos.f64 im)) Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6484.7
Applied rewrites84.7%
Taylor expanded in im around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6490.9
Applied rewrites90.9%
(FPCore (re im)
:precision binary64
(let* ((t_0 (* (exp re) (cos im))))
(if (<= t_0 (- INFINITY))
(*
(* (fma 0.16666666666666666 re 0.5) (* re re))
(fma (* im im) -0.5 1.0))
(if (<= t_0 -0.04)
(cos im)
(if (<= t_0 0.0)
(* (* -0.5 im) im)
(if (<= t_0 0.999)
(cos im)
(*
(fma (fma (fma 0.16666666666666666 re 0.5) re 1.0) re 1.0)
(fma
(- (* 0.041666666666666664 (* im im)) 0.5)
(* im im)
1.0))))))))
double code(double re, double im) {
double t_0 = exp(re) * cos(im);
double tmp;
if (t_0 <= -((double) INFINITY)) {
tmp = (fma(0.16666666666666666, re, 0.5) * (re * re)) * fma((im * im), -0.5, 1.0);
} else if (t_0 <= -0.04) {
tmp = cos(im);
} else if (t_0 <= 0.0) {
tmp = (-0.5 * im) * im;
} else if (t_0 <= 0.999) {
tmp = cos(im);
} else {
tmp = fma(fma(fma(0.16666666666666666, re, 0.5), re, 1.0), re, 1.0) * fma(((0.041666666666666664 * (im * im)) - 0.5), (im * im), 1.0);
}
return tmp;
}
function code(re, im) t_0 = Float64(exp(re) * cos(im)) tmp = 0.0 if (t_0 <= Float64(-Inf)) tmp = Float64(Float64(fma(0.16666666666666666, re, 0.5) * Float64(re * re)) * fma(Float64(im * im), -0.5, 1.0)); elseif (t_0 <= -0.04) tmp = cos(im); elseif (t_0 <= 0.0) tmp = Float64(Float64(-0.5 * im) * im); elseif (t_0 <= 0.999) tmp = cos(im); else tmp = Float64(fma(fma(fma(0.16666666666666666, re, 0.5), re, 1.0), re, 1.0) * fma(Float64(Float64(0.041666666666666664 * Float64(im * im)) - 0.5), Float64(im * im), 1.0)); end return tmp end
code[re_, im_] := Block[{t$95$0 = N[(N[Exp[re], $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, (-Infinity)], N[(N[(N[(0.16666666666666666 * re + 0.5), $MachinePrecision] * N[(re * re), $MachinePrecision]), $MachinePrecision] * N[(N[(im * im), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, -0.04], N[Cos[im], $MachinePrecision], If[LessEqual[t$95$0, 0.0], N[(N[(-0.5 * im), $MachinePrecision] * im), $MachinePrecision], If[LessEqual[t$95$0, 0.999], N[Cos[im], $MachinePrecision], N[(N[(N[(N[(0.16666666666666666 * re + 0.5), $MachinePrecision] * re + 1.0), $MachinePrecision] * re + 1.0), $MachinePrecision] * N[(N[(N[(0.041666666666666664 * N[(im * im), $MachinePrecision]), $MachinePrecision] - 0.5), $MachinePrecision] * N[(im * im), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := e^{re} \cdot \cos im\\
\mathbf{if}\;t\_0 \leq -\infty:\\
\;\;\;\;\left(\mathsf{fma}\left(0.16666666666666666, re, 0.5\right) \cdot \left(re \cdot re\right)\right) \cdot \mathsf{fma}\left(im \cdot im, -0.5, 1\right)\\
\mathbf{elif}\;t\_0 \leq -0.04:\\
\;\;\;\;\cos im\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;\left(-0.5 \cdot im\right) \cdot im\\
\mathbf{elif}\;t\_0 \leq 0.999:\\
\;\;\;\;\cos im\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(0.16666666666666666, re, 0.5\right), re, 1\right), re, 1\right) \cdot \mathsf{fma}\left(0.041666666666666664 \cdot \left(im \cdot im\right) - 0.5, im \cdot im, 1\right)\\
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (cos.f64 im)) < -inf.0Initial program 100.0%
Taylor expanded in im around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64100.0
Applied rewrites100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites100.0%
Applied rewrites100.0%
Taylor expanded in re around inf
Applied rewrites100.0%
if -inf.0 < (*.f64 (exp.f64 re) (cos.f64 im)) < -0.0400000000000000008 or 0.0 < (*.f64 (exp.f64 re) (cos.f64 im)) < 0.998999999999999999Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f6495.4
Applied rewrites95.4%
if -0.0400000000000000008 < (*.f64 (exp.f64 re) (cos.f64 im)) < 0.0Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f643.1
Applied rewrites3.1%
Taylor expanded in im around 0
Applied rewrites2.5%
Taylor expanded in im around inf
Applied rewrites29.8%
Applied rewrites29.8%
if 0.998999999999999999 < (*.f64 (exp.f64 re) (cos.f64 im)) Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6484.7
Applied rewrites84.7%
Taylor expanded in im around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6490.9
Applied rewrites90.9%
(FPCore (re im)
:precision binary64
(let* ((t_0 (* (exp re) (cos im))))
(if (<= t_0 -0.58)
(*
(* (fma 0.16666666666666666 re 0.5) (* re re))
(fma (* im im) -0.5 1.0))
(if (<= t_0 0.0)
(* (* -0.5 im) im)
(if (<= t_0 0.95)
(* (pow im -1.0) im)
(*
(fma (fma (fma 0.16666666666666666 re 0.5) re 1.0) re 1.0)
(fma (- (* 0.041666666666666664 (* im im)) 0.5) (* im im) 1.0)))))))
double code(double re, double im) {
double t_0 = exp(re) * cos(im);
double tmp;
if (t_0 <= -0.58) {
tmp = (fma(0.16666666666666666, re, 0.5) * (re * re)) * fma((im * im), -0.5, 1.0);
} else if (t_0 <= 0.0) {
tmp = (-0.5 * im) * im;
} else if (t_0 <= 0.95) {
tmp = pow(im, -1.0) * im;
} else {
tmp = fma(fma(fma(0.16666666666666666, re, 0.5), re, 1.0), re, 1.0) * fma(((0.041666666666666664 * (im * im)) - 0.5), (im * im), 1.0);
}
return tmp;
}
function code(re, im) t_0 = Float64(exp(re) * cos(im)) tmp = 0.0 if (t_0 <= -0.58) tmp = Float64(Float64(fma(0.16666666666666666, re, 0.5) * Float64(re * re)) * fma(Float64(im * im), -0.5, 1.0)); elseif (t_0 <= 0.0) tmp = Float64(Float64(-0.5 * im) * im); elseif (t_0 <= 0.95) tmp = Float64((im ^ -1.0) * im); else tmp = Float64(fma(fma(fma(0.16666666666666666, re, 0.5), re, 1.0), re, 1.0) * fma(Float64(Float64(0.041666666666666664 * Float64(im * im)) - 0.5), Float64(im * im), 1.0)); end return tmp end
code[re_, im_] := Block[{t$95$0 = N[(N[Exp[re], $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -0.58], N[(N[(N[(0.16666666666666666 * re + 0.5), $MachinePrecision] * N[(re * re), $MachinePrecision]), $MachinePrecision] * N[(N[(im * im), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 0.0], N[(N[(-0.5 * im), $MachinePrecision] * im), $MachinePrecision], If[LessEqual[t$95$0, 0.95], N[(N[Power[im, -1.0], $MachinePrecision] * im), $MachinePrecision], N[(N[(N[(N[(0.16666666666666666 * re + 0.5), $MachinePrecision] * re + 1.0), $MachinePrecision] * re + 1.0), $MachinePrecision] * N[(N[(N[(0.041666666666666664 * N[(im * im), $MachinePrecision]), $MachinePrecision] - 0.5), $MachinePrecision] * N[(im * im), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := e^{re} \cdot \cos im\\
\mathbf{if}\;t\_0 \leq -0.58:\\
\;\;\;\;\left(\mathsf{fma}\left(0.16666666666666666, re, 0.5\right) \cdot \left(re \cdot re\right)\right) \cdot \mathsf{fma}\left(im \cdot im, -0.5, 1\right)\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;\left(-0.5 \cdot im\right) \cdot im\\
\mathbf{elif}\;t\_0 \leq 0.95:\\
\;\;\;\;{im}^{-1} \cdot im\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(0.16666666666666666, re, 0.5\right), re, 1\right), re, 1\right) \cdot \mathsf{fma}\left(0.041666666666666664 \cdot \left(im \cdot im\right) - 0.5, im \cdot im, 1\right)\\
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (cos.f64 im)) < -0.57999999999999996Initial program 100.0%
Taylor expanded in im around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6449.5
Applied rewrites49.5%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites49.5%
Applied rewrites49.5%
Taylor expanded in re around inf
Applied rewrites49.9%
if -0.57999999999999996 < (*.f64 (exp.f64 re) (cos.f64 im)) < 0.0Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f6420.8
Applied rewrites20.8%
Taylor expanded in im around 0
Applied rewrites2.9%
Taylor expanded in im around inf
Applied rewrites25.1%
Applied rewrites25.1%
if 0.0 < (*.f64 (exp.f64 re) (cos.f64 im)) < 0.94999999999999996Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f6497.7
Applied rewrites97.7%
Taylor expanded in im around 0
Applied rewrites0.9%
Taylor expanded in im around inf
Applied rewrites0.9%
Taylor expanded in im around 0
Applied rewrites19.4%
if 0.94999999999999996 < (*.f64 (exp.f64 re) (cos.f64 im)) Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6484.6
Applied rewrites84.6%
Taylor expanded in im around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6489.8
Applied rewrites89.8%
Final simplification55.4%
(FPCore (re im)
:precision binary64
(let* ((t_0 (* (exp re) (cos im))))
(if (<= t_0 -100.0)
(* (+ 1.0 re) (fma (* im im) -0.5 1.0))
(if (<= t_0 0.0)
(* (* -0.5 im) im)
(if (<= t_0 0.999)
(* (pow im -1.0) im)
(fma (- (* 0.041666666666666664 (* im im)) 0.5) (* im im) 1.0))))))
double code(double re, double im) {
double t_0 = exp(re) * cos(im);
double tmp;
if (t_0 <= -100.0) {
tmp = (1.0 + re) * fma((im * im), -0.5, 1.0);
} else if (t_0 <= 0.0) {
tmp = (-0.5 * im) * im;
} else if (t_0 <= 0.999) {
tmp = pow(im, -1.0) * im;
} else {
tmp = fma(((0.041666666666666664 * (im * im)) - 0.5), (im * im), 1.0);
}
return tmp;
}
function code(re, im) t_0 = Float64(exp(re) * cos(im)) tmp = 0.0 if (t_0 <= -100.0) tmp = Float64(Float64(1.0 + re) * fma(Float64(im * im), -0.5, 1.0)); elseif (t_0 <= 0.0) tmp = Float64(Float64(-0.5 * im) * im); elseif (t_0 <= 0.999) tmp = Float64((im ^ -1.0) * im); else tmp = fma(Float64(Float64(0.041666666666666664 * Float64(im * im)) - 0.5), Float64(im * im), 1.0); end return tmp end
code[re_, im_] := Block[{t$95$0 = N[(N[Exp[re], $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -100.0], N[(N[(1.0 + re), $MachinePrecision] * N[(N[(im * im), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 0.0], N[(N[(-0.5 * im), $MachinePrecision] * im), $MachinePrecision], If[LessEqual[t$95$0, 0.999], N[(N[Power[im, -1.0], $MachinePrecision] * im), $MachinePrecision], N[(N[(N[(0.041666666666666664 * N[(im * im), $MachinePrecision]), $MachinePrecision] - 0.5), $MachinePrecision] * N[(im * im), $MachinePrecision] + 1.0), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := e^{re} \cdot \cos im\\
\mathbf{if}\;t\_0 \leq -100:\\
\;\;\;\;\left(1 + re\right) \cdot \mathsf{fma}\left(im \cdot im, -0.5, 1\right)\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;\left(-0.5 \cdot im\right) \cdot im\\
\mathbf{elif}\;t\_0 \leq 0.999:\\
\;\;\;\;{im}^{-1} \cdot im\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(0.041666666666666664 \cdot \left(im \cdot im\right) - 0.5, im \cdot im, 1\right)\\
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (cos.f64 im)) < -100Initial program 100.0%
Taylor expanded in im around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6494.6
Applied rewrites94.6%
Taylor expanded in re around 0
lower-+.f6468.4
Applied rewrites68.4%
if -100 < (*.f64 (exp.f64 re) (cos.f64 im)) < 0.0Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f6435.0
Applied rewrites35.0%
Taylor expanded in im around 0
Applied rewrites3.2%
Taylor expanded in im around inf
Applied rewrites21.3%
Applied rewrites21.3%
if 0.0 < (*.f64 (exp.f64 re) (cos.f64 im)) < 0.998999999999999999Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f6495.6
Applied rewrites95.6%
Taylor expanded in im around 0
Applied rewrites1.7%
Taylor expanded in im around inf
Applied rewrites1.0%
Taylor expanded in im around 0
Applied rewrites20.0%
if 0.998999999999999999 < (*.f64 (exp.f64 re) (cos.f64 im)) Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f6458.0
Applied rewrites58.0%
Taylor expanded in im around 0
Applied rewrites68.0%
Final simplification44.0%
(FPCore (re im)
:precision binary64
(let* ((t_0 (* (exp re) (cos im))))
(if (<= t_0 -100.0)
(* (+ 1.0 re) (fma (* im im) -0.5 1.0))
(if (<= t_0 0.0) (* (* -0.5 im) im) (* (pow im -1.0) im)))))
double code(double re, double im) {
double t_0 = exp(re) * cos(im);
double tmp;
if (t_0 <= -100.0) {
tmp = (1.0 + re) * fma((im * im), -0.5, 1.0);
} else if (t_0 <= 0.0) {
tmp = (-0.5 * im) * im;
} else {
tmp = pow(im, -1.0) * im;
}
return tmp;
}
function code(re, im) t_0 = Float64(exp(re) * cos(im)) tmp = 0.0 if (t_0 <= -100.0) tmp = Float64(Float64(1.0 + re) * fma(Float64(im * im), -0.5, 1.0)); elseif (t_0 <= 0.0) tmp = Float64(Float64(-0.5 * im) * im); else tmp = Float64((im ^ -1.0) * im); end return tmp end
code[re_, im_] := Block[{t$95$0 = N[(N[Exp[re], $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -100.0], N[(N[(1.0 + re), $MachinePrecision] * N[(N[(im * im), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 0.0], N[(N[(-0.5 * im), $MachinePrecision] * im), $MachinePrecision], N[(N[Power[im, -1.0], $MachinePrecision] * im), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := e^{re} \cdot \cos im\\
\mathbf{if}\;t\_0 \leq -100:\\
\;\;\;\;\left(1 + re\right) \cdot \mathsf{fma}\left(im \cdot im, -0.5, 1\right)\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;\left(-0.5 \cdot im\right) \cdot im\\
\mathbf{else}:\\
\;\;\;\;{im}^{-1} \cdot im\\
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (cos.f64 im)) < -100Initial program 100.0%
Taylor expanded in im around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6494.6
Applied rewrites94.6%
Taylor expanded in re around 0
lower-+.f6468.4
Applied rewrites68.4%
if -100 < (*.f64 (exp.f64 re) (cos.f64 im)) < 0.0Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f6435.0
Applied rewrites35.0%
Taylor expanded in im around 0
Applied rewrites3.2%
Taylor expanded in im around inf
Applied rewrites21.3%
Applied rewrites21.3%
if 0.0 < (*.f64 (exp.f64 re) (cos.f64 im)) Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f6466.8
Applied rewrites66.8%
Taylor expanded in im around 0
Applied rewrites44.4%
Taylor expanded in im around inf
Applied rewrites35.5%
Taylor expanded in im around 0
Applied rewrites48.8%
Final simplification39.7%
(FPCore (re im) :precision binary64 (if (<= (* (exp re) (cos im)) 0.0) (* (* -0.5 im) im) (* (pow im -1.0) im)))
double code(double re, double im) {
double tmp;
if ((exp(re) * cos(im)) <= 0.0) {
tmp = (-0.5 * im) * im;
} else {
tmp = pow(im, -1.0) * 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(re, im)
use fmin_fmax_functions
real(8), intent (in) :: re
real(8), intent (in) :: im
real(8) :: tmp
if ((exp(re) * cos(im)) <= 0.0d0) then
tmp = ((-0.5d0) * im) * im
else
tmp = (im ** (-1.0d0)) * im
end if
code = tmp
end function
public static double code(double re, double im) {
double tmp;
if ((Math.exp(re) * Math.cos(im)) <= 0.0) {
tmp = (-0.5 * im) * im;
} else {
tmp = Math.pow(im, -1.0) * im;
}
return tmp;
}
def code(re, im): tmp = 0 if (math.exp(re) * math.cos(im)) <= 0.0: tmp = (-0.5 * im) * im else: tmp = math.pow(im, -1.0) * im return tmp
function code(re, im) tmp = 0.0 if (Float64(exp(re) * cos(im)) <= 0.0) tmp = Float64(Float64(-0.5 * im) * im); else tmp = Float64((im ^ -1.0) * im); end return tmp end
function tmp_2 = code(re, im) tmp = 0.0; if ((exp(re) * cos(im)) <= 0.0) tmp = (-0.5 * im) * im; else tmp = (im ^ -1.0) * im; end tmp_2 = tmp; end
code[re_, im_] := If[LessEqual[N[(N[Exp[re], $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision], 0.0], N[(N[(-0.5 * im), $MachinePrecision] * im), $MachinePrecision], N[(N[Power[im, -1.0], $MachinePrecision] * im), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{re} \cdot \cos im \leq 0:\\
\;\;\;\;\left(-0.5 \cdot im\right) \cdot im\\
\mathbf{else}:\\
\;\;\;\;{im}^{-1} \cdot im\\
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (cos.f64 im)) < 0.0Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f6430.1
Applied rewrites30.1%
Taylor expanded in im around 0
Applied rewrites9.1%
Taylor expanded in im around inf
Applied rewrites24.4%
Applied rewrites24.4%
if 0.0 < (*.f64 (exp.f64 re) (cos.f64 im)) Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f6466.8
Applied rewrites66.8%
Taylor expanded in im around 0
Applied rewrites44.4%
Taylor expanded in im around inf
Applied rewrites35.5%
Taylor expanded in im around 0
Applied rewrites48.8%
Final simplification37.8%
(FPCore (re im) :precision binary64 (if (<= (* (exp re) (cos im)) 0.0) (* (* -0.5 im) im) (fma (* im im) -0.5 1.0)))
double code(double re, double im) {
double tmp;
if ((exp(re) * cos(im)) <= 0.0) {
tmp = (-0.5 * im) * im;
} else {
tmp = fma((im * im), -0.5, 1.0);
}
return tmp;
}
function code(re, im) tmp = 0.0 if (Float64(exp(re) * cos(im)) <= 0.0) tmp = Float64(Float64(-0.5 * im) * im); else tmp = fma(Float64(im * im), -0.5, 1.0); end return tmp end
code[re_, im_] := If[LessEqual[N[(N[Exp[re], $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision], 0.0], N[(N[(-0.5 * im), $MachinePrecision] * im), $MachinePrecision], N[(N[(im * im), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{re} \cdot \cos im \leq 0:\\
\;\;\;\;\left(-0.5 \cdot im\right) \cdot im\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(im \cdot im, -0.5, 1\right)\\
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (cos.f64 im)) < 0.0Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f6430.1
Applied rewrites30.1%
Taylor expanded in im around 0
Applied rewrites9.1%
Taylor expanded in im around inf
Applied rewrites24.4%
Applied rewrites24.4%
if 0.0 < (*.f64 (exp.f64 re) (cos.f64 im)) Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f6466.8
Applied rewrites66.8%
Taylor expanded in im around 0
Applied rewrites44.4%
(FPCore (re im)
:precision binary64
(let* ((t_0 (* (fma (fma 0.16666666666666666 re 0.5) re 1.0) re))
(t_1 (- 1.0 t_0))
(t_2 (- 1.0 (* t_0 t_0))))
(if (<= re -1.25e+122)
(* (/ 1.0 t_1) (cos im))
(if (<= re -4.8e-15)
(* (exp re) (fma (* im im) -0.5 1.0))
(if (<= re 5.2)
(* (/ t_2 t_1) (cos im))
(if (<= re 4.3e+51)
(*
(exp re)
(fma (- (* 0.041666666666666664 (* im im)) 0.5) (* im im) 1.0))
(* (/ t_2 (- 1.0 re)) (cos im))))))))
double code(double re, double im) {
double t_0 = fma(fma(0.16666666666666666, re, 0.5), re, 1.0) * re;
double t_1 = 1.0 - t_0;
double t_2 = 1.0 - (t_0 * t_0);
double tmp;
if (re <= -1.25e+122) {
tmp = (1.0 / t_1) * cos(im);
} else if (re <= -4.8e-15) {
tmp = exp(re) * fma((im * im), -0.5, 1.0);
} else if (re <= 5.2) {
tmp = (t_2 / t_1) * cos(im);
} else if (re <= 4.3e+51) {
tmp = exp(re) * fma(((0.041666666666666664 * (im * im)) - 0.5), (im * im), 1.0);
} else {
tmp = (t_2 / (1.0 - re)) * cos(im);
}
return tmp;
}
function code(re, im) t_0 = Float64(fma(fma(0.16666666666666666, re, 0.5), re, 1.0) * re) t_1 = Float64(1.0 - t_0) t_2 = Float64(1.0 - Float64(t_0 * t_0)) tmp = 0.0 if (re <= -1.25e+122) tmp = Float64(Float64(1.0 / t_1) * cos(im)); elseif (re <= -4.8e-15) tmp = Float64(exp(re) * fma(Float64(im * im), -0.5, 1.0)); elseif (re <= 5.2) tmp = Float64(Float64(t_2 / t_1) * cos(im)); elseif (re <= 4.3e+51) tmp = Float64(exp(re) * fma(Float64(Float64(0.041666666666666664 * Float64(im * im)) - 0.5), Float64(im * im), 1.0)); else tmp = Float64(Float64(t_2 / Float64(1.0 - re)) * cos(im)); end return tmp end
code[re_, im_] := Block[{t$95$0 = N[(N[(N[(0.16666666666666666 * re + 0.5), $MachinePrecision] * re + 1.0), $MachinePrecision] * re), $MachinePrecision]}, Block[{t$95$1 = N[(1.0 - t$95$0), $MachinePrecision]}, Block[{t$95$2 = N[(1.0 - N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[re, -1.25e+122], N[(N[(1.0 / t$95$1), $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision], If[LessEqual[re, -4.8e-15], N[(N[Exp[re], $MachinePrecision] * N[(N[(im * im), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[re, 5.2], N[(N[(t$95$2 / t$95$1), $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision], If[LessEqual[re, 4.3e+51], N[(N[Exp[re], $MachinePrecision] * N[(N[(N[(0.041666666666666664 * N[(im * im), $MachinePrecision]), $MachinePrecision] - 0.5), $MachinePrecision] * N[(im * im), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(N[(t$95$2 / N[(1.0 - re), $MachinePrecision]), $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(\mathsf{fma}\left(0.16666666666666666, re, 0.5\right), re, 1\right) \cdot re\\
t_1 := 1 - t\_0\\
t_2 := 1 - t\_0 \cdot t\_0\\
\mathbf{if}\;re \leq -1.25 \cdot 10^{+122}:\\
\;\;\;\;\frac{1}{t\_1} \cdot \cos im\\
\mathbf{elif}\;re \leq -4.8 \cdot 10^{-15}:\\
\;\;\;\;e^{re} \cdot \mathsf{fma}\left(im \cdot im, -0.5, 1\right)\\
\mathbf{elif}\;re \leq 5.2:\\
\;\;\;\;\frac{t\_2}{t\_1} \cdot \cos im\\
\mathbf{elif}\;re \leq 4.3 \cdot 10^{+51}:\\
\;\;\;\;e^{re} \cdot \mathsf{fma}\left(0.041666666666666664 \cdot \left(im \cdot im\right) - 0.5, im \cdot im, 1\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_2}{1 - re} \cdot \cos im\\
\end{array}
\end{array}
if re < -1.24999999999999997e122Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f641.6
Applied rewrites1.6%
Applied rewrites0.0%
Taylor expanded in re around 0
Applied rewrites100.0%
if -1.24999999999999997e122 < re < -4.7999999999999999e-15Initial program 100.0%
Taylor expanded in im around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6487.9
Applied rewrites87.9%
if -4.7999999999999999e-15 < re < 5.20000000000000018Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6498.9
Applied rewrites98.9%
Applied rewrites98.9%
if 5.20000000000000018 < re < 4.2999999999999997e51Initial program 100.0%
Taylor expanded in im around 0
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
distribute-lft-neg-outN/A
distribute-lft-neg-outN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64100.0
Applied rewrites100.0%
if 4.2999999999999997e51 < re Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6480.6
Applied rewrites80.6%
Applied rewrites20.8%
Taylor expanded in re around 0
Applied rewrites100.0%
Final simplification97.9%
(FPCore (re im)
:precision binary64
(let* ((t_0 (fma (fma 0.16666666666666666 re 0.5) re 1.0)) (t_1 (* t_0 re)))
(if (<= re -1.25e+122)
(* (/ 1.0 (- 1.0 t_1)) (cos im))
(if (<= re -0.0255)
(* (exp re) (fma (* im im) -0.5 1.0))
(if (<= re 5.2)
(* (fma t_0 re 1.0) (cos im))
(if (<= re 4.3e+51)
(*
(exp re)
(fma (- (* 0.041666666666666664 (* im im)) 0.5) (* im im) 1.0))
(* (/ (- 1.0 (* t_1 t_1)) (- 1.0 re)) (cos im))))))))
double code(double re, double im) {
double t_0 = fma(fma(0.16666666666666666, re, 0.5), re, 1.0);
double t_1 = t_0 * re;
double tmp;
if (re <= -1.25e+122) {
tmp = (1.0 / (1.0 - t_1)) * cos(im);
} else if (re <= -0.0255) {
tmp = exp(re) * fma((im * im), -0.5, 1.0);
} else if (re <= 5.2) {
tmp = fma(t_0, re, 1.0) * cos(im);
} else if (re <= 4.3e+51) {
tmp = exp(re) * fma(((0.041666666666666664 * (im * im)) - 0.5), (im * im), 1.0);
} else {
tmp = ((1.0 - (t_1 * t_1)) / (1.0 - re)) * cos(im);
}
return tmp;
}
function code(re, im) t_0 = fma(fma(0.16666666666666666, re, 0.5), re, 1.0) t_1 = Float64(t_0 * re) tmp = 0.0 if (re <= -1.25e+122) tmp = Float64(Float64(1.0 / Float64(1.0 - t_1)) * cos(im)); elseif (re <= -0.0255) tmp = Float64(exp(re) * fma(Float64(im * im), -0.5, 1.0)); elseif (re <= 5.2) tmp = Float64(fma(t_0, re, 1.0) * cos(im)); elseif (re <= 4.3e+51) tmp = Float64(exp(re) * fma(Float64(Float64(0.041666666666666664 * Float64(im * im)) - 0.5), Float64(im * im), 1.0)); else tmp = Float64(Float64(Float64(1.0 - Float64(t_1 * t_1)) / Float64(1.0 - re)) * cos(im)); end return tmp end
code[re_, im_] := Block[{t$95$0 = N[(N[(0.16666666666666666 * re + 0.5), $MachinePrecision] * re + 1.0), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 * re), $MachinePrecision]}, If[LessEqual[re, -1.25e+122], N[(N[(1.0 / N[(1.0 - t$95$1), $MachinePrecision]), $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision], If[LessEqual[re, -0.0255], N[(N[Exp[re], $MachinePrecision] * N[(N[(im * im), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[re, 5.2], N[(N[(t$95$0 * re + 1.0), $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision], If[LessEqual[re, 4.3e+51], N[(N[Exp[re], $MachinePrecision] * N[(N[(N[(0.041666666666666664 * N[(im * im), $MachinePrecision]), $MachinePrecision] - 0.5), $MachinePrecision] * N[(im * im), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 - N[(t$95$1 * t$95$1), $MachinePrecision]), $MachinePrecision] / N[(1.0 - re), $MachinePrecision]), $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(\mathsf{fma}\left(0.16666666666666666, re, 0.5\right), re, 1\right)\\
t_1 := t\_0 \cdot re\\
\mathbf{if}\;re \leq -1.25 \cdot 10^{+122}:\\
\;\;\;\;\frac{1}{1 - t\_1} \cdot \cos im\\
\mathbf{elif}\;re \leq -0.0255:\\
\;\;\;\;e^{re} \cdot \mathsf{fma}\left(im \cdot im, -0.5, 1\right)\\
\mathbf{elif}\;re \leq 5.2:\\
\;\;\;\;\mathsf{fma}\left(t\_0, re, 1\right) \cdot \cos im\\
\mathbf{elif}\;re \leq 4.3 \cdot 10^{+51}:\\
\;\;\;\;e^{re} \cdot \mathsf{fma}\left(0.041666666666666664 \cdot \left(im \cdot im\right) - 0.5, im \cdot im, 1\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{1 - t\_1 \cdot t\_1}{1 - re} \cdot \cos im\\
\end{array}
\end{array}
if re < -1.24999999999999997e122Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f641.6
Applied rewrites1.6%
Applied rewrites0.0%
Taylor expanded in re around 0
Applied rewrites100.0%
if -1.24999999999999997e122 < re < -0.0254999999999999984Initial program 100.0%
Taylor expanded in im around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6487.1
Applied rewrites87.1%
if -0.0254999999999999984 < re < 5.20000000000000018Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6498.9
Applied rewrites98.9%
if 5.20000000000000018 < re < 4.2999999999999997e51Initial program 100.0%
Taylor expanded in im around 0
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
distribute-lft-neg-outN/A
distribute-lft-neg-outN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64100.0
Applied rewrites100.0%
if 4.2999999999999997e51 < re Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6480.6
Applied rewrites80.6%
Applied rewrites20.8%
Taylor expanded in re around 0
Applied rewrites100.0%
Final simplification97.9%
(FPCore (re im)
:precision binary64
(let* ((t_0 (fma (fma 0.16666666666666666 re 0.5) re 1.0)))
(if (<= re -1.25e+122)
(* (/ 1.0 (- 1.0 (* t_0 re))) (cos im))
(if (<= re -0.0255)
(* (exp re) (fma (* im im) -0.5 1.0))
(if (<= re 5.2)
(* (fma t_0 re 1.0) (cos im))
(if (<= re 2.1e+94)
(*
(exp re)
(fma (- (* 0.041666666666666664 (* im im)) 0.5) (* im im) 1.0))
(* (* (fma 0.16666666666666666 re 0.5) (* re re)) (cos im))))))))
double code(double re, double im) {
double t_0 = fma(fma(0.16666666666666666, re, 0.5), re, 1.0);
double tmp;
if (re <= -1.25e+122) {
tmp = (1.0 / (1.0 - (t_0 * re))) * cos(im);
} else if (re <= -0.0255) {
tmp = exp(re) * fma((im * im), -0.5, 1.0);
} else if (re <= 5.2) {
tmp = fma(t_0, re, 1.0) * cos(im);
} else if (re <= 2.1e+94) {
tmp = exp(re) * fma(((0.041666666666666664 * (im * im)) - 0.5), (im * im), 1.0);
} else {
tmp = (fma(0.16666666666666666, re, 0.5) * (re * re)) * cos(im);
}
return tmp;
}
function code(re, im) t_0 = fma(fma(0.16666666666666666, re, 0.5), re, 1.0) tmp = 0.0 if (re <= -1.25e+122) tmp = Float64(Float64(1.0 / Float64(1.0 - Float64(t_0 * re))) * cos(im)); elseif (re <= -0.0255) tmp = Float64(exp(re) * fma(Float64(im * im), -0.5, 1.0)); elseif (re <= 5.2) tmp = Float64(fma(t_0, re, 1.0) * cos(im)); elseif (re <= 2.1e+94) tmp = Float64(exp(re) * fma(Float64(Float64(0.041666666666666664 * Float64(im * im)) - 0.5), Float64(im * im), 1.0)); else tmp = Float64(Float64(fma(0.16666666666666666, re, 0.5) * Float64(re * re)) * cos(im)); end return tmp end
code[re_, im_] := Block[{t$95$0 = N[(N[(0.16666666666666666 * re + 0.5), $MachinePrecision] * re + 1.0), $MachinePrecision]}, If[LessEqual[re, -1.25e+122], N[(N[(1.0 / N[(1.0 - N[(t$95$0 * re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision], If[LessEqual[re, -0.0255], N[(N[Exp[re], $MachinePrecision] * N[(N[(im * im), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[re, 5.2], N[(N[(t$95$0 * re + 1.0), $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision], If[LessEqual[re, 2.1e+94], N[(N[Exp[re], $MachinePrecision] * N[(N[(N[(0.041666666666666664 * N[(im * im), $MachinePrecision]), $MachinePrecision] - 0.5), $MachinePrecision] * N[(im * im), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(N[(N[(0.16666666666666666 * re + 0.5), $MachinePrecision] * N[(re * re), $MachinePrecision]), $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(\mathsf{fma}\left(0.16666666666666666, re, 0.5\right), re, 1\right)\\
\mathbf{if}\;re \leq -1.25 \cdot 10^{+122}:\\
\;\;\;\;\frac{1}{1 - t\_0 \cdot re} \cdot \cos im\\
\mathbf{elif}\;re \leq -0.0255:\\
\;\;\;\;e^{re} \cdot \mathsf{fma}\left(im \cdot im, -0.5, 1\right)\\
\mathbf{elif}\;re \leq 5.2:\\
\;\;\;\;\mathsf{fma}\left(t\_0, re, 1\right) \cdot \cos im\\
\mathbf{elif}\;re \leq 2.1 \cdot 10^{+94}:\\
\;\;\;\;e^{re} \cdot \mathsf{fma}\left(0.041666666666666664 \cdot \left(im \cdot im\right) - 0.5, im \cdot im, 1\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\mathsf{fma}\left(0.16666666666666666, re, 0.5\right) \cdot \left(re \cdot re\right)\right) \cdot \cos im\\
\end{array}
\end{array}
if re < -1.24999999999999997e122Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f641.6
Applied rewrites1.6%
Applied rewrites0.0%
Taylor expanded in re around 0
Applied rewrites100.0%
if -1.24999999999999997e122 < re < -0.0254999999999999984Initial program 100.0%
Taylor expanded in im around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6487.1
Applied rewrites87.1%
if -0.0254999999999999984 < re < 5.20000000000000018Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6498.9
Applied rewrites98.9%
if 5.20000000000000018 < re < 2.09999999999999989e94Initial program 100.0%
Taylor expanded in im around 0
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
distribute-lft-neg-outN/A
distribute-lft-neg-outN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6494.4
Applied rewrites94.4%
if 2.09999999999999989e94 < re Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6495.9
Applied rewrites95.9%
Taylor expanded in re around inf
Applied rewrites95.9%
Final simplification96.8%
(FPCore (re im)
:precision binary64
(if (<= re -0.0255)
(* (exp re) (fma (* im im) -0.5 1.0))
(if (<= re 5.2)
(* (fma (fma (fma 0.16666666666666666 re 0.5) re 1.0) re 1.0) (cos im))
(if (<= re 2.1e+94)
(*
(exp re)
(fma (- (* 0.041666666666666664 (* im im)) 0.5) (* im im) 1.0))
(* (* (fma 0.16666666666666666 re 0.5) (* re re)) (cos im))))))
double code(double re, double im) {
double tmp;
if (re <= -0.0255) {
tmp = exp(re) * fma((im * im), -0.5, 1.0);
} else if (re <= 5.2) {
tmp = fma(fma(fma(0.16666666666666666, re, 0.5), re, 1.0), re, 1.0) * cos(im);
} else if (re <= 2.1e+94) {
tmp = exp(re) * fma(((0.041666666666666664 * (im * im)) - 0.5), (im * im), 1.0);
} else {
tmp = (fma(0.16666666666666666, re, 0.5) * (re * re)) * cos(im);
}
return tmp;
}
function code(re, im) tmp = 0.0 if (re <= -0.0255) tmp = Float64(exp(re) * fma(Float64(im * im), -0.5, 1.0)); elseif (re <= 5.2) tmp = Float64(fma(fma(fma(0.16666666666666666, re, 0.5), re, 1.0), re, 1.0) * cos(im)); elseif (re <= 2.1e+94) tmp = Float64(exp(re) * fma(Float64(Float64(0.041666666666666664 * Float64(im * im)) - 0.5), Float64(im * im), 1.0)); else tmp = Float64(Float64(fma(0.16666666666666666, re, 0.5) * Float64(re * re)) * cos(im)); end return tmp end
code[re_, im_] := If[LessEqual[re, -0.0255], N[(N[Exp[re], $MachinePrecision] * N[(N[(im * im), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[re, 5.2], N[(N[(N[(N[(0.16666666666666666 * re + 0.5), $MachinePrecision] * re + 1.0), $MachinePrecision] * re + 1.0), $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision], If[LessEqual[re, 2.1e+94], N[(N[Exp[re], $MachinePrecision] * N[(N[(N[(0.041666666666666664 * N[(im * im), $MachinePrecision]), $MachinePrecision] - 0.5), $MachinePrecision] * N[(im * im), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(N[(N[(0.16666666666666666 * re + 0.5), $MachinePrecision] * N[(re * re), $MachinePrecision]), $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;re \leq -0.0255:\\
\;\;\;\;e^{re} \cdot \mathsf{fma}\left(im \cdot im, -0.5, 1\right)\\
\mathbf{elif}\;re \leq 5.2:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(0.16666666666666666, re, 0.5\right), re, 1\right), re, 1\right) \cdot \cos im\\
\mathbf{elif}\;re \leq 2.1 \cdot 10^{+94}:\\
\;\;\;\;e^{re} \cdot \mathsf{fma}\left(0.041666666666666664 \cdot \left(im \cdot im\right) - 0.5, im \cdot im, 1\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\mathsf{fma}\left(0.16666666666666666, re, 0.5\right) \cdot \left(re \cdot re\right)\right) \cdot \cos im\\
\end{array}
\end{array}
if re < -0.0254999999999999984Initial program 100.0%
Taylor expanded in im around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6474.2
Applied rewrites74.2%
if -0.0254999999999999984 < re < 5.20000000000000018Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6498.9
Applied rewrites98.9%
if 5.20000000000000018 < re < 2.09999999999999989e94Initial program 100.0%
Taylor expanded in im around 0
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
distribute-lft-neg-outN/A
distribute-lft-neg-outN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6494.4
Applied rewrites94.4%
if 2.09999999999999989e94 < re Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6495.9
Applied rewrites95.9%
Taylor expanded in re around inf
Applied rewrites95.9%
(FPCore (re im)
:precision binary64
(let* ((t_0 (* (exp re) (fma (* im im) -0.5 1.0))))
(if (<= re -0.0255)
t_0
(if (<= re 5.2)
(* (fma (fma (fma 0.16666666666666666 re 0.5) re 1.0) re 1.0) (cos im))
(if (<= re 1.4e+154) t_0 (* (fma (* re re) 0.5 re) (cos im)))))))
double code(double re, double im) {
double t_0 = exp(re) * fma((im * im), -0.5, 1.0);
double tmp;
if (re <= -0.0255) {
tmp = t_0;
} else if (re <= 5.2) {
tmp = fma(fma(fma(0.16666666666666666, re, 0.5), re, 1.0), re, 1.0) * cos(im);
} else if (re <= 1.4e+154) {
tmp = t_0;
} else {
tmp = fma((re * re), 0.5, re) * cos(im);
}
return tmp;
}
function code(re, im) t_0 = Float64(exp(re) * fma(Float64(im * im), -0.5, 1.0)) tmp = 0.0 if (re <= -0.0255) tmp = t_0; elseif (re <= 5.2) tmp = Float64(fma(fma(fma(0.16666666666666666, re, 0.5), re, 1.0), re, 1.0) * cos(im)); elseif (re <= 1.4e+154) tmp = t_0; else tmp = Float64(fma(Float64(re * re), 0.5, re) * cos(im)); end return tmp end
code[re_, im_] := Block[{t$95$0 = N[(N[Exp[re], $MachinePrecision] * N[(N[(im * im), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[re, -0.0255], t$95$0, If[LessEqual[re, 5.2], N[(N[(N[(N[(0.16666666666666666 * re + 0.5), $MachinePrecision] * re + 1.0), $MachinePrecision] * re + 1.0), $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision], If[LessEqual[re, 1.4e+154], t$95$0, N[(N[(N[(re * re), $MachinePrecision] * 0.5 + re), $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := e^{re} \cdot \mathsf{fma}\left(im \cdot im, -0.5, 1\right)\\
\mathbf{if}\;re \leq -0.0255:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;re \leq 5.2:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(0.16666666666666666, re, 0.5\right), re, 1\right), re, 1\right) \cdot \cos im\\
\mathbf{elif}\;re \leq 1.4 \cdot 10^{+154}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(re \cdot re, 0.5, re\right) \cdot \cos im\\
\end{array}
\end{array}
if re < -0.0254999999999999984 or 5.20000000000000018 < re < 1.4e154Initial program 100.0%
Taylor expanded in im around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6474.7
Applied rewrites74.7%
if -0.0254999999999999984 < re < 5.20000000000000018Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6498.9
Applied rewrites98.9%
if 1.4e154 < re Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64100.0
Applied rewrites100.0%
Taylor expanded in re around inf
Applied rewrites100.0%
Taylor expanded in re around 0
Applied rewrites100.0%
(FPCore (re im)
:precision binary64
(let* ((t_0 (* (exp re) (fma (* im im) -0.5 1.0))))
(if (<= re -4.2e-5)
t_0
(if (<= re 5.2)
(* (fma (fma 0.5 re 1.0) re 1.0) (cos im))
(if (<= re 1.4e+154) t_0 (* (fma (* re re) 0.5 re) (cos im)))))))
double code(double re, double im) {
double t_0 = exp(re) * fma((im * im), -0.5, 1.0);
double tmp;
if (re <= -4.2e-5) {
tmp = t_0;
} else if (re <= 5.2) {
tmp = fma(fma(0.5, re, 1.0), re, 1.0) * cos(im);
} else if (re <= 1.4e+154) {
tmp = t_0;
} else {
tmp = fma((re * re), 0.5, re) * cos(im);
}
return tmp;
}
function code(re, im) t_0 = Float64(exp(re) * fma(Float64(im * im), -0.5, 1.0)) tmp = 0.0 if (re <= -4.2e-5) tmp = t_0; elseif (re <= 5.2) tmp = Float64(fma(fma(0.5, re, 1.0), re, 1.0) * cos(im)); elseif (re <= 1.4e+154) tmp = t_0; else tmp = Float64(fma(Float64(re * re), 0.5, re) * cos(im)); end return tmp end
code[re_, im_] := Block[{t$95$0 = N[(N[Exp[re], $MachinePrecision] * N[(N[(im * im), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[re, -4.2e-5], t$95$0, If[LessEqual[re, 5.2], N[(N[(N[(0.5 * re + 1.0), $MachinePrecision] * re + 1.0), $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision], If[LessEqual[re, 1.4e+154], t$95$0, N[(N[(N[(re * re), $MachinePrecision] * 0.5 + re), $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := e^{re} \cdot \mathsf{fma}\left(im \cdot im, -0.5, 1\right)\\
\mathbf{if}\;re \leq -4.2 \cdot 10^{-5}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;re \leq 5.2:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(0.5, re, 1\right), re, 1\right) \cdot \cos im\\
\mathbf{elif}\;re \leq 1.4 \cdot 10^{+154}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(re \cdot re, 0.5, re\right) \cdot \cos im\\
\end{array}
\end{array}
if re < -4.19999999999999977e-5 or 5.20000000000000018 < re < 1.4e154Initial program 100.0%
Taylor expanded in im around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6475.0
Applied rewrites75.0%
if -4.19999999999999977e-5 < re < 5.20000000000000018Initial program 100.0%
Taylor expanded in re around 0
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6498.7
Applied rewrites98.7%
if 1.4e154 < re Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64100.0
Applied rewrites100.0%
Taylor expanded in re around inf
Applied rewrites100.0%
Taylor expanded in re around 0
Applied rewrites100.0%
(FPCore (re im)
:precision binary64
(let* ((t_0 (* (exp re) (fma (* im im) -0.5 1.0))))
(if (<= re -3.4e-5)
t_0
(if (<= re 0.00044)
(* (+ 1.0 re) (cos im))
(if (<= re 1.4e+154) t_0 (* (fma (* re re) 0.5 re) (cos im)))))))
double code(double re, double im) {
double t_0 = exp(re) * fma((im * im), -0.5, 1.0);
double tmp;
if (re <= -3.4e-5) {
tmp = t_0;
} else if (re <= 0.00044) {
tmp = (1.0 + re) * cos(im);
} else if (re <= 1.4e+154) {
tmp = t_0;
} else {
tmp = fma((re * re), 0.5, re) * cos(im);
}
return tmp;
}
function code(re, im) t_0 = Float64(exp(re) * fma(Float64(im * im), -0.5, 1.0)) tmp = 0.0 if (re <= -3.4e-5) tmp = t_0; elseif (re <= 0.00044) tmp = Float64(Float64(1.0 + re) * cos(im)); elseif (re <= 1.4e+154) tmp = t_0; else tmp = Float64(fma(Float64(re * re), 0.5, re) * cos(im)); end return tmp end
code[re_, im_] := Block[{t$95$0 = N[(N[Exp[re], $MachinePrecision] * N[(N[(im * im), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[re, -3.4e-5], t$95$0, If[LessEqual[re, 0.00044], N[(N[(1.0 + re), $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision], If[LessEqual[re, 1.4e+154], t$95$0, N[(N[(N[(re * re), $MachinePrecision] * 0.5 + re), $MachinePrecision] * N[Cos[im], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := e^{re} \cdot \mathsf{fma}\left(im \cdot im, -0.5, 1\right)\\
\mathbf{if}\;re \leq -3.4 \cdot 10^{-5}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;re \leq 0.00044:\\
\;\;\;\;\left(1 + re\right) \cdot \cos im\\
\mathbf{elif}\;re \leq 1.4 \cdot 10^{+154}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(re \cdot re, 0.5, re\right) \cdot \cos im\\
\end{array}
\end{array}
if re < -3.4e-5 or 4.40000000000000016e-4 < re < 1.4e154Initial program 100.0%
Taylor expanded in im around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6473.8
Applied rewrites73.8%
if -3.4e-5 < re < 4.40000000000000016e-4Initial program 100.0%
Taylor expanded in re around 0
lower-+.f64100.0
Applied rewrites100.0%
if 1.4e154 < re Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
remove-double-negN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64100.0
Applied rewrites100.0%
Taylor expanded in re around inf
Applied rewrites100.0%
Taylor expanded in re around 0
Applied rewrites100.0%
(FPCore (re im)
:precision binary64
(if (<= re -440.0)
(* (* -0.5 im) im)
(if (<= re 1.02e-9)
(* (pow im -1.0) im)
(if (<= re 8.5e+90)
(fma
(fma
(* (fma 0.041666666666666664 re 0.041666666666666664) im)
im
(- (* -0.5 re) 0.5))
(* im im)
(+ 1.0 re))
(*
(* (fma 0.16666666666666666 re 0.5) (* re re))
(fma (* im im) -0.5 1.0))))))
double code(double re, double im) {
double tmp;
if (re <= -440.0) {
tmp = (-0.5 * im) * im;
} else if (re <= 1.02e-9) {
tmp = pow(im, -1.0) * im;
} else if (re <= 8.5e+90) {
tmp = fma(fma((fma(0.041666666666666664, re, 0.041666666666666664) * im), im, ((-0.5 * re) - 0.5)), (im * im), (1.0 + re));
} else {
tmp = (fma(0.16666666666666666, re, 0.5) * (re * re)) * fma((im * im), -0.5, 1.0);
}
return tmp;
}
function code(re, im) tmp = 0.0 if (re <= -440.0) tmp = Float64(Float64(-0.5 * im) * im); elseif (re <= 1.02e-9) tmp = Float64((im ^ -1.0) * im); elseif (re <= 8.5e+90) tmp = fma(fma(Float64(fma(0.041666666666666664, re, 0.041666666666666664) * im), im, Float64(Float64(-0.5 * re) - 0.5)), Float64(im * im), Float64(1.0 + re)); else tmp = Float64(Float64(fma(0.16666666666666666, re, 0.5) * Float64(re * re)) * fma(Float64(im * im), -0.5, 1.0)); end return tmp end
code[re_, im_] := If[LessEqual[re, -440.0], N[(N[(-0.5 * im), $MachinePrecision] * im), $MachinePrecision], If[LessEqual[re, 1.02e-9], N[(N[Power[im, -1.0], $MachinePrecision] * im), $MachinePrecision], If[LessEqual[re, 8.5e+90], N[(N[(N[(N[(0.041666666666666664 * re + 0.041666666666666664), $MachinePrecision] * im), $MachinePrecision] * im + N[(N[(-0.5 * re), $MachinePrecision] - 0.5), $MachinePrecision]), $MachinePrecision] * N[(im * im), $MachinePrecision] + N[(1.0 + re), $MachinePrecision]), $MachinePrecision], N[(N[(N[(0.16666666666666666 * re + 0.5), $MachinePrecision] * N[(re * re), $MachinePrecision]), $MachinePrecision] * N[(N[(im * im), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;re \leq -440:\\
\;\;\;\;\left(-0.5 \cdot im\right) \cdot im\\
\mathbf{elif}\;re \leq 1.02 \cdot 10^{-9}:\\
\;\;\;\;{im}^{-1} \cdot im\\
\mathbf{elif}\;re \leq 8.5 \cdot 10^{+90}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(0.041666666666666664, re, 0.041666666666666664\right) \cdot im, im, -0.5 \cdot re - 0.5\right), im \cdot im, 1 + re\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\mathsf{fma}\left(0.16666666666666666, re, 0.5\right) \cdot \left(re \cdot re\right)\right) \cdot \mathsf{fma}\left(im \cdot im, -0.5, 1\right)\\
\end{array}
\end{array}
if re < -440Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f643.1
Applied rewrites3.1%
Taylor expanded in im around 0
Applied rewrites2.5%
Taylor expanded in im around inf
Applied rewrites29.8%
Applied rewrites29.8%
if -440 < re < 1.01999999999999999e-9Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f6498.3
Applied rewrites98.3%
Taylor expanded in im around 0
Applied rewrites49.5%
Taylor expanded in im around inf
Applied rewrites31.2%
Taylor expanded in im around 0
Applied rewrites53.2%
if 1.01999999999999999e-9 < re < 8.5000000000000002e90Initial program 100.0%
Taylor expanded in re around 0
distribute-rgt1-inN/A
*-commutativeN/A
distribute-rgt-inN/A
*-commutativeN/A
*-lft-identityN/A
lower-fma.f64N/A
lower-cos.f64N/A
lower-cos.f648.2
Applied rewrites8.2%
Taylor expanded in im around 0
Applied rewrites34.3%
if 8.5000000000000002e90 < re Initial program 100.0%
Taylor expanded in im around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6480.0
Applied rewrites80.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites78.0%
Applied rewrites78.0%
Taylor expanded in re around inf
Applied rewrites78.0%
Final simplification50.1%
(FPCore (re im)
:precision binary64
(if (<= re -440.0)
(* (* -0.5 im) im)
(if (<= re 400.0)
(* (pow im -1.0) im)
(if (<= re 8.5e+90)
(fma (- (* 0.041666666666666664 (* im im)) 0.5) (* im im) 1.0)
(*
(* (fma 0.16666666666666666 re 0.5) (* re re))
(fma (* im im) -0.5 1.0))))))
double code(double re, double im) {
double tmp;
if (re <= -440.0) {
tmp = (-0.5 * im) * im;
} else if (re <= 400.0) {
tmp = pow(im, -1.0) * im;
} else if (re <= 8.5e+90) {
tmp = fma(((0.041666666666666664 * (im * im)) - 0.5), (im * im), 1.0);
} else {
tmp = (fma(0.16666666666666666, re, 0.5) * (re * re)) * fma((im * im), -0.5, 1.0);
}
return tmp;
}
function code(re, im) tmp = 0.0 if (re <= -440.0) tmp = Float64(Float64(-0.5 * im) * im); elseif (re <= 400.0) tmp = Float64((im ^ -1.0) * im); elseif (re <= 8.5e+90) tmp = fma(Float64(Float64(0.041666666666666664 * Float64(im * im)) - 0.5), Float64(im * im), 1.0); else tmp = Float64(Float64(fma(0.16666666666666666, re, 0.5) * Float64(re * re)) * fma(Float64(im * im), -0.5, 1.0)); end return tmp end
code[re_, im_] := If[LessEqual[re, -440.0], N[(N[(-0.5 * im), $MachinePrecision] * im), $MachinePrecision], If[LessEqual[re, 400.0], N[(N[Power[im, -1.0], $MachinePrecision] * im), $MachinePrecision], If[LessEqual[re, 8.5e+90], N[(N[(N[(0.041666666666666664 * N[(im * im), $MachinePrecision]), $MachinePrecision] - 0.5), $MachinePrecision] * N[(im * im), $MachinePrecision] + 1.0), $MachinePrecision], N[(N[(N[(0.16666666666666666 * re + 0.5), $MachinePrecision] * N[(re * re), $MachinePrecision]), $MachinePrecision] * N[(N[(im * im), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;re \leq -440:\\
\;\;\;\;\left(-0.5 \cdot im\right) \cdot im\\
\mathbf{elif}\;re \leq 400:\\
\;\;\;\;{im}^{-1} \cdot im\\
\mathbf{elif}\;re \leq 8.5 \cdot 10^{+90}:\\
\;\;\;\;\mathsf{fma}\left(0.041666666666666664 \cdot \left(im \cdot im\right) - 0.5, im \cdot im, 1\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\mathsf{fma}\left(0.16666666666666666, re, 0.5\right) \cdot \left(re \cdot re\right)\right) \cdot \mathsf{fma}\left(im \cdot im, -0.5, 1\right)\\
\end{array}
\end{array}
if re < -440Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f643.1
Applied rewrites3.1%
Taylor expanded in im around 0
Applied rewrites2.5%
Taylor expanded in im around inf
Applied rewrites29.8%
Applied rewrites29.8%
if -440 < re < 400Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f6496.5
Applied rewrites96.5%
Taylor expanded in im around 0
Applied rewrites48.6%
Taylor expanded in im around inf
Applied rewrites30.7%
Taylor expanded in im around 0
Applied rewrites52.3%
if 400 < re < 8.5000000000000002e90Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f643.1
Applied rewrites3.1%
Taylor expanded in im around 0
Applied rewrites37.2%
if 8.5000000000000002e90 < re Initial program 100.0%
Taylor expanded in im around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6480.0
Applied rewrites80.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites78.0%
Applied rewrites78.0%
Taylor expanded in re around inf
Applied rewrites78.0%
Final simplification50.1%
(FPCore (re im)
:precision binary64
(if (<= re -440.0)
(* (* -0.5 im) im)
(if (<= re 400.0)
(* (pow im -1.0) im)
(if (<= re 9e+90)
(fma (- (* 0.041666666666666664 (* im im)) 0.5) (* im im) 1.0)
(* (fma (fma 0.5 re 1.0) re 1.0) (fma (* im im) -0.5 1.0))))))
double code(double re, double im) {
double tmp;
if (re <= -440.0) {
tmp = (-0.5 * im) * im;
} else if (re <= 400.0) {
tmp = pow(im, -1.0) * im;
} else if (re <= 9e+90) {
tmp = fma(((0.041666666666666664 * (im * im)) - 0.5), (im * im), 1.0);
} else {
tmp = fma(fma(0.5, re, 1.0), re, 1.0) * fma((im * im), -0.5, 1.0);
}
return tmp;
}
function code(re, im) tmp = 0.0 if (re <= -440.0) tmp = Float64(Float64(-0.5 * im) * im); elseif (re <= 400.0) tmp = Float64((im ^ -1.0) * im); elseif (re <= 9e+90) tmp = fma(Float64(Float64(0.041666666666666664 * Float64(im * im)) - 0.5), Float64(im * im), 1.0); else tmp = Float64(fma(fma(0.5, re, 1.0), re, 1.0) * fma(Float64(im * im), -0.5, 1.0)); end return tmp end
code[re_, im_] := If[LessEqual[re, -440.0], N[(N[(-0.5 * im), $MachinePrecision] * im), $MachinePrecision], If[LessEqual[re, 400.0], N[(N[Power[im, -1.0], $MachinePrecision] * im), $MachinePrecision], If[LessEqual[re, 9e+90], N[(N[(N[(0.041666666666666664 * N[(im * im), $MachinePrecision]), $MachinePrecision] - 0.5), $MachinePrecision] * N[(im * im), $MachinePrecision] + 1.0), $MachinePrecision], N[(N[(N[(0.5 * re + 1.0), $MachinePrecision] * re + 1.0), $MachinePrecision] * N[(N[(im * im), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;re \leq -440:\\
\;\;\;\;\left(-0.5 \cdot im\right) \cdot im\\
\mathbf{elif}\;re \leq 400:\\
\;\;\;\;{im}^{-1} \cdot im\\
\mathbf{elif}\;re \leq 9 \cdot 10^{+90}:\\
\;\;\;\;\mathsf{fma}\left(0.041666666666666664 \cdot \left(im \cdot im\right) - 0.5, im \cdot im, 1\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(0.5, re, 1\right), re, 1\right) \cdot \mathsf{fma}\left(im \cdot im, -0.5, 1\right)\\
\end{array}
\end{array}
if re < -440Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f643.1
Applied rewrites3.1%
Taylor expanded in im around 0
Applied rewrites2.5%
Taylor expanded in im around inf
Applied rewrites29.8%
Applied rewrites29.8%
if -440 < re < 400Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f6496.5
Applied rewrites96.5%
Taylor expanded in im around 0
Applied rewrites48.6%
Taylor expanded in im around inf
Applied rewrites30.7%
Taylor expanded in im around 0
Applied rewrites52.3%
if 400 < re < 9e90Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f643.1
Applied rewrites3.1%
Taylor expanded in im around 0
Applied rewrites37.2%
if 9e90 < re Initial program 100.0%
Taylor expanded in im around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6480.0
Applied rewrites80.0%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6457.5
Applied rewrites57.5%
Final simplification46.5%
(FPCore (re im) :precision binary64 (* (* -0.5 im) im))
double code(double re, double im) {
return (-0.5 * im) * 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(re, im)
use fmin_fmax_functions
real(8), intent (in) :: re
real(8), intent (in) :: im
code = ((-0.5d0) * im) * im
end function
public static double code(double re, double im) {
return (-0.5 * im) * im;
}
def code(re, im): return (-0.5 * im) * im
function code(re, im) return Float64(Float64(-0.5 * im) * im) end
function tmp = code(re, im) tmp = (-0.5 * im) * im; end
code[re_, im_] := N[(N[(-0.5 * im), $MachinePrecision] * im), $MachinePrecision]
\begin{array}{l}
\\
\left(-0.5 \cdot im\right) \cdot im
\end{array}
Initial program 100.0%
Taylor expanded in re around 0
lower-cos.f6450.2
Applied rewrites50.2%
Taylor expanded in im around 0
Applied rewrites28.4%
Taylor expanded in im around inf
Applied rewrites12.0%
Applied rewrites12.0%
herbie shell --seed 2024357
(FPCore (re im)
:name "math.exp on complex, real part"
:precision binary64
(* (exp re) (cos im)))