
(FPCore (re im) :precision binary64 (* (exp re) (sin im)))
double code(double re, double im) {
return exp(re) * sin(im);
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
code = exp(re) * sin(im)
end function
public static double code(double re, double im) {
return Math.exp(re) * Math.sin(im);
}
def code(re, im): return math.exp(re) * math.sin(im)
function code(re, im) return Float64(exp(re) * sin(im)) end
function tmp = code(re, im) tmp = exp(re) * sin(im); end
code[re_, im_] := N[(N[Exp[re], $MachinePrecision] * N[Sin[im], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
e^{re} \cdot \sin im
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 24 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (re im) :precision binary64 (* (exp re) (sin im)))
double code(double re, double im) {
return exp(re) * sin(im);
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
code = exp(re) * sin(im)
end function
public static double code(double re, double im) {
return Math.exp(re) * Math.sin(im);
}
def code(re, im): return math.exp(re) * math.sin(im)
function code(re, im) return Float64(exp(re) * sin(im)) end
function tmp = code(re, im) tmp = exp(re) * sin(im); end
code[re_, im_] := N[(N[Exp[re], $MachinePrecision] * N[Sin[im], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
e^{re} \cdot \sin im
\end{array}
im\_m = (fabs.f64 im)
im\_s = (copysign.f64 #s(literal 1 binary64) im)
(FPCore (im_s re im_m)
:precision binary64
(let* ((t_0 (* (exp re) im_m))
(t_1 (* (exp re) (sin im_m)))
(t_2 (* (sin im_m) (fma re (fma re 0.5 1.0) 1.0))))
(*
im_s
(if (<= t_1 (- INFINITY))
(*
im_m
(fma
(* im_m im_m)
(* im_m (* -0.0001984126984126984 (* im_m (* im_m im_m))))
1.0))
(if (<= t_1 -0.02)
t_2
(if (<= t_1 0.0) t_0 (if (<= t_1 1.0) t_2 t_0)))))))im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
double t_0 = exp(re) * im_m;
double t_1 = exp(re) * sin(im_m);
double t_2 = sin(im_m) * fma(re, fma(re, 0.5, 1.0), 1.0);
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = im_m * fma((im_m * im_m), (im_m * (-0.0001984126984126984 * (im_m * (im_m * im_m)))), 1.0);
} else if (t_1 <= -0.02) {
tmp = t_2;
} else if (t_1 <= 0.0) {
tmp = t_0;
} else if (t_1 <= 1.0) {
tmp = t_2;
} else {
tmp = t_0;
}
return im_s * tmp;
}
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) t_0 = Float64(exp(re) * im_m) t_1 = Float64(exp(re) * sin(im_m)) t_2 = Float64(sin(im_m) * fma(re, fma(re, 0.5, 1.0), 1.0)) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = Float64(im_m * fma(Float64(im_m * im_m), Float64(im_m * Float64(-0.0001984126984126984 * Float64(im_m * Float64(im_m * im_m)))), 1.0)); elseif (t_1 <= -0.02) tmp = t_2; elseif (t_1 <= 0.0) tmp = t_0; elseif (t_1 <= 1.0) tmp = t_2; else tmp = t_0; end return Float64(im_s * tmp) end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := Block[{t$95$0 = N[(N[Exp[re], $MachinePrecision] * im$95$m), $MachinePrecision]}, Block[{t$95$1 = N[(N[Exp[re], $MachinePrecision] * N[Sin[im$95$m], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Sin[im$95$m], $MachinePrecision] * N[(re * N[(re * 0.5 + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, N[(im$95$s * If[LessEqual[t$95$1, (-Infinity)], N[(im$95$m * N[(N[(im$95$m * im$95$m), $MachinePrecision] * N[(im$95$m * N[(-0.0001984126984126984 * N[(im$95$m * N[(im$95$m * im$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -0.02], t$95$2, If[LessEqual[t$95$1, 0.0], t$95$0, If[LessEqual[t$95$1, 1.0], t$95$2, t$95$0]]]]), $MachinePrecision]]]]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
\begin{array}{l}
t_0 := e^{re} \cdot im\_m\\
t_1 := e^{re} \cdot \sin im\_m\\
t_2 := \sin im\_m \cdot \mathsf{fma}\left(re, \mathsf{fma}\left(re, 0.5, 1\right), 1\right)\\
im\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;im\_m \cdot \mathsf{fma}\left(im\_m \cdot im\_m, im\_m \cdot \left(-0.0001984126984126984 \cdot \left(im\_m \cdot \left(im\_m \cdot im\_m\right)\right)\right), 1\right)\\
\mathbf{elif}\;t\_1 \leq -0.02:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;t\_1 \leq 1:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (sin.f64 im)) < -inf.0Initial program 100.0%
Taylor expanded in re around 0
sin-lowering-sin.f642.7
Simplified2.7%
Taylor expanded in im around 0
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sub-negN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6438.5
Simplified38.5%
Taylor expanded in im around inf
metadata-evalN/A
pow-sqrN/A
associate-*l*N/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
unpow2N/A
unpow3N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6438.5
Simplified38.5%
if -inf.0 < (*.f64 (exp.f64 re) (sin.f64 im)) < -0.0200000000000000004 or 0.0 < (*.f64 (exp.f64 re) (sin.f64 im)) < 1Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f64100.0
Simplified100.0%
if -0.0200000000000000004 < (*.f64 (exp.f64 re) (sin.f64 im)) < 0.0 or 1 < (*.f64 (exp.f64 re) (sin.f64 im)) Initial program 100.0%
Taylor expanded in im around 0
Simplified95.5%
Final simplification91.9%
im\_m = (fabs.f64 im)
im\_s = (copysign.f64 #s(literal 1 binary64) im)
(FPCore (im_s re im_m)
:precision binary64
(let* ((t_0 (* (exp re) (sin im_m)))
(t_1 (* (sin im_m) (+ re 1.0)))
(t_2 (* (exp re) im_m)))
(*
im_s
(if (<= t_0 (- INFINITY))
(*
im_m
(fma
(* im_m im_m)
(* im_m (* -0.0001984126984126984 (* im_m (* im_m im_m))))
1.0))
(if (<= t_0 -0.02)
t_1
(if (<= t_0 0.0) t_2 (if (<= t_0 1.0) t_1 t_2)))))))im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
double t_0 = exp(re) * sin(im_m);
double t_1 = sin(im_m) * (re + 1.0);
double t_2 = exp(re) * im_m;
double tmp;
if (t_0 <= -((double) INFINITY)) {
tmp = im_m * fma((im_m * im_m), (im_m * (-0.0001984126984126984 * (im_m * (im_m * im_m)))), 1.0);
} else if (t_0 <= -0.02) {
tmp = t_1;
} else if (t_0 <= 0.0) {
tmp = t_2;
} else if (t_0 <= 1.0) {
tmp = t_1;
} else {
tmp = t_2;
}
return im_s * tmp;
}
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) t_0 = Float64(exp(re) * sin(im_m)) t_1 = Float64(sin(im_m) * Float64(re + 1.0)) t_2 = Float64(exp(re) * im_m) tmp = 0.0 if (t_0 <= Float64(-Inf)) tmp = Float64(im_m * fma(Float64(im_m * im_m), Float64(im_m * Float64(-0.0001984126984126984 * Float64(im_m * Float64(im_m * im_m)))), 1.0)); elseif (t_0 <= -0.02) tmp = t_1; elseif (t_0 <= 0.0) tmp = t_2; elseif (t_0 <= 1.0) tmp = t_1; else tmp = t_2; end return Float64(im_s * tmp) end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := Block[{t$95$0 = N[(N[Exp[re], $MachinePrecision] * N[Sin[im$95$m], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Sin[im$95$m], $MachinePrecision] * N[(re + 1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Exp[re], $MachinePrecision] * im$95$m), $MachinePrecision]}, N[(im$95$s * If[LessEqual[t$95$0, (-Infinity)], N[(im$95$m * N[(N[(im$95$m * im$95$m), $MachinePrecision] * N[(im$95$m * N[(-0.0001984126984126984 * N[(im$95$m * N[(im$95$m * im$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, -0.02], t$95$1, If[LessEqual[t$95$0, 0.0], t$95$2, If[LessEqual[t$95$0, 1.0], t$95$1, t$95$2]]]]), $MachinePrecision]]]]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
\begin{array}{l}
t_0 := e^{re} \cdot \sin im\_m\\
t_1 := \sin im\_m \cdot \left(re + 1\right)\\
t_2 := e^{re} \cdot im\_m\\
im\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_0 \leq -\infty:\\
\;\;\;\;im\_m \cdot \mathsf{fma}\left(im\_m \cdot im\_m, im\_m \cdot \left(-0.0001984126984126984 \cdot \left(im\_m \cdot \left(im\_m \cdot im\_m\right)\right)\right), 1\right)\\
\mathbf{elif}\;t\_0 \leq -0.02:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_0 \leq 1:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (sin.f64 im)) < -inf.0Initial program 100.0%
Taylor expanded in re around 0
sin-lowering-sin.f642.7
Simplified2.7%
Taylor expanded in im around 0
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sub-negN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6438.5
Simplified38.5%
Taylor expanded in im around inf
metadata-evalN/A
pow-sqrN/A
associate-*l*N/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
unpow2N/A
unpow3N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6438.5
Simplified38.5%
if -inf.0 < (*.f64 (exp.f64 re) (sin.f64 im)) < -0.0200000000000000004 or 0.0 < (*.f64 (exp.f64 re) (sin.f64 im)) < 1Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
+-lowering-+.f6499.3
Simplified99.3%
if -0.0200000000000000004 < (*.f64 (exp.f64 re) (sin.f64 im)) < 0.0 or 1 < (*.f64 (exp.f64 re) (sin.f64 im)) Initial program 100.0%
Taylor expanded in im around 0
Simplified95.5%
Final simplification91.6%
im\_m = (fabs.f64 im)
im\_s = (copysign.f64 #s(literal 1 binary64) im)
(FPCore (im_s re im_m)
:precision binary64
(let* ((t_0 (* (exp re) (sin im_m))) (t_1 (* (exp re) im_m)))
(*
im_s
(if (<= t_0 (- INFINITY))
(*
im_m
(fma
(* im_m im_m)
(* im_m (* -0.0001984126984126984 (* im_m (* im_m im_m))))
1.0))
(if (<= t_0 -0.02)
(sin im_m)
(if (<= t_0 2e-13) t_1 (if (<= t_0 1.0) (sin im_m) t_1)))))))im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
double t_0 = exp(re) * sin(im_m);
double t_1 = exp(re) * im_m;
double tmp;
if (t_0 <= -((double) INFINITY)) {
tmp = im_m * fma((im_m * im_m), (im_m * (-0.0001984126984126984 * (im_m * (im_m * im_m)))), 1.0);
} else if (t_0 <= -0.02) {
tmp = sin(im_m);
} else if (t_0 <= 2e-13) {
tmp = t_1;
} else if (t_0 <= 1.0) {
tmp = sin(im_m);
} else {
tmp = t_1;
}
return im_s * tmp;
}
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) t_0 = Float64(exp(re) * sin(im_m)) t_1 = Float64(exp(re) * im_m) tmp = 0.0 if (t_0 <= Float64(-Inf)) tmp = Float64(im_m * fma(Float64(im_m * im_m), Float64(im_m * Float64(-0.0001984126984126984 * Float64(im_m * Float64(im_m * im_m)))), 1.0)); elseif (t_0 <= -0.02) tmp = sin(im_m); elseif (t_0 <= 2e-13) tmp = t_1; elseif (t_0 <= 1.0) tmp = sin(im_m); else tmp = t_1; end return Float64(im_s * tmp) end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := Block[{t$95$0 = N[(N[Exp[re], $MachinePrecision] * N[Sin[im$95$m], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Exp[re], $MachinePrecision] * im$95$m), $MachinePrecision]}, N[(im$95$s * If[LessEqual[t$95$0, (-Infinity)], N[(im$95$m * N[(N[(im$95$m * im$95$m), $MachinePrecision] * N[(im$95$m * N[(-0.0001984126984126984 * N[(im$95$m * N[(im$95$m * im$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, -0.02], N[Sin[im$95$m], $MachinePrecision], If[LessEqual[t$95$0, 2e-13], t$95$1, If[LessEqual[t$95$0, 1.0], N[Sin[im$95$m], $MachinePrecision], t$95$1]]]]), $MachinePrecision]]]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
\begin{array}{l}
t_0 := e^{re} \cdot \sin im\_m\\
t_1 := e^{re} \cdot im\_m\\
im\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_0 \leq -\infty:\\
\;\;\;\;im\_m \cdot \mathsf{fma}\left(im\_m \cdot im\_m, im\_m \cdot \left(-0.0001984126984126984 \cdot \left(im\_m \cdot \left(im\_m \cdot im\_m\right)\right)\right), 1\right)\\
\mathbf{elif}\;t\_0 \leq -0.02:\\
\;\;\;\;\sin im\_m\\
\mathbf{elif}\;t\_0 \leq 2 \cdot 10^{-13}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_0 \leq 1:\\
\;\;\;\;\sin im\_m\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (sin.f64 im)) < -inf.0Initial program 100.0%
Taylor expanded in re around 0
sin-lowering-sin.f642.7
Simplified2.7%
Taylor expanded in im around 0
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sub-negN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6438.5
Simplified38.5%
Taylor expanded in im around inf
metadata-evalN/A
pow-sqrN/A
associate-*l*N/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
unpow2N/A
unpow3N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6438.5
Simplified38.5%
if -inf.0 < (*.f64 (exp.f64 re) (sin.f64 im)) < -0.0200000000000000004 or 2.0000000000000001e-13 < (*.f64 (exp.f64 re) (sin.f64 im)) < 1Initial program 99.9%
Taylor expanded in re around 0
sin-lowering-sin.f6496.0
Simplified96.0%
if -0.0200000000000000004 < (*.f64 (exp.f64 re) (sin.f64 im)) < 2.0000000000000001e-13 or 1 < (*.f64 (exp.f64 re) (sin.f64 im)) Initial program 100.0%
Taylor expanded in im around 0
Simplified96.3%
im\_m = (fabs.f64 im)
im\_s = (copysign.f64 #s(literal 1 binary64) im)
(FPCore (im_s re im_m)
:precision binary64
(let* ((t_0 (* (exp re) (sin im_m))))
(*
im_s
(if (<= t_0 (- INFINITY))
(*
im_m
(fma
(* im_m im_m)
(* im_m (* -0.0001984126984126984 (* im_m (* im_m im_m))))
1.0))
(if (<= t_0 -0.02)
(sin im_m)
(if (<= t_0 0.0)
(* im_m (* 0.008333333333333333 (* (* im_m im_m) (* im_m im_m))))
(if (<= t_0 1.0)
(sin im_m)
(*
im_m
(fma re (fma re (fma re 0.16666666666666666 0.5) 1.0) 1.0)))))))))im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
double t_0 = exp(re) * sin(im_m);
double tmp;
if (t_0 <= -((double) INFINITY)) {
tmp = im_m * fma((im_m * im_m), (im_m * (-0.0001984126984126984 * (im_m * (im_m * im_m)))), 1.0);
} else if (t_0 <= -0.02) {
tmp = sin(im_m);
} else if (t_0 <= 0.0) {
tmp = im_m * (0.008333333333333333 * ((im_m * im_m) * (im_m * im_m)));
} else if (t_0 <= 1.0) {
tmp = sin(im_m);
} else {
tmp = im_m * fma(re, fma(re, fma(re, 0.16666666666666666, 0.5), 1.0), 1.0);
}
return im_s * tmp;
}
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) t_0 = Float64(exp(re) * sin(im_m)) tmp = 0.0 if (t_0 <= Float64(-Inf)) tmp = Float64(im_m * fma(Float64(im_m * im_m), Float64(im_m * Float64(-0.0001984126984126984 * Float64(im_m * Float64(im_m * im_m)))), 1.0)); elseif (t_0 <= -0.02) tmp = sin(im_m); elseif (t_0 <= 0.0) tmp = Float64(im_m * Float64(0.008333333333333333 * Float64(Float64(im_m * im_m) * Float64(im_m * im_m)))); elseif (t_0 <= 1.0) tmp = sin(im_m); else tmp = Float64(im_m * fma(re, fma(re, fma(re, 0.16666666666666666, 0.5), 1.0), 1.0)); end return Float64(im_s * tmp) end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := Block[{t$95$0 = N[(N[Exp[re], $MachinePrecision] * N[Sin[im$95$m], $MachinePrecision]), $MachinePrecision]}, N[(im$95$s * If[LessEqual[t$95$0, (-Infinity)], N[(im$95$m * N[(N[(im$95$m * im$95$m), $MachinePrecision] * N[(im$95$m * N[(-0.0001984126984126984 * N[(im$95$m * N[(im$95$m * im$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, -0.02], N[Sin[im$95$m], $MachinePrecision], If[LessEqual[t$95$0, 0.0], N[(im$95$m * N[(0.008333333333333333 * N[(N[(im$95$m * im$95$m), $MachinePrecision] * N[(im$95$m * im$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 1.0], N[Sin[im$95$m], $MachinePrecision], N[(im$95$m * N[(re * N[(re * N[(re * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]]]), $MachinePrecision]]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
\begin{array}{l}
t_0 := e^{re} \cdot \sin im\_m\\
im\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_0 \leq -\infty:\\
\;\;\;\;im\_m \cdot \mathsf{fma}\left(im\_m \cdot im\_m, im\_m \cdot \left(-0.0001984126984126984 \cdot \left(im\_m \cdot \left(im\_m \cdot im\_m\right)\right)\right), 1\right)\\
\mathbf{elif}\;t\_0 \leq -0.02:\\
\;\;\;\;\sin im\_m\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;im\_m \cdot \left(0.008333333333333333 \cdot \left(\left(im\_m \cdot im\_m\right) \cdot \left(im\_m \cdot im\_m\right)\right)\right)\\
\mathbf{elif}\;t\_0 \leq 1:\\
\;\;\;\;\sin im\_m\\
\mathbf{else}:\\
\;\;\;\;im\_m \cdot \mathsf{fma}\left(re, \mathsf{fma}\left(re, \mathsf{fma}\left(re, 0.16666666666666666, 0.5\right), 1\right), 1\right)\\
\end{array}
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (sin.f64 im)) < -inf.0Initial program 100.0%
Taylor expanded in re around 0
sin-lowering-sin.f642.7
Simplified2.7%
Taylor expanded in im around 0
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sub-negN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6438.5
Simplified38.5%
Taylor expanded in im around inf
metadata-evalN/A
pow-sqrN/A
associate-*l*N/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
unpow2N/A
unpow3N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6438.5
Simplified38.5%
if -inf.0 < (*.f64 (exp.f64 re) (sin.f64 im)) < -0.0200000000000000004 or 0.0 < (*.f64 (exp.f64 re) (sin.f64 im)) < 1Initial program 100.0%
Taylor expanded in re around 0
sin-lowering-sin.f6497.2
Simplified97.2%
if -0.0200000000000000004 < (*.f64 (exp.f64 re) (sin.f64 im)) < 0.0Initial program 100.0%
Taylor expanded in re around 0
sin-lowering-sin.f6448.5
Simplified48.5%
Taylor expanded in im around 0
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6448.1
Simplified48.1%
Taylor expanded in im around inf
*-lowering-*.f64N/A
metadata-evalN/A
pow-sqrN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6427.0
Simplified27.0%
if 1 < (*.f64 (exp.f64 re) (sin.f64 im)) Initial program 100.0%
Taylor expanded in im around 0
Simplified80.6%
Taylor expanded in re around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6462.2
Simplified62.2%
Final simplification59.2%
im\_m = (fabs.f64 im)
im\_s = (copysign.f64 #s(literal 1 binary64) im)
(FPCore (im_s re im_m)
:precision binary64
(let* ((t_0 (* (exp re) (sin im_m))))
(*
im_s
(if (<= t_0 (- INFINITY))
(*
im_m
(fma
(* im_m im_m)
(* im_m (* -0.0001984126984126984 (* im_m (* im_m im_m))))
1.0))
(if (<= t_0 1.0)
(/
(sin im_m)
(+ 1.0 (* (* re (fma re 0.5 1.0)) (fma re (fma re 0.5 1.0) -1.0))))
(* (exp re) im_m))))))im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
double t_0 = exp(re) * sin(im_m);
double tmp;
if (t_0 <= -((double) INFINITY)) {
tmp = im_m * fma((im_m * im_m), (im_m * (-0.0001984126984126984 * (im_m * (im_m * im_m)))), 1.0);
} else if (t_0 <= 1.0) {
tmp = sin(im_m) / (1.0 + ((re * fma(re, 0.5, 1.0)) * fma(re, fma(re, 0.5, 1.0), -1.0)));
} else {
tmp = exp(re) * im_m;
}
return im_s * tmp;
}
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) t_0 = Float64(exp(re) * sin(im_m)) tmp = 0.0 if (t_0 <= Float64(-Inf)) tmp = Float64(im_m * fma(Float64(im_m * im_m), Float64(im_m * Float64(-0.0001984126984126984 * Float64(im_m * Float64(im_m * im_m)))), 1.0)); elseif (t_0 <= 1.0) tmp = Float64(sin(im_m) / Float64(1.0 + Float64(Float64(re * fma(re, 0.5, 1.0)) * fma(re, fma(re, 0.5, 1.0), -1.0)))); else tmp = Float64(exp(re) * im_m); end return Float64(im_s * tmp) end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := Block[{t$95$0 = N[(N[Exp[re], $MachinePrecision] * N[Sin[im$95$m], $MachinePrecision]), $MachinePrecision]}, N[(im$95$s * If[LessEqual[t$95$0, (-Infinity)], N[(im$95$m * N[(N[(im$95$m * im$95$m), $MachinePrecision] * N[(im$95$m * N[(-0.0001984126984126984 * N[(im$95$m * N[(im$95$m * im$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 1.0], N[(N[Sin[im$95$m], $MachinePrecision] / N[(1.0 + N[(N[(re * N[(re * 0.5 + 1.0), $MachinePrecision]), $MachinePrecision] * N[(re * N[(re * 0.5 + 1.0), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Exp[re], $MachinePrecision] * im$95$m), $MachinePrecision]]]), $MachinePrecision]]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
\begin{array}{l}
t_0 := e^{re} \cdot \sin im\_m\\
im\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_0 \leq -\infty:\\
\;\;\;\;im\_m \cdot \mathsf{fma}\left(im\_m \cdot im\_m, im\_m \cdot \left(-0.0001984126984126984 \cdot \left(im\_m \cdot \left(im\_m \cdot im\_m\right)\right)\right), 1\right)\\
\mathbf{elif}\;t\_0 \leq 1:\\
\;\;\;\;\frac{\sin im\_m}{1 + \left(re \cdot \mathsf{fma}\left(re, 0.5, 1\right)\right) \cdot \mathsf{fma}\left(re, \mathsf{fma}\left(re, 0.5, 1\right), -1\right)}\\
\mathbf{else}:\\
\;\;\;\;e^{re} \cdot im\_m\\
\end{array}
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (sin.f64 im)) < -inf.0Initial program 100.0%
Taylor expanded in re around 0
sin-lowering-sin.f642.7
Simplified2.7%
Taylor expanded in im around 0
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sub-negN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6438.5
Simplified38.5%
Taylor expanded in im around inf
metadata-evalN/A
pow-sqrN/A
associate-*l*N/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
unpow2N/A
unpow3N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6438.5
Simplified38.5%
if -inf.0 < (*.f64 (exp.f64 re) (sin.f64 im)) < 1Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6473.2
Simplified73.2%
+-commutativeN/A
flip3-+N/A
metadata-evalN/A
+-commutativeN/A
metadata-evalN/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr72.8%
Taylor expanded in re around 0
sin-lowering-sin.f6497.2
Simplified97.2%
if 1 < (*.f64 (exp.f64 re) (sin.f64 im)) Initial program 100.0%
Taylor expanded in im around 0
Simplified80.6%
im\_m = (fabs.f64 im)
im\_s = (copysign.f64 #s(literal 1 binary64) im)
(FPCore (im_s re im_m)
:precision binary64
(let* ((t_0 (* (exp re) (sin im_m))))
(*
im_s
(if (<= t_0 -0.02)
(fma
im_m
(fma
(* im_m im_m)
(*
(+ re 1.0)
(fma
im_m
(*
im_m
(fma (* im_m im_m) -0.0001984126984126984 0.008333333333333333))
-0.16666666666666666))
re)
im_m)
(if (<= t_0 0.0)
(* im_m (* 0.008333333333333333 (* (* im_m im_m) (* im_m im_m))))
(*
(fma (* re (fma (* re re) 0.25 -1.0)) (/ 1.0 (fma re 0.5 -1.0)) 1.0)
(*
im_m
(fma
(* im_m im_m)
(fma (* im_m im_m) 0.008333333333333333 -0.16666666666666666)
1.0))))))))im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
double t_0 = exp(re) * sin(im_m);
double tmp;
if (t_0 <= -0.02) {
tmp = fma(im_m, fma((im_m * im_m), ((re + 1.0) * fma(im_m, (im_m * fma((im_m * im_m), -0.0001984126984126984, 0.008333333333333333)), -0.16666666666666666)), re), im_m);
} else if (t_0 <= 0.0) {
tmp = im_m * (0.008333333333333333 * ((im_m * im_m) * (im_m * im_m)));
} else {
tmp = fma((re * fma((re * re), 0.25, -1.0)), (1.0 / fma(re, 0.5, -1.0)), 1.0) * (im_m * fma((im_m * im_m), fma((im_m * im_m), 0.008333333333333333, -0.16666666666666666), 1.0));
}
return im_s * tmp;
}
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) t_0 = Float64(exp(re) * sin(im_m)) tmp = 0.0 if (t_0 <= -0.02) tmp = fma(im_m, fma(Float64(im_m * im_m), Float64(Float64(re + 1.0) * fma(im_m, Float64(im_m * fma(Float64(im_m * im_m), -0.0001984126984126984, 0.008333333333333333)), -0.16666666666666666)), re), im_m); elseif (t_0 <= 0.0) tmp = Float64(im_m * Float64(0.008333333333333333 * Float64(Float64(im_m * im_m) * Float64(im_m * im_m)))); else tmp = Float64(fma(Float64(re * fma(Float64(re * re), 0.25, -1.0)), Float64(1.0 / fma(re, 0.5, -1.0)), 1.0) * Float64(im_m * fma(Float64(im_m * im_m), fma(Float64(im_m * im_m), 0.008333333333333333, -0.16666666666666666), 1.0))); end return Float64(im_s * tmp) end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := Block[{t$95$0 = N[(N[Exp[re], $MachinePrecision] * N[Sin[im$95$m], $MachinePrecision]), $MachinePrecision]}, N[(im$95$s * If[LessEqual[t$95$0, -0.02], N[(im$95$m * N[(N[(im$95$m * im$95$m), $MachinePrecision] * N[(N[(re + 1.0), $MachinePrecision] * N[(im$95$m * N[(im$95$m * N[(N[(im$95$m * im$95$m), $MachinePrecision] * -0.0001984126984126984 + 0.008333333333333333), $MachinePrecision]), $MachinePrecision] + -0.16666666666666666), $MachinePrecision]), $MachinePrecision] + re), $MachinePrecision] + im$95$m), $MachinePrecision], If[LessEqual[t$95$0, 0.0], N[(im$95$m * N[(0.008333333333333333 * N[(N[(im$95$m * im$95$m), $MachinePrecision] * N[(im$95$m * im$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(re * N[(N[(re * re), $MachinePrecision] * 0.25 + -1.0), $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(re * 0.5 + -1.0), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] * N[(im$95$m * N[(N[(im$95$m * im$95$m), $MachinePrecision] * N[(N[(im$95$m * im$95$m), $MachinePrecision] * 0.008333333333333333 + -0.16666666666666666), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
\begin{array}{l}
t_0 := e^{re} \cdot \sin im\_m\\
im\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_0 \leq -0.02:\\
\;\;\;\;\mathsf{fma}\left(im\_m, \mathsf{fma}\left(im\_m \cdot im\_m, \left(re + 1\right) \cdot \mathsf{fma}\left(im\_m, im\_m \cdot \mathsf{fma}\left(im\_m \cdot im\_m, -0.0001984126984126984, 0.008333333333333333\right), -0.16666666666666666\right), re\right), im\_m\right)\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;im\_m \cdot \left(0.008333333333333333 \cdot \left(\left(im\_m \cdot im\_m\right) \cdot \left(im\_m \cdot im\_m\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(re \cdot \mathsf{fma}\left(re \cdot re, 0.25, -1\right), \frac{1}{\mathsf{fma}\left(re, 0.5, -1\right)}, 1\right) \cdot \left(im\_m \cdot \mathsf{fma}\left(im\_m \cdot im\_m, \mathsf{fma}\left(im\_m \cdot im\_m, 0.008333333333333333, -0.16666666666666666\right), 1\right)\right)\\
\end{array}
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (sin.f64 im)) < -0.0200000000000000004Initial program 99.9%
Taylor expanded in re around 0
+-commutativeN/A
+-lowering-+.f6458.4
Simplified58.4%
Taylor expanded in im around 0
Simplified19.5%
if -0.0200000000000000004 < (*.f64 (exp.f64 re) (sin.f64 im)) < 0.0Initial program 100.0%
Taylor expanded in re around 0
sin-lowering-sin.f6448.5
Simplified48.5%
Taylor expanded in im around 0
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6448.1
Simplified48.1%
Taylor expanded in im around inf
*-lowering-*.f64N/A
metadata-evalN/A
pow-sqrN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6427.0
Simplified27.0%
if 0.0 < (*.f64 (exp.f64 re) (sin.f64 im)) Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6483.3
Simplified83.3%
Taylor expanded in im around 0
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6450.6
Simplified50.6%
*-commutativeN/A
flip-+N/A
associate-*l/N/A
div-invN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
sub-negN/A
swap-sqrN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
/-lowering-/.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6454.5
Applied egg-rr54.5%
Final simplification35.8%
im\_m = (fabs.f64 im)
im\_s = (copysign.f64 #s(literal 1 binary64) im)
(FPCore (im_s re im_m)
:precision binary64
(let* ((t_0 (* (exp re) (sin im_m))))
(*
im_s
(if (<= t_0 -0.02)
(fma
im_m
(fma
(* im_m im_m)
(*
(+ re 1.0)
(fma
im_m
(*
im_m
(fma (* im_m im_m) -0.0001984126984126984 0.008333333333333333))
-0.16666666666666666))
re)
im_m)
(if (<= t_0 0.0)
(* im_m (* 0.008333333333333333 (* (* im_m im_m) (* im_m im_m))))
(*
im_m
(fma re (fma re (fma re 0.16666666666666666 0.5) 1.0) 1.0)))))))im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
double t_0 = exp(re) * sin(im_m);
double tmp;
if (t_0 <= -0.02) {
tmp = fma(im_m, fma((im_m * im_m), ((re + 1.0) * fma(im_m, (im_m * fma((im_m * im_m), -0.0001984126984126984, 0.008333333333333333)), -0.16666666666666666)), re), im_m);
} else if (t_0 <= 0.0) {
tmp = im_m * (0.008333333333333333 * ((im_m * im_m) * (im_m * im_m)));
} else {
tmp = im_m * fma(re, fma(re, fma(re, 0.16666666666666666, 0.5), 1.0), 1.0);
}
return im_s * tmp;
}
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) t_0 = Float64(exp(re) * sin(im_m)) tmp = 0.0 if (t_0 <= -0.02) tmp = fma(im_m, fma(Float64(im_m * im_m), Float64(Float64(re + 1.0) * fma(im_m, Float64(im_m * fma(Float64(im_m * im_m), -0.0001984126984126984, 0.008333333333333333)), -0.16666666666666666)), re), im_m); elseif (t_0 <= 0.0) tmp = Float64(im_m * Float64(0.008333333333333333 * Float64(Float64(im_m * im_m) * Float64(im_m * im_m)))); else tmp = Float64(im_m * fma(re, fma(re, fma(re, 0.16666666666666666, 0.5), 1.0), 1.0)); end return Float64(im_s * tmp) end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := Block[{t$95$0 = N[(N[Exp[re], $MachinePrecision] * N[Sin[im$95$m], $MachinePrecision]), $MachinePrecision]}, N[(im$95$s * If[LessEqual[t$95$0, -0.02], N[(im$95$m * N[(N[(im$95$m * im$95$m), $MachinePrecision] * N[(N[(re + 1.0), $MachinePrecision] * N[(im$95$m * N[(im$95$m * N[(N[(im$95$m * im$95$m), $MachinePrecision] * -0.0001984126984126984 + 0.008333333333333333), $MachinePrecision]), $MachinePrecision] + -0.16666666666666666), $MachinePrecision]), $MachinePrecision] + re), $MachinePrecision] + im$95$m), $MachinePrecision], If[LessEqual[t$95$0, 0.0], N[(im$95$m * N[(0.008333333333333333 * N[(N[(im$95$m * im$95$m), $MachinePrecision] * N[(im$95$m * im$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(im$95$m * N[(re * N[(re * N[(re * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
\begin{array}{l}
t_0 := e^{re} \cdot \sin im\_m\\
im\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_0 \leq -0.02:\\
\;\;\;\;\mathsf{fma}\left(im\_m, \mathsf{fma}\left(im\_m \cdot im\_m, \left(re + 1\right) \cdot \mathsf{fma}\left(im\_m, im\_m \cdot \mathsf{fma}\left(im\_m \cdot im\_m, -0.0001984126984126984, 0.008333333333333333\right), -0.16666666666666666\right), re\right), im\_m\right)\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;im\_m \cdot \left(0.008333333333333333 \cdot \left(\left(im\_m \cdot im\_m\right) \cdot \left(im\_m \cdot im\_m\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;im\_m \cdot \mathsf{fma}\left(re, \mathsf{fma}\left(re, \mathsf{fma}\left(re, 0.16666666666666666, 0.5\right), 1\right), 1\right)\\
\end{array}
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (sin.f64 im)) < -0.0200000000000000004Initial program 99.9%
Taylor expanded in re around 0
+-commutativeN/A
+-lowering-+.f6458.4
Simplified58.4%
Taylor expanded in im around 0
Simplified19.5%
if -0.0200000000000000004 < (*.f64 (exp.f64 re) (sin.f64 im)) < 0.0Initial program 100.0%
Taylor expanded in re around 0
sin-lowering-sin.f6448.5
Simplified48.5%
Taylor expanded in im around 0
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6448.1
Simplified48.1%
Taylor expanded in im around inf
*-lowering-*.f64N/A
metadata-evalN/A
pow-sqrN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6427.0
Simplified27.0%
if 0.0 < (*.f64 (exp.f64 re) (sin.f64 im)) Initial program 100.0%
Taylor expanded in im around 0
Simplified60.0%
Taylor expanded in re around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6454.1
Simplified54.1%
Final simplification35.7%
im\_m = (fabs.f64 im)
im\_s = (copysign.f64 #s(literal 1 binary64) im)
(FPCore (im_s re im_m)
:precision binary64
(let* ((t_0 (* (exp re) (sin im_m))))
(*
im_s
(if (<= t_0 -0.02)
(*
im_m
(fma
(* im_m im_m)
(* im_m (* -0.0001984126984126984 (* im_m (* im_m im_m))))
1.0))
(if (<= t_0 0.0)
(* im_m (* 0.008333333333333333 (* (* im_m im_m) (* im_m im_m))))
(*
im_m
(fma re (fma re (fma re 0.16666666666666666 0.5) 1.0) 1.0)))))))im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
double t_0 = exp(re) * sin(im_m);
double tmp;
if (t_0 <= -0.02) {
tmp = im_m * fma((im_m * im_m), (im_m * (-0.0001984126984126984 * (im_m * (im_m * im_m)))), 1.0);
} else if (t_0 <= 0.0) {
tmp = im_m * (0.008333333333333333 * ((im_m * im_m) * (im_m * im_m)));
} else {
tmp = im_m * fma(re, fma(re, fma(re, 0.16666666666666666, 0.5), 1.0), 1.0);
}
return im_s * tmp;
}
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) t_0 = Float64(exp(re) * sin(im_m)) tmp = 0.0 if (t_0 <= -0.02) tmp = Float64(im_m * fma(Float64(im_m * im_m), Float64(im_m * Float64(-0.0001984126984126984 * Float64(im_m * Float64(im_m * im_m)))), 1.0)); elseif (t_0 <= 0.0) tmp = Float64(im_m * Float64(0.008333333333333333 * Float64(Float64(im_m * im_m) * Float64(im_m * im_m)))); else tmp = Float64(im_m * fma(re, fma(re, fma(re, 0.16666666666666666, 0.5), 1.0), 1.0)); end return Float64(im_s * tmp) end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := Block[{t$95$0 = N[(N[Exp[re], $MachinePrecision] * N[Sin[im$95$m], $MachinePrecision]), $MachinePrecision]}, N[(im$95$s * If[LessEqual[t$95$0, -0.02], N[(im$95$m * N[(N[(im$95$m * im$95$m), $MachinePrecision] * N[(im$95$m * N[(-0.0001984126984126984 * N[(im$95$m * N[(im$95$m * im$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 0.0], N[(im$95$m * N[(0.008333333333333333 * N[(N[(im$95$m * im$95$m), $MachinePrecision] * N[(im$95$m * im$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(im$95$m * N[(re * N[(re * N[(re * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
\begin{array}{l}
t_0 := e^{re} \cdot \sin im\_m\\
im\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_0 \leq -0.02:\\
\;\;\;\;im\_m \cdot \mathsf{fma}\left(im\_m \cdot im\_m, im\_m \cdot \left(-0.0001984126984126984 \cdot \left(im\_m \cdot \left(im\_m \cdot im\_m\right)\right)\right), 1\right)\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;im\_m \cdot \left(0.008333333333333333 \cdot \left(\left(im\_m \cdot im\_m\right) \cdot \left(im\_m \cdot im\_m\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;im\_m \cdot \mathsf{fma}\left(re, \mathsf{fma}\left(re, \mathsf{fma}\left(re, 0.16666666666666666, 0.5\right), 1\right), 1\right)\\
\end{array}
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (sin.f64 im)) < -0.0200000000000000004Initial program 99.9%
Taylor expanded in re around 0
sin-lowering-sin.f6455.9
Simplified55.9%
Taylor expanded in im around 0
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sub-negN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6419.3
Simplified19.3%
Taylor expanded in im around inf
metadata-evalN/A
pow-sqrN/A
associate-*l*N/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
unpow2N/A
unpow3N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6418.2
Simplified18.2%
if -0.0200000000000000004 < (*.f64 (exp.f64 re) (sin.f64 im)) < 0.0Initial program 100.0%
Taylor expanded in re around 0
sin-lowering-sin.f6448.5
Simplified48.5%
Taylor expanded in im around 0
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6448.1
Simplified48.1%
Taylor expanded in im around inf
*-lowering-*.f64N/A
metadata-evalN/A
pow-sqrN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6427.0
Simplified27.0%
if 0.0 < (*.f64 (exp.f64 re) (sin.f64 im)) Initial program 100.0%
Taylor expanded in im around 0
Simplified60.0%
Taylor expanded in re around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6454.1
Simplified54.1%
Final simplification35.4%
im\_m = (fabs.f64 im)
im\_s = (copysign.f64 #s(literal 1 binary64) im)
(FPCore (im_s re im_m)
:precision binary64
(let* ((t_0 (* (exp re) (sin im_m))))
(*
im_s
(if (<= t_0 -0.02)
(*
im_m
(*
(fma re (fma re 0.5 1.0) 1.0)
(fma im_m (* im_m -0.16666666666666666) 1.0)))
(if (<= t_0 0.0)
(* im_m (* 0.008333333333333333 (* (* im_m im_m) (* im_m im_m))))
(*
im_m
(fma re (fma re (fma re 0.16666666666666666 0.5) 1.0) 1.0)))))))im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
double t_0 = exp(re) * sin(im_m);
double tmp;
if (t_0 <= -0.02) {
tmp = im_m * (fma(re, fma(re, 0.5, 1.0), 1.0) * fma(im_m, (im_m * -0.16666666666666666), 1.0));
} else if (t_0 <= 0.0) {
tmp = im_m * (0.008333333333333333 * ((im_m * im_m) * (im_m * im_m)));
} else {
tmp = im_m * fma(re, fma(re, fma(re, 0.16666666666666666, 0.5), 1.0), 1.0);
}
return im_s * tmp;
}
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) t_0 = Float64(exp(re) * sin(im_m)) tmp = 0.0 if (t_0 <= -0.02) tmp = Float64(im_m * Float64(fma(re, fma(re, 0.5, 1.0), 1.0) * fma(im_m, Float64(im_m * -0.16666666666666666), 1.0))); elseif (t_0 <= 0.0) tmp = Float64(im_m * Float64(0.008333333333333333 * Float64(Float64(im_m * im_m) * Float64(im_m * im_m)))); else tmp = Float64(im_m * fma(re, fma(re, fma(re, 0.16666666666666666, 0.5), 1.0), 1.0)); end return Float64(im_s * tmp) end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := Block[{t$95$0 = N[(N[Exp[re], $MachinePrecision] * N[Sin[im$95$m], $MachinePrecision]), $MachinePrecision]}, N[(im$95$s * If[LessEqual[t$95$0, -0.02], N[(im$95$m * N[(N[(re * N[(re * 0.5 + 1.0), $MachinePrecision] + 1.0), $MachinePrecision] * N[(im$95$m * N[(im$95$m * -0.16666666666666666), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 0.0], N[(im$95$m * N[(0.008333333333333333 * N[(N[(im$95$m * im$95$m), $MachinePrecision] * N[(im$95$m * im$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(im$95$m * N[(re * N[(re * N[(re * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
\begin{array}{l}
t_0 := e^{re} \cdot \sin im\_m\\
im\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_0 \leq -0.02:\\
\;\;\;\;im\_m \cdot \left(\mathsf{fma}\left(re, \mathsf{fma}\left(re, 0.5, 1\right), 1\right) \cdot \mathsf{fma}\left(im\_m, im\_m \cdot -0.16666666666666666, 1\right)\right)\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;im\_m \cdot \left(0.008333333333333333 \cdot \left(\left(im\_m \cdot im\_m\right) \cdot \left(im\_m \cdot im\_m\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;im\_m \cdot \mathsf{fma}\left(re, \mathsf{fma}\left(re, \mathsf{fma}\left(re, 0.16666666666666666, 0.5\right), 1\right), 1\right)\\
\end{array}
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (sin.f64 im)) < -0.0200000000000000004Initial program 99.9%
Taylor expanded in re around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6483.0
Simplified83.0%
Taylor expanded in im around 0
*-lowering-*.f64N/A
+-commutativeN/A
associate-+r+N/A
associate-*r*N/A
distribute-rgt1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified27.7%
if -0.0200000000000000004 < (*.f64 (exp.f64 re) (sin.f64 im)) < 0.0Initial program 100.0%
Taylor expanded in re around 0
sin-lowering-sin.f6448.5
Simplified48.5%
Taylor expanded in im around 0
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6448.1
Simplified48.1%
Taylor expanded in im around inf
*-lowering-*.f64N/A
metadata-evalN/A
pow-sqrN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6427.0
Simplified27.0%
if 0.0 < (*.f64 (exp.f64 re) (sin.f64 im)) Initial program 100.0%
Taylor expanded in im around 0
Simplified60.0%
Taylor expanded in re around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6454.1
Simplified54.1%
Final simplification37.4%
im\_m = (fabs.f64 im)
im\_s = (copysign.f64 #s(literal 1 binary64) im)
(FPCore (im_s re im_m)
:precision binary64
(let* ((t_0 (* (exp re) (sin im_m))))
(*
im_s
(if (<= t_0 -0.02)
(* (fma im_m (* im_m -0.16666666666666666) 1.0) (fma re im_m im_m))
(if (<= t_0 0.0)
(* im_m (* 0.008333333333333333 (* (* im_m im_m) (* im_m im_m))))
(*
im_m
(fma re (fma re (fma re 0.16666666666666666 0.5) 1.0) 1.0)))))))im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
double t_0 = exp(re) * sin(im_m);
double tmp;
if (t_0 <= -0.02) {
tmp = fma(im_m, (im_m * -0.16666666666666666), 1.0) * fma(re, im_m, im_m);
} else if (t_0 <= 0.0) {
tmp = im_m * (0.008333333333333333 * ((im_m * im_m) * (im_m * im_m)));
} else {
tmp = im_m * fma(re, fma(re, fma(re, 0.16666666666666666, 0.5), 1.0), 1.0);
}
return im_s * tmp;
}
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) t_0 = Float64(exp(re) * sin(im_m)) tmp = 0.0 if (t_0 <= -0.02) tmp = Float64(fma(im_m, Float64(im_m * -0.16666666666666666), 1.0) * fma(re, im_m, im_m)); elseif (t_0 <= 0.0) tmp = Float64(im_m * Float64(0.008333333333333333 * Float64(Float64(im_m * im_m) * Float64(im_m * im_m)))); else tmp = Float64(im_m * fma(re, fma(re, fma(re, 0.16666666666666666, 0.5), 1.0), 1.0)); end return Float64(im_s * tmp) end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := Block[{t$95$0 = N[(N[Exp[re], $MachinePrecision] * N[Sin[im$95$m], $MachinePrecision]), $MachinePrecision]}, N[(im$95$s * If[LessEqual[t$95$0, -0.02], N[(N[(im$95$m * N[(im$95$m * -0.16666666666666666), $MachinePrecision] + 1.0), $MachinePrecision] * N[(re * im$95$m + im$95$m), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 0.0], N[(im$95$m * N[(0.008333333333333333 * N[(N[(im$95$m * im$95$m), $MachinePrecision] * N[(im$95$m * im$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(im$95$m * N[(re * N[(re * N[(re * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
\begin{array}{l}
t_0 := e^{re} \cdot \sin im\_m\\
im\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_0 \leq -0.02:\\
\;\;\;\;\mathsf{fma}\left(im\_m, im\_m \cdot -0.16666666666666666, 1\right) \cdot \mathsf{fma}\left(re, im\_m, im\_m\right)\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;im\_m \cdot \left(0.008333333333333333 \cdot \left(\left(im\_m \cdot im\_m\right) \cdot \left(im\_m \cdot im\_m\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;im\_m \cdot \mathsf{fma}\left(re, \mathsf{fma}\left(re, \mathsf{fma}\left(re, 0.16666666666666666, 0.5\right), 1\right), 1\right)\\
\end{array}
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (sin.f64 im)) < -0.0200000000000000004Initial program 99.9%
Taylor expanded in re around 0
+-commutativeN/A
+-lowering-+.f6458.4
Simplified58.4%
Taylor expanded in im around 0
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
associate-*r*N/A
distribute-rgt1-inN/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
distribute-lft-outN/A
associate-*r*N/A
distribute-rgt-outN/A
*-rgt-identityN/A
distribute-lft-inN/A
Simplified17.3%
if -0.0200000000000000004 < (*.f64 (exp.f64 re) (sin.f64 im)) < 0.0Initial program 100.0%
Taylor expanded in re around 0
sin-lowering-sin.f6448.5
Simplified48.5%
Taylor expanded in im around 0
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6448.1
Simplified48.1%
Taylor expanded in im around inf
*-lowering-*.f64N/A
metadata-evalN/A
pow-sqrN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6427.0
Simplified27.0%
if 0.0 < (*.f64 (exp.f64 re) (sin.f64 im)) Initial program 100.0%
Taylor expanded in im around 0
Simplified60.0%
Taylor expanded in re around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6454.1
Simplified54.1%
Final simplification35.2%
im\_m = (fabs.f64 im)
im\_s = (copysign.f64 #s(literal 1 binary64) im)
(FPCore (im_s re im_m)
:precision binary64
(*
im_s
(if (<= (* (exp re) (sin im_m)) 0.04)
(* (fma im_m (* im_m -0.16666666666666666) 1.0) (fma re im_m im_m))
(* im_m (fma re (fma re (fma re 0.16666666666666666 0.5) 1.0) 1.0)))))im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
double tmp;
if ((exp(re) * sin(im_m)) <= 0.04) {
tmp = fma(im_m, (im_m * -0.16666666666666666), 1.0) * fma(re, im_m, im_m);
} else {
tmp = im_m * fma(re, fma(re, fma(re, 0.16666666666666666, 0.5), 1.0), 1.0);
}
return im_s * tmp;
}
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) tmp = 0.0 if (Float64(exp(re) * sin(im_m)) <= 0.04) tmp = Float64(fma(im_m, Float64(im_m * -0.16666666666666666), 1.0) * fma(re, im_m, im_m)); else tmp = Float64(im_m * fma(re, fma(re, fma(re, 0.16666666666666666, 0.5), 1.0), 1.0)); end return Float64(im_s * tmp) end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := N[(im$95$s * If[LessEqual[N[(N[Exp[re], $MachinePrecision] * N[Sin[im$95$m], $MachinePrecision]), $MachinePrecision], 0.04], N[(N[(im$95$m * N[(im$95$m * -0.16666666666666666), $MachinePrecision] + 1.0), $MachinePrecision] * N[(re * im$95$m + im$95$m), $MachinePrecision]), $MachinePrecision], N[(im$95$m * N[(re * N[(re * N[(re * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
im\_s \cdot \begin{array}{l}
\mathbf{if}\;e^{re} \cdot \sin im\_m \leq 0.04:\\
\;\;\;\;\mathsf{fma}\left(im\_m, im\_m \cdot -0.16666666666666666, 1\right) \cdot \mathsf{fma}\left(re, im\_m, im\_m\right)\\
\mathbf{else}:\\
\;\;\;\;im\_m \cdot \mathsf{fma}\left(re, \mathsf{fma}\left(re, \mathsf{fma}\left(re, 0.16666666666666666, 0.5\right), 1\right), 1\right)\\
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (sin.f64 im)) < 0.0400000000000000008Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
+-lowering-+.f6460.1
Simplified60.1%
Taylor expanded in im around 0
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
associate-*r*N/A
distribute-rgt1-inN/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
distribute-lft-outN/A
associate-*r*N/A
distribute-rgt-outN/A
*-rgt-identityN/A
distribute-lft-inN/A
Simplified47.6%
if 0.0400000000000000008 < (*.f64 (exp.f64 re) (sin.f64 im)) Initial program 100.0%
Taylor expanded in im around 0
Simplified41.0%
Taylor expanded in re around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6431.9
Simplified31.9%
Final simplification43.8%
im\_m = (fabs.f64 im)
im\_s = (copysign.f64 #s(literal 1 binary64) im)
(FPCore (im_s re im_m)
:precision binary64
(*
im_s
(if (<= (* (exp re) (sin im_m)) 0.04)
(* (fma im_m (* im_m -0.16666666666666666) 1.0) (fma re im_m im_m))
(* im_m (* re (fma re (fma re 0.16666666666666666 0.5) 1.0))))))im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
double tmp;
if ((exp(re) * sin(im_m)) <= 0.04) {
tmp = fma(im_m, (im_m * -0.16666666666666666), 1.0) * fma(re, im_m, im_m);
} else {
tmp = im_m * (re * fma(re, fma(re, 0.16666666666666666, 0.5), 1.0));
}
return im_s * tmp;
}
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) tmp = 0.0 if (Float64(exp(re) * sin(im_m)) <= 0.04) tmp = Float64(fma(im_m, Float64(im_m * -0.16666666666666666), 1.0) * fma(re, im_m, im_m)); else tmp = Float64(im_m * Float64(re * fma(re, fma(re, 0.16666666666666666, 0.5), 1.0))); end return Float64(im_s * tmp) end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := N[(im$95$s * If[LessEqual[N[(N[Exp[re], $MachinePrecision] * N[Sin[im$95$m], $MachinePrecision]), $MachinePrecision], 0.04], N[(N[(im$95$m * N[(im$95$m * -0.16666666666666666), $MachinePrecision] + 1.0), $MachinePrecision] * N[(re * im$95$m + im$95$m), $MachinePrecision]), $MachinePrecision], N[(im$95$m * N[(re * N[(re * N[(re * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
im\_s \cdot \begin{array}{l}
\mathbf{if}\;e^{re} \cdot \sin im\_m \leq 0.04:\\
\;\;\;\;\mathsf{fma}\left(im\_m, im\_m \cdot -0.16666666666666666, 1\right) \cdot \mathsf{fma}\left(re, im\_m, im\_m\right)\\
\mathbf{else}:\\
\;\;\;\;im\_m \cdot \left(re \cdot \mathsf{fma}\left(re, \mathsf{fma}\left(re, 0.16666666666666666, 0.5\right), 1\right)\right)\\
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (sin.f64 im)) < 0.0400000000000000008Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
+-lowering-+.f6460.1
Simplified60.1%
Taylor expanded in im around 0
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
associate-*r*N/A
distribute-rgt1-inN/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
distribute-lft-outN/A
associate-*r*N/A
distribute-rgt-outN/A
*-rgt-identityN/A
distribute-lft-inN/A
Simplified47.6%
if 0.0400000000000000008 < (*.f64 (exp.f64 re) (sin.f64 im)) Initial program 100.0%
Taylor expanded in im around 0
Simplified41.0%
Taylor expanded in re around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
distribute-rgt-outN/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6426.0
Simplified26.0%
Taylor expanded in re around inf
Simplified32.5%
im\_m = (fabs.f64 im)
im\_s = (copysign.f64 #s(literal 1 binary64) im)
(FPCore (im_s re im_m)
:precision binary64
(*
im_s
(if (<= (* (exp re) (sin im_m)) 0.04)
(* im_m (fma im_m (* im_m -0.16666666666666666) 1.0))
(* im_m (* re (fma re (fma re 0.16666666666666666 0.5) 1.0))))))im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
double tmp;
if ((exp(re) * sin(im_m)) <= 0.04) {
tmp = im_m * fma(im_m, (im_m * -0.16666666666666666), 1.0);
} else {
tmp = im_m * (re * fma(re, fma(re, 0.16666666666666666, 0.5), 1.0));
}
return im_s * tmp;
}
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) tmp = 0.0 if (Float64(exp(re) * sin(im_m)) <= 0.04) tmp = Float64(im_m * fma(im_m, Float64(im_m * -0.16666666666666666), 1.0)); else tmp = Float64(im_m * Float64(re * fma(re, fma(re, 0.16666666666666666, 0.5), 1.0))); end return Float64(im_s * tmp) end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := N[(im$95$s * If[LessEqual[N[(N[Exp[re], $MachinePrecision] * N[Sin[im$95$m], $MachinePrecision]), $MachinePrecision], 0.04], N[(im$95$m * N[(im$95$m * N[(im$95$m * -0.16666666666666666), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(im$95$m * N[(re * N[(re * N[(re * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
im\_s \cdot \begin{array}{l}
\mathbf{if}\;e^{re} \cdot \sin im\_m \leq 0.04:\\
\;\;\;\;im\_m \cdot \mathsf{fma}\left(im\_m, im\_m \cdot -0.16666666666666666, 1\right)\\
\mathbf{else}:\\
\;\;\;\;im\_m \cdot \left(re \cdot \mathsf{fma}\left(re, \mathsf{fma}\left(re, 0.16666666666666666, 0.5\right), 1\right)\right)\\
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (sin.f64 im)) < 0.0400000000000000008Initial program 100.0%
Taylor expanded in re around 0
sin-lowering-sin.f6459.5
Simplified59.5%
Taylor expanded in im around 0
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f6446.5
Simplified46.5%
if 0.0400000000000000008 < (*.f64 (exp.f64 re) (sin.f64 im)) Initial program 100.0%
Taylor expanded in im around 0
Simplified41.0%
Taylor expanded in re around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
distribute-rgt-outN/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6426.0
Simplified26.0%
Taylor expanded in re around inf
Simplified32.5%
im\_m = (fabs.f64 im)
im\_s = (copysign.f64 #s(literal 1 binary64) im)
(FPCore (im_s re im_m)
:precision binary64
(*
im_s
(if (<= (* (exp re) (sin im_m)) 0.04)
(* im_m (fma im_m (* im_m -0.16666666666666666) 1.0))
(* (* re re) (* im_m (fma re 0.16666666666666666 0.5))))))im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
double tmp;
if ((exp(re) * sin(im_m)) <= 0.04) {
tmp = im_m * fma(im_m, (im_m * -0.16666666666666666), 1.0);
} else {
tmp = (re * re) * (im_m * fma(re, 0.16666666666666666, 0.5));
}
return im_s * tmp;
}
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) tmp = 0.0 if (Float64(exp(re) * sin(im_m)) <= 0.04) tmp = Float64(im_m * fma(im_m, Float64(im_m * -0.16666666666666666), 1.0)); else tmp = Float64(Float64(re * re) * Float64(im_m * fma(re, 0.16666666666666666, 0.5))); end return Float64(im_s * tmp) end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := N[(im$95$s * If[LessEqual[N[(N[Exp[re], $MachinePrecision] * N[Sin[im$95$m], $MachinePrecision]), $MachinePrecision], 0.04], N[(im$95$m * N[(im$95$m * N[(im$95$m * -0.16666666666666666), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(N[(re * re), $MachinePrecision] * N[(im$95$m * N[(re * 0.16666666666666666 + 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
im\_s \cdot \begin{array}{l}
\mathbf{if}\;e^{re} \cdot \sin im\_m \leq 0.04:\\
\;\;\;\;im\_m \cdot \mathsf{fma}\left(im\_m, im\_m \cdot -0.16666666666666666, 1\right)\\
\mathbf{else}:\\
\;\;\;\;\left(re \cdot re\right) \cdot \left(im\_m \cdot \mathsf{fma}\left(re, 0.16666666666666666, 0.5\right)\right)\\
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (sin.f64 im)) < 0.0400000000000000008Initial program 100.0%
Taylor expanded in re around 0
sin-lowering-sin.f6459.5
Simplified59.5%
Taylor expanded in im around 0
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f6446.5
Simplified46.5%
if 0.0400000000000000008 < (*.f64 (exp.f64 re) (sin.f64 im)) Initial program 100.0%
Taylor expanded in im around 0
Simplified41.0%
Taylor expanded in re around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
distribute-rgt-outN/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6426.0
Simplified26.0%
Taylor expanded in re around inf
distribute-lft-inN/A
*-commutativeN/A
associate-*r/N/A
associate-*l/N/A
associate-/l*N/A
unpow3N/A
unpow2N/A
associate-*l/N/A
*-rgt-identityN/A
associate-*r/N/A
unpow2N/A
associate-*l*N/A
rgt-mult-inverseN/A
*-rgt-identityN/A
unpow2N/A
*-commutativeN/A
Simplified27.8%
im\_m = (fabs.f64 im)
im\_s = (copysign.f64 #s(literal 1 binary64) im)
(FPCore (im_s re im_m)
:precision binary64
(*
im_s
(if (<= (* (exp re) (sin im_m)) 0.04)
(* im_m (fma im_m (* im_m -0.16666666666666666) 1.0))
(* re (* im_m (* 0.16666666666666666 (* re re)))))))im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
double tmp;
if ((exp(re) * sin(im_m)) <= 0.04) {
tmp = im_m * fma(im_m, (im_m * -0.16666666666666666), 1.0);
} else {
tmp = re * (im_m * (0.16666666666666666 * (re * re)));
}
return im_s * tmp;
}
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) tmp = 0.0 if (Float64(exp(re) * sin(im_m)) <= 0.04) tmp = Float64(im_m * fma(im_m, Float64(im_m * -0.16666666666666666), 1.0)); else tmp = Float64(re * Float64(im_m * Float64(0.16666666666666666 * Float64(re * re)))); end return Float64(im_s * tmp) end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := N[(im$95$s * If[LessEqual[N[(N[Exp[re], $MachinePrecision] * N[Sin[im$95$m], $MachinePrecision]), $MachinePrecision], 0.04], N[(im$95$m * N[(im$95$m * N[(im$95$m * -0.16666666666666666), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(re * N[(im$95$m * N[(0.16666666666666666 * N[(re * re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
im\_s \cdot \begin{array}{l}
\mathbf{if}\;e^{re} \cdot \sin im\_m \leq 0.04:\\
\;\;\;\;im\_m \cdot \mathsf{fma}\left(im\_m, im\_m \cdot -0.16666666666666666, 1\right)\\
\mathbf{else}:\\
\;\;\;\;re \cdot \left(im\_m \cdot \left(0.16666666666666666 \cdot \left(re \cdot re\right)\right)\right)\\
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (sin.f64 im)) < 0.0400000000000000008Initial program 100.0%
Taylor expanded in re around 0
sin-lowering-sin.f6459.5
Simplified59.5%
Taylor expanded in im around 0
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f6446.5
Simplified46.5%
if 0.0400000000000000008 < (*.f64 (exp.f64 re) (sin.f64 im)) Initial program 100.0%
Taylor expanded in im around 0
Simplified41.0%
Taylor expanded in re around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
distribute-rgt-outN/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6426.0
Simplified26.0%
Taylor expanded in re around inf
associate-*r*N/A
*-commutativeN/A
cube-multN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6428.3
Simplified28.3%
Final simplification42.1%
im\_m = (fabs.f64 im)
im\_s = (copysign.f64 #s(literal 1 binary64) im)
(FPCore (im_s re im_m)
:precision binary64
(*
im_s
(if (<= (* (exp re) (sin im_m)) 0.0)
(* im_m (fma im_m (* im_m -0.16666666666666666) 1.0))
(* im_m (fma re (fma re 0.5 1.0) 1.0)))))im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
double tmp;
if ((exp(re) * sin(im_m)) <= 0.0) {
tmp = im_m * fma(im_m, (im_m * -0.16666666666666666), 1.0);
} else {
tmp = im_m * fma(re, fma(re, 0.5, 1.0), 1.0);
}
return im_s * tmp;
}
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) tmp = 0.0 if (Float64(exp(re) * sin(im_m)) <= 0.0) tmp = Float64(im_m * fma(im_m, Float64(im_m * -0.16666666666666666), 1.0)); else tmp = Float64(im_m * fma(re, fma(re, 0.5, 1.0), 1.0)); end return Float64(im_s * tmp) end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := N[(im$95$s * If[LessEqual[N[(N[Exp[re], $MachinePrecision] * N[Sin[im$95$m], $MachinePrecision]), $MachinePrecision], 0.0], N[(im$95$m * N[(im$95$m * N[(im$95$m * -0.16666666666666666), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(im$95$m * N[(re * N[(re * 0.5 + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
im\_s \cdot \begin{array}{l}
\mathbf{if}\;e^{re} \cdot \sin im\_m \leq 0:\\
\;\;\;\;im\_m \cdot \mathsf{fma}\left(im\_m, im\_m \cdot -0.16666666666666666, 1\right)\\
\mathbf{else}:\\
\;\;\;\;im\_m \cdot \mathsf{fma}\left(re, \mathsf{fma}\left(re, 0.5, 1\right), 1\right)\\
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (sin.f64 im)) < 0.0Initial program 100.0%
Taylor expanded in re around 0
sin-lowering-sin.f6451.1
Simplified51.1%
Taylor expanded in im around 0
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f6436.0
Simplified36.0%
if 0.0 < (*.f64 (exp.f64 re) (sin.f64 im)) Initial program 100.0%
Taylor expanded in im around 0
Simplified60.0%
Taylor expanded in re around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6449.2
Simplified49.2%
Final simplification41.0%
im\_m = (fabs.f64 im)
im\_s = (copysign.f64 #s(literal 1 binary64) im)
(FPCore (im_s re im_m)
:precision binary64
(*
im_s
(if (<= (* (exp re) (sin im_m)) 0.04)
(* im_m (fma im_m (* im_m -0.16666666666666666) 1.0))
(* im_m (* 0.5 (* re re))))))im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
double tmp;
if ((exp(re) * sin(im_m)) <= 0.04) {
tmp = im_m * fma(im_m, (im_m * -0.16666666666666666), 1.0);
} else {
tmp = im_m * (0.5 * (re * re));
}
return im_s * tmp;
}
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) tmp = 0.0 if (Float64(exp(re) * sin(im_m)) <= 0.04) tmp = Float64(im_m * fma(im_m, Float64(im_m * -0.16666666666666666), 1.0)); else tmp = Float64(im_m * Float64(0.5 * Float64(re * re))); end return Float64(im_s * tmp) end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := N[(im$95$s * If[LessEqual[N[(N[Exp[re], $MachinePrecision] * N[Sin[im$95$m], $MachinePrecision]), $MachinePrecision], 0.04], N[(im$95$m * N[(im$95$m * N[(im$95$m * -0.16666666666666666), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(im$95$m * N[(0.5 * N[(re * re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
im\_s \cdot \begin{array}{l}
\mathbf{if}\;e^{re} \cdot \sin im\_m \leq 0.04:\\
\;\;\;\;im\_m \cdot \mathsf{fma}\left(im\_m, im\_m \cdot -0.16666666666666666, 1\right)\\
\mathbf{else}:\\
\;\;\;\;im\_m \cdot \left(0.5 \cdot \left(re \cdot re\right)\right)\\
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (sin.f64 im)) < 0.0400000000000000008Initial program 100.0%
Taylor expanded in re around 0
sin-lowering-sin.f6459.5
Simplified59.5%
Taylor expanded in im around 0
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f6446.5
Simplified46.5%
if 0.0400000000000000008 < (*.f64 (exp.f64 re) (sin.f64 im)) Initial program 100.0%
Taylor expanded in im around 0
Simplified41.0%
Taylor expanded in re around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6424.3
Simplified24.3%
Taylor expanded in re around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6424.7
Simplified24.7%
Final simplification41.2%
im\_m = (fabs.f64 im) im\_s = (copysign.f64 #s(literal 1 binary64) im) (FPCore (im_s re im_m) :precision binary64 (* im_s (if (<= (* (exp re) (sin im_m)) 0.45) im_m (* im_m (* 0.5 (* re re))))))
im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
double tmp;
if ((exp(re) * sin(im_m)) <= 0.45) {
tmp = im_m;
} else {
tmp = im_m * (0.5 * (re * re));
}
return im_s * tmp;
}
im\_m = abs(im)
im\_s = copysign(1.0d0, im)
real(8) function code(im_s, re, im_m)
real(8), intent (in) :: im_s
real(8), intent (in) :: re
real(8), intent (in) :: im_m
real(8) :: tmp
if ((exp(re) * sin(im_m)) <= 0.45d0) then
tmp = im_m
else
tmp = im_m * (0.5d0 * (re * re))
end if
code = im_s * tmp
end function
im\_m = Math.abs(im);
im\_s = Math.copySign(1.0, im);
public static double code(double im_s, double re, double im_m) {
double tmp;
if ((Math.exp(re) * Math.sin(im_m)) <= 0.45) {
tmp = im_m;
} else {
tmp = im_m * (0.5 * (re * re));
}
return im_s * tmp;
}
im\_m = math.fabs(im) im\_s = math.copysign(1.0, im) def code(im_s, re, im_m): tmp = 0 if (math.exp(re) * math.sin(im_m)) <= 0.45: tmp = im_m else: tmp = im_m * (0.5 * (re * re)) return im_s * tmp
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) tmp = 0.0 if (Float64(exp(re) * sin(im_m)) <= 0.45) tmp = im_m; else tmp = Float64(im_m * Float64(0.5 * Float64(re * re))); end return Float64(im_s * tmp) end
im\_m = abs(im); im\_s = sign(im) * abs(1.0); function tmp_2 = code(im_s, re, im_m) tmp = 0.0; if ((exp(re) * sin(im_m)) <= 0.45) tmp = im_m; else tmp = im_m * (0.5 * (re * re)); end tmp_2 = im_s * tmp; end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := N[(im$95$s * If[LessEqual[N[(N[Exp[re], $MachinePrecision] * N[Sin[im$95$m], $MachinePrecision]), $MachinePrecision], 0.45], im$95$m, N[(im$95$m * N[(0.5 * N[(re * re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
im\_s \cdot \begin{array}{l}
\mathbf{if}\;e^{re} \cdot \sin im\_m \leq 0.45:\\
\;\;\;\;im\_m\\
\mathbf{else}:\\
\;\;\;\;im\_m \cdot \left(0.5 \cdot \left(re \cdot re\right)\right)\\
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (sin.f64 im)) < 0.450000000000000011Initial program 100.0%
Taylor expanded in im around 0
Simplified74.9%
Taylor expanded in re around 0
Simplified41.4%
if 0.450000000000000011 < (*.f64 (exp.f64 re) (sin.f64 im)) Initial program 100.0%
Taylor expanded in im around 0
Simplified48.3%
Taylor expanded in re around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6428.4
Simplified28.4%
Taylor expanded in re around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6428.7
Simplified28.7%
Final simplification38.8%
im\_m = (fabs.f64 im) im\_s = (copysign.f64 #s(literal 1 binary64) im) (FPCore (im_s re im_m) :precision binary64 (* im_s (if (<= (* (exp re) (sin im_m)) 0.45) im_m (* re (* 0.5 (* re im_m))))))
im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
double tmp;
if ((exp(re) * sin(im_m)) <= 0.45) {
tmp = im_m;
} else {
tmp = re * (0.5 * (re * im_m));
}
return im_s * tmp;
}
im\_m = abs(im)
im\_s = copysign(1.0d0, im)
real(8) function code(im_s, re, im_m)
real(8), intent (in) :: im_s
real(8), intent (in) :: re
real(8), intent (in) :: im_m
real(8) :: tmp
if ((exp(re) * sin(im_m)) <= 0.45d0) then
tmp = im_m
else
tmp = re * (0.5d0 * (re * im_m))
end if
code = im_s * tmp
end function
im\_m = Math.abs(im);
im\_s = Math.copySign(1.0, im);
public static double code(double im_s, double re, double im_m) {
double tmp;
if ((Math.exp(re) * Math.sin(im_m)) <= 0.45) {
tmp = im_m;
} else {
tmp = re * (0.5 * (re * im_m));
}
return im_s * tmp;
}
im\_m = math.fabs(im) im\_s = math.copysign(1.0, im) def code(im_s, re, im_m): tmp = 0 if (math.exp(re) * math.sin(im_m)) <= 0.45: tmp = im_m else: tmp = re * (0.5 * (re * im_m)) return im_s * tmp
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) tmp = 0.0 if (Float64(exp(re) * sin(im_m)) <= 0.45) tmp = im_m; else tmp = Float64(re * Float64(0.5 * Float64(re * im_m))); end return Float64(im_s * tmp) end
im\_m = abs(im); im\_s = sign(im) * abs(1.0); function tmp_2 = code(im_s, re, im_m) tmp = 0.0; if ((exp(re) * sin(im_m)) <= 0.45) tmp = im_m; else tmp = re * (0.5 * (re * im_m)); end tmp_2 = im_s * tmp; end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := N[(im$95$s * If[LessEqual[N[(N[Exp[re], $MachinePrecision] * N[Sin[im$95$m], $MachinePrecision]), $MachinePrecision], 0.45], im$95$m, N[(re * N[(0.5 * N[(re * im$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
im\_s \cdot \begin{array}{l}
\mathbf{if}\;e^{re} \cdot \sin im\_m \leq 0.45:\\
\;\;\;\;im\_m\\
\mathbf{else}:\\
\;\;\;\;re \cdot \left(0.5 \cdot \left(re \cdot im\_m\right)\right)\\
\end{array}
\end{array}
if (*.f64 (exp.f64 re) (sin.f64 im)) < 0.450000000000000011Initial program 100.0%
Taylor expanded in im around 0
Simplified74.9%
Taylor expanded in re around 0
Simplified41.4%
if 0.450000000000000011 < (*.f64 (exp.f64 re) (sin.f64 im)) Initial program 100.0%
Taylor expanded in im around 0
Simplified48.3%
Taylor expanded in re around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6428.4
Simplified28.4%
Taylor expanded in re around inf
unpow2N/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6421.7
Simplified21.7%
im\_m = (fabs.f64 im) im\_s = (copysign.f64 #s(literal 1 binary64) im) (FPCore (im_s re im_m) :precision binary64 (* im_s (* (exp re) (sin im_m))))
im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
return im_s * (exp(re) * sin(im_m));
}
im\_m = abs(im)
im\_s = copysign(1.0d0, im)
real(8) function code(im_s, re, im_m)
real(8), intent (in) :: im_s
real(8), intent (in) :: re
real(8), intent (in) :: im_m
code = im_s * (exp(re) * sin(im_m))
end function
im\_m = Math.abs(im);
im\_s = Math.copySign(1.0, im);
public static double code(double im_s, double re, double im_m) {
return im_s * (Math.exp(re) * Math.sin(im_m));
}
im\_m = math.fabs(im) im\_s = math.copysign(1.0, im) def code(im_s, re, im_m): return im_s * (math.exp(re) * math.sin(im_m))
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) return Float64(im_s * Float64(exp(re) * sin(im_m))) end
im\_m = abs(im); im\_s = sign(im) * abs(1.0); function tmp = code(im_s, re, im_m) tmp = im_s * (exp(re) * sin(im_m)); end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := N[(im$95$s * N[(N[Exp[re], $MachinePrecision] * N[Sin[im$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
im\_s \cdot \left(e^{re} \cdot \sin im\_m\right)
\end{array}
Initial program 100.0%
im\_m = (fabs.f64 im) im\_s = (copysign.f64 #s(literal 1 binary64) im) (FPCore (im_s re im_m) :precision binary64 (* im_s (if (<= im_m 175.0) im_m (* re im_m))))
im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
double tmp;
if (im_m <= 175.0) {
tmp = im_m;
} else {
tmp = re * im_m;
}
return im_s * tmp;
}
im\_m = abs(im)
im\_s = copysign(1.0d0, im)
real(8) function code(im_s, re, im_m)
real(8), intent (in) :: im_s
real(8), intent (in) :: re
real(8), intent (in) :: im_m
real(8) :: tmp
if (im_m <= 175.0d0) then
tmp = im_m
else
tmp = re * im_m
end if
code = im_s * tmp
end function
im\_m = Math.abs(im);
im\_s = Math.copySign(1.0, im);
public static double code(double im_s, double re, double im_m) {
double tmp;
if (im_m <= 175.0) {
tmp = im_m;
} else {
tmp = re * im_m;
}
return im_s * tmp;
}
im\_m = math.fabs(im) im\_s = math.copysign(1.0, im) def code(im_s, re, im_m): tmp = 0 if im_m <= 175.0: tmp = im_m else: tmp = re * im_m return im_s * tmp
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) tmp = 0.0 if (im_m <= 175.0) tmp = im_m; else tmp = Float64(re * im_m); end return Float64(im_s * tmp) end
im\_m = abs(im); im\_s = sign(im) * abs(1.0); function tmp_2 = code(im_s, re, im_m) tmp = 0.0; if (im_m <= 175.0) tmp = im_m; else tmp = re * im_m; end tmp_2 = im_s * tmp; end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := N[(im$95$s * If[LessEqual[im$95$m, 175.0], im$95$m, N[(re * im$95$m), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
im\_s \cdot \begin{array}{l}
\mathbf{if}\;im\_m \leq 175:\\
\;\;\;\;im\_m\\
\mathbf{else}:\\
\;\;\;\;re \cdot im\_m\\
\end{array}
\end{array}
if im < 175Initial program 100.0%
Taylor expanded in im around 0
Simplified79.2%
Taylor expanded in re around 0
Simplified42.4%
if 175 < im Initial program 99.9%
Taylor expanded in im around 0
Simplified35.8%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f647.4
Simplified7.4%
Taylor expanded in re around inf
*-commutativeN/A
*-lowering-*.f648.1
Simplified8.1%
im\_m = (fabs.f64 im) im\_s = (copysign.f64 #s(literal 1 binary64) im) (FPCore (im_s re im_m) :precision binary64 (* im_s (* im_m (+ re 1.0))))
im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
return im_s * (im_m * (re + 1.0));
}
im\_m = abs(im)
im\_s = copysign(1.0d0, im)
real(8) function code(im_s, re, im_m)
real(8), intent (in) :: im_s
real(8), intent (in) :: re
real(8), intent (in) :: im_m
code = im_s * (im_m * (re + 1.0d0))
end function
im\_m = Math.abs(im);
im\_s = Math.copySign(1.0, im);
public static double code(double im_s, double re, double im_m) {
return im_s * (im_m * (re + 1.0));
}
im\_m = math.fabs(im) im\_s = math.copysign(1.0, im) def code(im_s, re, im_m): return im_s * (im_m * (re + 1.0))
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) return Float64(im_s * Float64(im_m * Float64(re + 1.0))) end
im\_m = abs(im); im\_s = sign(im) * abs(1.0); function tmp = code(im_s, re, im_m) tmp = im_s * (im_m * (re + 1.0)); end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := N[(im$95$s * N[(im$95$m * N[(re + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
im\_s \cdot \left(im\_m \cdot \left(re + 1\right)\right)
\end{array}
Initial program 100.0%
Taylor expanded in re around 0
+-commutativeN/A
+-lowering-+.f6458.3
Simplified58.3%
Taylor expanded in im around 0
Simplified35.3%
Final simplification35.3%
im\_m = (fabs.f64 im) im\_s = (copysign.f64 #s(literal 1 binary64) im) (FPCore (im_s re im_m) :precision binary64 (* im_s (fma re im_m im_m)))
im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
return im_s * fma(re, im_m, im_m);
}
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) return Float64(im_s * fma(re, im_m, im_m)) end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := N[(im$95$s * N[(re * im$95$m + im$95$m), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
im\_s \cdot \mathsf{fma}\left(re, im\_m, im\_m\right)
\end{array}
Initial program 100.0%
Taylor expanded in im around 0
Simplified69.4%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6435.3
Simplified35.3%
im\_m = (fabs.f64 im) im\_s = (copysign.f64 #s(literal 1 binary64) im) (FPCore (im_s re im_m) :precision binary64 (* im_s im_m))
im\_m = fabs(im);
im\_s = copysign(1.0, im);
double code(double im_s, double re, double im_m) {
return im_s * im_m;
}
im\_m = abs(im)
im\_s = copysign(1.0d0, im)
real(8) function code(im_s, re, im_m)
real(8), intent (in) :: im_s
real(8), intent (in) :: re
real(8), intent (in) :: im_m
code = im_s * im_m
end function
im\_m = Math.abs(im);
im\_s = Math.copySign(1.0, im);
public static double code(double im_s, double re, double im_m) {
return im_s * im_m;
}
im\_m = math.fabs(im) im\_s = math.copysign(1.0, im) def code(im_s, re, im_m): return im_s * im_m
im\_m = abs(im) im\_s = copysign(1.0, im) function code(im_s, re, im_m) return Float64(im_s * im_m) end
im\_m = abs(im); im\_s = sign(im) * abs(1.0); function tmp = code(im_s, re, im_m) tmp = im_s * im_m; end
im\_m = N[Abs[im], $MachinePrecision]
im\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[im$95$s_, re_, im$95$m_] := N[(im$95$s * im$95$m), $MachinePrecision]
\begin{array}{l}
im\_m = \left|im\right|
\\
im\_s = \mathsf{copysign}\left(1, im\right)
\\
im\_s \cdot im\_m
\end{array}
Initial program 100.0%
Taylor expanded in im around 0
Simplified69.4%
Taylor expanded in re around 0
Simplified33.4%
herbie shell --seed 2024196
(FPCore (re im)
:name "math.exp on complex, imaginary part"
:precision binary64
(* (exp re) (sin im)))