
(FPCore (re im) :precision binary64 (* (* 0.5 (sin re)) (+ (exp (- 0.0 im)) (exp im))))
double code(double re, double im) {
return (0.5 * sin(re)) * (exp((0.0 - im)) + exp(im));
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
code = (0.5d0 * sin(re)) * (exp((0.0d0 - im)) + exp(im))
end function
public static double code(double re, double im) {
return (0.5 * Math.sin(re)) * (Math.exp((0.0 - im)) + Math.exp(im));
}
def code(re, im): return (0.5 * math.sin(re)) * (math.exp((0.0 - im)) + math.exp(im))
function code(re, im) return Float64(Float64(0.5 * sin(re)) * Float64(exp(Float64(0.0 - im)) + exp(im))) end
function tmp = code(re, im) tmp = (0.5 * sin(re)) * (exp((0.0 - im)) + exp(im)); end
code[re_, im_] := N[(N[(0.5 * N[Sin[re], $MachinePrecision]), $MachinePrecision] * N[(N[Exp[N[(0.0 - im), $MachinePrecision]], $MachinePrecision] + N[Exp[im], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(0.5 \cdot \sin re\right) \cdot \left(e^{0 - im} + e^{im}\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 11 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (re im) :precision binary64 (* (* 0.5 (sin re)) (+ (exp (- 0.0 im)) (exp im))))
double code(double re, double im) {
return (0.5 * sin(re)) * (exp((0.0 - im)) + exp(im));
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
code = (0.5d0 * sin(re)) * (exp((0.0d0 - im)) + exp(im))
end function
public static double code(double re, double im) {
return (0.5 * Math.sin(re)) * (Math.exp((0.0 - im)) + Math.exp(im));
}
def code(re, im): return (0.5 * math.sin(re)) * (math.exp((0.0 - im)) + math.exp(im))
function code(re, im) return Float64(Float64(0.5 * sin(re)) * Float64(exp(Float64(0.0 - im)) + exp(im))) end
function tmp = code(re, im) tmp = (0.5 * sin(re)) * (exp((0.0 - im)) + exp(im)); end
code[re_, im_] := N[(N[(0.5 * N[Sin[re], $MachinePrecision]), $MachinePrecision] * N[(N[Exp[N[(0.0 - im), $MachinePrecision]], $MachinePrecision] + N[Exp[im], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(0.5 \cdot \sin re\right) \cdot \left(e^{0 - im} + e^{im}\right)
\end{array}
(FPCore (re im) :precision binary64 (* (* 0.5 (sin re)) (+ (exp (- im)) (exp im))))
double code(double re, double im) {
return (0.5 * sin(re)) * (exp(-im) + exp(im));
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
code = (0.5d0 * sin(re)) * (exp(-im) + exp(im))
end function
public static double code(double re, double im) {
return (0.5 * Math.sin(re)) * (Math.exp(-im) + Math.exp(im));
}
def code(re, im): return (0.5 * math.sin(re)) * (math.exp(-im) + math.exp(im))
function code(re, im) return Float64(Float64(0.5 * sin(re)) * Float64(exp(Float64(-im)) + exp(im))) end
function tmp = code(re, im) tmp = (0.5 * sin(re)) * (exp(-im) + exp(im)); end
code[re_, im_] := N[(N[(0.5 * N[Sin[re], $MachinePrecision]), $MachinePrecision] * N[(N[Exp[(-im)], $MachinePrecision] + N[Exp[im], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(0.5 \cdot \sin re\right) \cdot \left(e^{-im} + e^{im}\right)
\end{array}
Initial program 99.6%
distribute-lft-in99.6%
cancel-sign-sub99.6%
distribute-rgt-neg-out99.6%
sin-neg99.6%
*-commutative99.6%
sin-neg99.6%
distribute-rgt-neg-out99.6%
neg-mul-199.6%
associate-*r*99.6%
*-commutative99.6%
distribute-lft-out--99.6%
sub-neg99.6%
neg-sub099.6%
Simplified99.6%
Final simplification99.6%
(FPCore (re im)
:precision binary64
(let* ((t_0 (* (sin re) (+ 1.0 (* im (* 0.5 im))))))
(if (<= im 0.0295)
t_0
(if (<= im 3.3e+117)
(* re (cosh im))
(cast (! :precision binary32 (cast (! :precision binary64 t_0))))))))
double code(double re, double im) {
double t_0 = sin(re) * (1.0 + (im * (0.5 * im)));
double tmp;
if (im <= 0.0295) {
tmp = t_0;
} else if (im <= 3.3e+117) {
tmp = re * cosh(im);
} else {
double tmp_3 = t_0;
double tmp_2 = (float) tmp_3;
tmp = (double) tmp_2;
}
return tmp;
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
real(8) :: t_0
real(8) :: tmp
real(8) :: tmp_1
real(8) :: tmp_2
real(8) :: tmp_3
t_0 = sin(re) * (1.0d0 + (im * (0.5d0 * im)))
if (im <= 0.0295d0) then
tmp = t_0
else if (im <= 3.3d+117) then
tmp = re * cosh(im)
else
tmp_3 = t_0
tmp_2 = real(tmp_3, 4)
tmp = real(tmp_2, 8)
end if
code = tmp
end function
function code(re, im) t_0 = Float64(sin(re) * Float64(1.0 + Float64(im * Float64(0.5 * im)))) tmp = 0.0 if (im <= 0.0295) tmp = t_0; elseif (im <= 3.3e+117) tmp = Float64(re * cosh(im)); else tmp_3 = t_0 tmp_2 = Float32(tmp_3) tmp = Float64(tmp_2); end return tmp end
function tmp_5 = code(re, im) t_0 = sin(re) * (1.0 + (im * (0.5 * im))); tmp = 0.0; if (im <= 0.0295) tmp = t_0; elseif (im <= 3.3e+117) tmp = re * cosh(im); else tmp_4 = t_0; tmp_3 = single(tmp_4); tmp = double(tmp_3); end tmp_5 = tmp; end
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sin re \cdot \left(1 + im \cdot \left(0.5 \cdot im\right)\right)\\
\mathbf{if}\;im \leq 0.0295:\\
\;\;\;\;t_0\\
\mathbf{elif}\;im \leq 3.3 \cdot 10^{+117}:\\
\;\;\;\;re \cdot \cosh im\\
\mathbf{else}:\\
\;\;\;\;\langle \left( \langle \left( t_0 \right)_{\text{binary64}} \rangle_{\text{binary32}} \right)_{\text{binary32}} \rangle_{\text{binary64}}\\
\end{array}
\end{array}
if im < 0.029499999999999998Initial program 99.5%
distribute-lft-in99.5%
cancel-sign-sub99.5%
distribute-rgt-neg-out99.5%
sin-neg99.5%
*-commutative99.5%
sin-neg99.5%
distribute-rgt-neg-out99.5%
neg-mul-199.5%
associate-*r*99.5%
*-commutative99.5%
distribute-lft-out--99.5%
sub-neg99.5%
neg-sub099.5%
Simplified99.5%
Taylor expanded in im around 0 84.6%
*-lft-identity84.6%
associate-*r*84.6%
distribute-rgt-out84.6%
unpow284.6%
associate-*r*84.6%
Simplified84.6%
if 0.029499999999999998 < im < 3.2999999999999998e117Initial program 100.0%
distribute-lft-in100.0%
cancel-sign-sub100.0%
distribute-rgt-neg-out100.0%
sin-neg100.0%
*-commutative100.0%
sin-neg100.0%
distribute-rgt-neg-out100.0%
neg-mul-1100.0%
associate-*r*100.0%
*-commutative100.0%
distribute-lft-out--100.0%
sub-neg100.0%
neg-sub0100.0%
Simplified100.0%
Taylor expanded in re around 0 88.2%
flip3-+5.8%
associate-*r/5.8%
associate-/l*5.8%
*-commutative5.8%
clear-num5.8%
flip3-+88.2%
+-commutative88.2%
cosh-undef88.2%
Applied egg-rr88.2%
associate-/l*88.2%
associate-/r*88.2%
metadata-eval88.2%
Simplified88.2%
clear-num88.1%
associate-/r/88.2%
clear-num88.2%
associate-/r/88.2%
metadata-eval88.2%
*-lft-identity88.2%
Applied egg-rr88.2%
if 3.2999999999999998e117 < im Initial program 100.0%
distribute-lft-in100.0%
cancel-sign-sub100.0%
distribute-rgt-neg-out100.0%
sin-neg100.0%
*-commutative100.0%
sin-neg100.0%
distribute-rgt-neg-out100.0%
neg-mul-1100.0%
associate-*r*100.0%
*-commutative100.0%
distribute-lft-out--100.0%
sub-neg100.0%
neg-sub0100.0%
Simplified100.0%
Taylor expanded in im around 0 85.1%
*-lft-identity85.1%
associate-*r*85.1%
distribute-rgt-out85.1%
unpow285.1%
associate-*r*85.1%
Simplified85.1%
rewrite-binary64/binary32-simplify100.0%
Applied rewrite-once100.0%
Final simplification87.5%
(FPCore (re im) :precision binary64 (if (<= im 0.082) (* (sin re) (+ 1.0 (* im (* 0.5 im)))) (if (<= im 1.35e+154) (* re (cosh im)) (* (sin re) (* im im)))))
double code(double re, double im) {
double tmp;
if (im <= 0.082) {
tmp = sin(re) * (1.0 + (im * (0.5 * im)));
} else if (im <= 1.35e+154) {
tmp = re * cosh(im);
} else {
tmp = sin(re) * (im * im);
}
return tmp;
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
real(8) :: tmp
if (im <= 0.082d0) then
tmp = sin(re) * (1.0d0 + (im * (0.5d0 * im)))
else if (im <= 1.35d+154) then
tmp = re * cosh(im)
else
tmp = sin(re) * (im * im)
end if
code = tmp
end function
public static double code(double re, double im) {
double tmp;
if (im <= 0.082) {
tmp = Math.sin(re) * (1.0 + (im * (0.5 * im)));
} else if (im <= 1.35e+154) {
tmp = re * Math.cosh(im);
} else {
tmp = Math.sin(re) * (im * im);
}
return tmp;
}
def code(re, im): tmp = 0 if im <= 0.082: tmp = math.sin(re) * (1.0 + (im * (0.5 * im))) elif im <= 1.35e+154: tmp = re * math.cosh(im) else: tmp = math.sin(re) * (im * im) return tmp
function code(re, im) tmp = 0.0 if (im <= 0.082) tmp = Float64(sin(re) * Float64(1.0 + Float64(im * Float64(0.5 * im)))); elseif (im <= 1.35e+154) tmp = Float64(re * cosh(im)); else tmp = Float64(sin(re) * Float64(im * im)); end return tmp end
function tmp_2 = code(re, im) tmp = 0.0; if (im <= 0.082) tmp = sin(re) * (1.0 + (im * (0.5 * im))); elseif (im <= 1.35e+154) tmp = re * cosh(im); else tmp = sin(re) * (im * im); end tmp_2 = tmp; end
code[re_, im_] := If[LessEqual[im, 0.082], N[(N[Sin[re], $MachinePrecision] * N[(1.0 + N[(im * N[(0.5 * im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[im, 1.35e+154], N[(re * N[Cosh[im], $MachinePrecision]), $MachinePrecision], N[(N[Sin[re], $MachinePrecision] * N[(im * im), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;im \leq 0.082:\\
\;\;\;\;\sin re \cdot \left(1 + im \cdot \left(0.5 \cdot im\right)\right)\\
\mathbf{elif}\;im \leq 1.35 \cdot 10^{+154}:\\
\;\;\;\;re \cdot \cosh im\\
\mathbf{else}:\\
\;\;\;\;\sin re \cdot \left(im \cdot im\right)\\
\end{array}
\end{array}
if im < 0.0820000000000000034Initial program 99.5%
distribute-lft-in99.5%
cancel-sign-sub99.5%
distribute-rgt-neg-out99.5%
sin-neg99.5%
*-commutative99.5%
sin-neg99.5%
distribute-rgt-neg-out99.5%
neg-mul-199.5%
associate-*r*99.5%
*-commutative99.5%
distribute-lft-out--99.5%
sub-neg99.5%
neg-sub099.5%
Simplified99.5%
Taylor expanded in im around 0 84.6%
*-lft-identity84.6%
associate-*r*84.6%
distribute-rgt-out84.6%
unpow284.6%
associate-*r*84.6%
Simplified84.6%
if 0.0820000000000000034 < im < 1.35000000000000003e154Initial program 100.0%
distribute-lft-in100.0%
cancel-sign-sub100.0%
distribute-rgt-neg-out100.0%
sin-neg100.0%
*-commutative100.0%
sin-neg100.0%
distribute-rgt-neg-out100.0%
neg-mul-1100.0%
associate-*r*100.0%
*-commutative100.0%
distribute-lft-out--100.0%
sub-neg100.0%
neg-sub0100.0%
Simplified100.0%
Taylor expanded in re around 0 75.0%
flip3-+4.1%
associate-*r/4.1%
associate-/l*4.1%
*-commutative4.1%
clear-num4.1%
flip3-+75.0%
+-commutative75.0%
cosh-undef75.0%
Applied egg-rr75.0%
associate-/l*75.0%
associate-/r*75.0%
metadata-eval75.0%
Simplified75.0%
clear-num74.9%
associate-/r/75.0%
clear-num75.0%
associate-/r/75.0%
metadata-eval75.0%
*-lft-identity75.0%
Applied egg-rr75.0%
if 1.35000000000000003e154 < im Initial program 100.0%
distribute-lft-in100.0%
cancel-sign-sub100.0%
distribute-rgt-neg-out100.0%
sin-neg100.0%
*-commutative100.0%
sin-neg100.0%
distribute-rgt-neg-out100.0%
neg-mul-1100.0%
associate-*r*100.0%
*-commutative100.0%
distribute-lft-out--100.0%
sub-neg100.0%
neg-sub0100.0%
Simplified100.0%
Taylor expanded in im around 0 100.0%
*-lft-identity100.0%
associate-*r*100.0%
distribute-rgt-out100.0%
unpow2100.0%
associate-*r*100.0%
Simplified100.0%
Applied egg-rr100.0%
Taylor expanded in im around inf 100.0%
*-commutative100.0%
unpow2100.0%
Simplified100.0%
Final simplification85.9%
(FPCore (re im) :precision binary64 (if (<= im 0.0106) (sin re) (if (<= im 1.35e+154) (* re (cosh im)) (* (sin re) (* im im)))))
double code(double re, double im) {
double tmp;
if (im <= 0.0106) {
tmp = sin(re);
} else if (im <= 1.35e+154) {
tmp = re * cosh(im);
} else {
tmp = sin(re) * (im * im);
}
return tmp;
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
real(8) :: tmp
if (im <= 0.0106d0) then
tmp = sin(re)
else if (im <= 1.35d+154) then
tmp = re * cosh(im)
else
tmp = sin(re) * (im * im)
end if
code = tmp
end function
public static double code(double re, double im) {
double tmp;
if (im <= 0.0106) {
tmp = Math.sin(re);
} else if (im <= 1.35e+154) {
tmp = re * Math.cosh(im);
} else {
tmp = Math.sin(re) * (im * im);
}
return tmp;
}
def code(re, im): tmp = 0 if im <= 0.0106: tmp = math.sin(re) elif im <= 1.35e+154: tmp = re * math.cosh(im) else: tmp = math.sin(re) * (im * im) return tmp
function code(re, im) tmp = 0.0 if (im <= 0.0106) tmp = sin(re); elseif (im <= 1.35e+154) tmp = Float64(re * cosh(im)); else tmp = Float64(sin(re) * Float64(im * im)); end return tmp end
function tmp_2 = code(re, im) tmp = 0.0; if (im <= 0.0106) tmp = sin(re); elseif (im <= 1.35e+154) tmp = re * cosh(im); else tmp = sin(re) * (im * im); end tmp_2 = tmp; end
code[re_, im_] := If[LessEqual[im, 0.0106], N[Sin[re], $MachinePrecision], If[LessEqual[im, 1.35e+154], N[(re * N[Cosh[im], $MachinePrecision]), $MachinePrecision], N[(N[Sin[re], $MachinePrecision] * N[(im * im), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;im \leq 0.0106:\\
\;\;\;\;\sin re\\
\mathbf{elif}\;im \leq 1.35 \cdot 10^{+154}:\\
\;\;\;\;re \cdot \cosh im\\
\mathbf{else}:\\
\;\;\;\;\sin re \cdot \left(im \cdot im\right)\\
\end{array}
\end{array}
if im < 0.0106Initial program 99.5%
distribute-lft-in99.5%
cancel-sign-sub99.5%
distribute-rgt-neg-out99.5%
sin-neg99.5%
*-commutative99.5%
sin-neg99.5%
distribute-rgt-neg-out99.5%
neg-mul-199.5%
associate-*r*99.5%
*-commutative99.5%
distribute-lft-out--99.5%
sub-neg99.5%
neg-sub099.5%
Simplified99.5%
Taylor expanded in im around 0 66.3%
if 0.0106 < im < 1.35000000000000003e154Initial program 100.0%
distribute-lft-in100.0%
cancel-sign-sub100.0%
distribute-rgt-neg-out100.0%
sin-neg100.0%
*-commutative100.0%
sin-neg100.0%
distribute-rgt-neg-out100.0%
neg-mul-1100.0%
associate-*r*100.0%
*-commutative100.0%
distribute-lft-out--100.0%
sub-neg100.0%
neg-sub0100.0%
Simplified100.0%
Taylor expanded in re around 0 75.0%
flip3-+4.1%
associate-*r/4.1%
associate-/l*4.1%
*-commutative4.1%
clear-num4.1%
flip3-+75.0%
+-commutative75.0%
cosh-undef75.0%
Applied egg-rr75.0%
associate-/l*75.0%
associate-/r*75.0%
metadata-eval75.0%
Simplified75.0%
clear-num74.9%
associate-/r/75.0%
clear-num75.0%
associate-/r/75.0%
metadata-eval75.0%
*-lft-identity75.0%
Applied egg-rr75.0%
if 1.35000000000000003e154 < im Initial program 100.0%
distribute-lft-in100.0%
cancel-sign-sub100.0%
distribute-rgt-neg-out100.0%
sin-neg100.0%
*-commutative100.0%
sin-neg100.0%
distribute-rgt-neg-out100.0%
neg-mul-1100.0%
associate-*r*100.0%
*-commutative100.0%
distribute-lft-out--100.0%
sub-neg100.0%
neg-sub0100.0%
Simplified100.0%
Taylor expanded in im around 0 100.0%
*-lft-identity100.0%
associate-*r*100.0%
distribute-rgt-out100.0%
unpow2100.0%
associate-*r*100.0%
Simplified100.0%
Applied egg-rr100.0%
Taylor expanded in im around inf 100.0%
*-commutative100.0%
unpow2100.0%
Simplified100.0%
Final simplification71.9%
(FPCore (re im) :precision binary64 (if (<= im 0.0175) (sin re) (* re (cosh im))))
double code(double re, double im) {
double tmp;
if (im <= 0.0175) {
tmp = sin(re);
} else {
tmp = re * cosh(im);
}
return tmp;
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
real(8) :: tmp
if (im <= 0.0175d0) then
tmp = sin(re)
else
tmp = re * cosh(im)
end if
code = tmp
end function
public static double code(double re, double im) {
double tmp;
if (im <= 0.0175) {
tmp = Math.sin(re);
} else {
tmp = re * Math.cosh(im);
}
return tmp;
}
def code(re, im): tmp = 0 if im <= 0.0175: tmp = math.sin(re) else: tmp = re * math.cosh(im) return tmp
function code(re, im) tmp = 0.0 if (im <= 0.0175) tmp = sin(re); else tmp = Float64(re * cosh(im)); end return tmp end
function tmp_2 = code(re, im) tmp = 0.0; if (im <= 0.0175) tmp = sin(re); else tmp = re * cosh(im); end tmp_2 = tmp; end
code[re_, im_] := If[LessEqual[im, 0.0175], N[Sin[re], $MachinePrecision], N[(re * N[Cosh[im], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;im \leq 0.0175:\\
\;\;\;\;\sin re\\
\mathbf{else}:\\
\;\;\;\;re \cdot \cosh im\\
\end{array}
\end{array}
if im < 0.017500000000000002Initial program 99.5%
distribute-lft-in99.5%
cancel-sign-sub99.5%
distribute-rgt-neg-out99.5%
sin-neg99.5%
*-commutative99.5%
sin-neg99.5%
distribute-rgt-neg-out99.5%
neg-mul-199.5%
associate-*r*99.5%
*-commutative99.5%
distribute-lft-out--99.5%
sub-neg99.5%
neg-sub099.5%
Simplified99.5%
Taylor expanded in im around 0 66.3%
if 0.017500000000000002 < im Initial program 100.0%
distribute-lft-in100.0%
cancel-sign-sub100.0%
distribute-rgt-neg-out100.0%
sin-neg100.0%
*-commutative100.0%
sin-neg100.0%
distribute-rgt-neg-out100.0%
neg-mul-1100.0%
associate-*r*100.0%
*-commutative100.0%
distribute-lft-out--100.0%
sub-neg100.0%
neg-sub0100.0%
Simplified100.0%
Taylor expanded in re around 0 77.0%
flip3-+1.6%
associate-*r/1.6%
associate-/l*1.6%
*-commutative1.6%
clear-num1.6%
flip3-+77.0%
+-commutative77.0%
cosh-undef77.0%
Applied egg-rr77.0%
associate-/l*77.0%
associate-/r*77.0%
metadata-eval77.0%
Simplified77.0%
clear-num77.0%
associate-/r/77.0%
clear-num77.0%
associate-/r/77.0%
metadata-eval77.0%
*-lft-identity77.0%
Applied egg-rr77.0%
Final simplification68.8%
(FPCore (re im)
:precision binary64
(if (<= im 9.8e+23)
(sin re)
(if (<= im 6e+142)
(+ re (* (* re (* re re)) -0.16666666666666666))
(* (+ 1.0 (* im (* 0.5 im))) (* 2.0 (* re 2.0))))))
double code(double re, double im) {
double tmp;
if (im <= 9.8e+23) {
tmp = sin(re);
} else if (im <= 6e+142) {
tmp = re + ((re * (re * re)) * -0.16666666666666666);
} else {
tmp = (1.0 + (im * (0.5 * im))) * (2.0 * (re * 2.0));
}
return tmp;
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
real(8) :: tmp
if (im <= 9.8d+23) then
tmp = sin(re)
else if (im <= 6d+142) then
tmp = re + ((re * (re * re)) * (-0.16666666666666666d0))
else
tmp = (1.0d0 + (im * (0.5d0 * im))) * (2.0d0 * (re * 2.0d0))
end if
code = tmp
end function
public static double code(double re, double im) {
double tmp;
if (im <= 9.8e+23) {
tmp = Math.sin(re);
} else if (im <= 6e+142) {
tmp = re + ((re * (re * re)) * -0.16666666666666666);
} else {
tmp = (1.0 + (im * (0.5 * im))) * (2.0 * (re * 2.0));
}
return tmp;
}
def code(re, im): tmp = 0 if im <= 9.8e+23: tmp = math.sin(re) elif im <= 6e+142: tmp = re + ((re * (re * re)) * -0.16666666666666666) else: tmp = (1.0 + (im * (0.5 * im))) * (2.0 * (re * 2.0)) return tmp
function code(re, im) tmp = 0.0 if (im <= 9.8e+23) tmp = sin(re); elseif (im <= 6e+142) tmp = Float64(re + Float64(Float64(re * Float64(re * re)) * -0.16666666666666666)); else tmp = Float64(Float64(1.0 + Float64(im * Float64(0.5 * im))) * Float64(2.0 * Float64(re * 2.0))); end return tmp end
function tmp_2 = code(re, im) tmp = 0.0; if (im <= 9.8e+23) tmp = sin(re); elseif (im <= 6e+142) tmp = re + ((re * (re * re)) * -0.16666666666666666); else tmp = (1.0 + (im * (0.5 * im))) * (2.0 * (re * 2.0)); end tmp_2 = tmp; end
code[re_, im_] := If[LessEqual[im, 9.8e+23], N[Sin[re], $MachinePrecision], If[LessEqual[im, 6e+142], N[(re + N[(N[(re * N[(re * re), $MachinePrecision]), $MachinePrecision] * -0.16666666666666666), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 + N[(im * N[(0.5 * im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(2.0 * N[(re * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;im \leq 9.8 \cdot 10^{+23}:\\
\;\;\;\;\sin re\\
\mathbf{elif}\;im \leq 6 \cdot 10^{+142}:\\
\;\;\;\;re + \left(re \cdot \left(re \cdot re\right)\right) \cdot -0.16666666666666666\\
\mathbf{else}:\\
\;\;\;\;\left(1 + im \cdot \left(0.5 \cdot im\right)\right) \cdot \left(2 \cdot \left(re \cdot 2\right)\right)\\
\end{array}
\end{array}
if im < 9.8000000000000006e23Initial program 99.5%
distribute-lft-in99.5%
cancel-sign-sub99.5%
distribute-rgt-neg-out99.5%
sin-neg99.5%
*-commutative99.5%
sin-neg99.5%
distribute-rgt-neg-out99.5%
neg-mul-199.5%
associate-*r*99.5%
*-commutative99.5%
distribute-lft-out--99.5%
sub-neg99.5%
neg-sub099.5%
Simplified99.5%
Taylor expanded in im around 0 66.0%
if 9.8000000000000006e23 < im < 5.99999999999999949e142Initial program 100.0%
distribute-lft-in100.0%
cancel-sign-sub100.0%
distribute-rgt-neg-out100.0%
sin-neg100.0%
*-commutative100.0%
sin-neg100.0%
distribute-rgt-neg-out100.0%
neg-mul-1100.0%
associate-*r*100.0%
*-commutative100.0%
distribute-lft-out--100.0%
sub-neg100.0%
neg-sub0100.0%
Simplified100.0%
Taylor expanded in im around 0 2.5%
Taylor expanded in re around 0 25.3%
*-commutative25.3%
Simplified25.3%
unpow325.3%
Applied egg-rr25.3%
if 5.99999999999999949e142 < im Initial program 100.0%
distribute-lft-in100.0%
cancel-sign-sub100.0%
distribute-rgt-neg-out100.0%
sin-neg100.0%
*-commutative100.0%
sin-neg100.0%
distribute-rgt-neg-out100.0%
neg-mul-1100.0%
associate-*r*100.0%
*-commutative100.0%
distribute-lft-out--100.0%
sub-neg100.0%
neg-sub0100.0%
Simplified100.0%
Taylor expanded in im around 0 95.1%
*-lft-identity95.1%
associate-*r*95.1%
distribute-rgt-out95.1%
unpow295.1%
associate-*r*95.1%
Simplified95.1%
Applied egg-rr95.1%
Applied egg-rr95.1%
Taylor expanded in re around 0 74.6%
Final simplification63.9%
(FPCore (re im) :precision binary64 (if (or (<= re -3.6e+60) (not (<= re 1.8e+91))) (+ re (* (* re (* re re)) -0.16666666666666666)) (* re (+ 1.0 (* im (* 0.5 im))))))
double code(double re, double im) {
double tmp;
if ((re <= -3.6e+60) || !(re <= 1.8e+91)) {
tmp = re + ((re * (re * re)) * -0.16666666666666666);
} else {
tmp = re * (1.0 + (im * (0.5 * im)));
}
return tmp;
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
real(8) :: tmp
if ((re <= (-3.6d+60)) .or. (.not. (re <= 1.8d+91))) then
tmp = re + ((re * (re * re)) * (-0.16666666666666666d0))
else
tmp = re * (1.0d0 + (im * (0.5d0 * im)))
end if
code = tmp
end function
public static double code(double re, double im) {
double tmp;
if ((re <= -3.6e+60) || !(re <= 1.8e+91)) {
tmp = re + ((re * (re * re)) * -0.16666666666666666);
} else {
tmp = re * (1.0 + (im * (0.5 * im)));
}
return tmp;
}
def code(re, im): tmp = 0 if (re <= -3.6e+60) or not (re <= 1.8e+91): tmp = re + ((re * (re * re)) * -0.16666666666666666) else: tmp = re * (1.0 + (im * (0.5 * im))) return tmp
function code(re, im) tmp = 0.0 if ((re <= -3.6e+60) || !(re <= 1.8e+91)) tmp = Float64(re + Float64(Float64(re * Float64(re * re)) * -0.16666666666666666)); else tmp = Float64(re * Float64(1.0 + Float64(im * Float64(0.5 * im)))); end return tmp end
function tmp_2 = code(re, im) tmp = 0.0; if ((re <= -3.6e+60) || ~((re <= 1.8e+91))) tmp = re + ((re * (re * re)) * -0.16666666666666666); else tmp = re * (1.0 + (im * (0.5 * im))); end tmp_2 = tmp; end
code[re_, im_] := If[Or[LessEqual[re, -3.6e+60], N[Not[LessEqual[re, 1.8e+91]], $MachinePrecision]], N[(re + N[(N[(re * N[(re * re), $MachinePrecision]), $MachinePrecision] * -0.16666666666666666), $MachinePrecision]), $MachinePrecision], N[(re * N[(1.0 + N[(im * N[(0.5 * im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;re \leq -3.6 \cdot 10^{+60} \lor \neg \left(re \leq 1.8 \cdot 10^{+91}\right):\\
\;\;\;\;re + \left(re \cdot \left(re \cdot re\right)\right) \cdot -0.16666666666666666\\
\mathbf{else}:\\
\;\;\;\;re \cdot \left(1 + im \cdot \left(0.5 \cdot im\right)\right)\\
\end{array}
\end{array}
if re < -3.59999999999999968e60 or 1.8e91 < re Initial program 100.0%
distribute-lft-in100.0%
cancel-sign-sub100.0%
distribute-rgt-neg-out100.0%
sin-neg100.0%
*-commutative100.0%
sin-neg100.0%
distribute-rgt-neg-out100.0%
neg-mul-1100.0%
associate-*r*100.0%
*-commutative100.0%
distribute-lft-out--100.0%
sub-neg100.0%
neg-sub0100.0%
Simplified100.0%
Taylor expanded in im around 0 54.6%
Taylor expanded in re around 0 27.9%
*-commutative27.9%
Simplified27.9%
unpow327.9%
Applied egg-rr27.9%
if -3.59999999999999968e60 < re < 1.8e91Initial program 99.4%
distribute-lft-in99.4%
cancel-sign-sub99.4%
distribute-rgt-neg-out99.4%
sin-neg99.4%
*-commutative99.4%
sin-neg99.4%
distribute-rgt-neg-out99.4%
neg-mul-199.4%
associate-*r*99.4%
*-commutative99.4%
distribute-lft-out--99.4%
sub-neg99.4%
neg-sub099.4%
Simplified99.4%
Taylor expanded in im around 0 79.0%
*-lft-identity79.0%
associate-*r*79.0%
distribute-rgt-out79.0%
unpow279.0%
associate-*r*79.0%
Simplified79.0%
Taylor expanded in re around 0 66.8%
Final simplification53.0%
(FPCore (re im) :precision binary64 (* re (+ 1.0 (* im (* 0.5 im)))))
double code(double re, double im) {
return re * (1.0 + (im * (0.5 * im)));
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
code = re * (1.0d0 + (im * (0.5d0 * im)))
end function
public static double code(double re, double im) {
return re * (1.0 + (im * (0.5 * im)));
}
def code(re, im): return re * (1.0 + (im * (0.5 * im)))
function code(re, im) return Float64(re * Float64(1.0 + Float64(im * Float64(0.5 * im)))) end
function tmp = code(re, im) tmp = re * (1.0 + (im * (0.5 * im))); end
code[re_, im_] := N[(re * N[(1.0 + N[(im * N[(0.5 * im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
re \cdot \left(1 + im \cdot \left(0.5 \cdot im\right)\right)
\end{array}
Initial program 99.6%
distribute-lft-in99.6%
cancel-sign-sub99.6%
distribute-rgt-neg-out99.6%
sin-neg99.6%
*-commutative99.6%
sin-neg99.6%
distribute-rgt-neg-out99.6%
neg-mul-199.6%
associate-*r*99.6%
*-commutative99.6%
distribute-lft-out--99.6%
sub-neg99.6%
neg-sub099.6%
Simplified99.6%
Taylor expanded in im around 0 79.3%
*-lft-identity79.3%
associate-*r*79.3%
distribute-rgt-out79.3%
unpow279.3%
associate-*r*79.3%
Simplified79.3%
Taylor expanded in re around 0 47.9%
Final simplification47.9%
(FPCore (re im) :precision binary64 (if (<= im 0.0105) re (* re (* im im))))
double code(double re, double im) {
double tmp;
if (im <= 0.0105) {
tmp = re;
} else {
tmp = re * (im * im);
}
return tmp;
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
real(8) :: tmp
if (im <= 0.0105d0) then
tmp = re
else
tmp = re * (im * im)
end if
code = tmp
end function
public static double code(double re, double im) {
double tmp;
if (im <= 0.0105) {
tmp = re;
} else {
tmp = re * (im * im);
}
return tmp;
}
def code(re, im): tmp = 0 if im <= 0.0105: tmp = re else: tmp = re * (im * im) return tmp
function code(re, im) tmp = 0.0 if (im <= 0.0105) tmp = re; else tmp = Float64(re * Float64(im * im)); end return tmp end
function tmp_2 = code(re, im) tmp = 0.0; if (im <= 0.0105) tmp = re; else tmp = re * (im * im); end tmp_2 = tmp; end
code[re_, im_] := If[LessEqual[im, 0.0105], re, N[(re * N[(im * im), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;im \leq 0.0105:\\
\;\;\;\;re\\
\mathbf{else}:\\
\;\;\;\;re \cdot \left(im \cdot im\right)\\
\end{array}
\end{array}
if im < 0.0105000000000000007Initial program 99.5%
distribute-lft-in99.5%
cancel-sign-sub99.5%
distribute-rgt-neg-out99.5%
sin-neg99.5%
*-commutative99.5%
sin-neg99.5%
distribute-rgt-neg-out99.5%
neg-mul-199.5%
associate-*r*99.5%
*-commutative99.5%
distribute-lft-out--99.5%
sub-neg99.5%
neg-sub099.5%
Simplified99.5%
Taylor expanded in re around 0 55.8%
Taylor expanded in im around 0 32.9%
if 0.0105000000000000007 < im Initial program 100.0%
distribute-lft-in100.0%
cancel-sign-sub100.0%
distribute-rgt-neg-out100.0%
sin-neg100.0%
*-commutative100.0%
sin-neg100.0%
distribute-rgt-neg-out100.0%
neg-mul-1100.0%
associate-*r*100.0%
*-commutative100.0%
distribute-lft-out--100.0%
sub-neg100.0%
neg-sub0100.0%
Simplified100.0%
Taylor expanded in im around 0 62.5%
*-lft-identity62.5%
associate-*r*62.5%
distribute-rgt-out62.5%
unpow262.5%
associate-*r*62.5%
Simplified62.5%
Applied egg-rr61.7%
Taylor expanded in re around 0 49.5%
Taylor expanded in im around inf 49.5%
*-commutative49.5%
unpow249.5%
Simplified49.5%
Final simplification36.9%
(FPCore (re im) :precision binary64 -3.0)
double code(double re, double im) {
return -3.0;
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
code = -3.0d0
end function
public static double code(double re, double im) {
return -3.0;
}
def code(re, im): return -3.0
function code(re, im) return -3.0 end
function tmp = code(re, im) tmp = -3.0; end
code[re_, im_] := -3.0
\begin{array}{l}
\\
-3
\end{array}
Initial program 99.6%
distribute-lft-in99.6%
cancel-sign-sub99.6%
distribute-rgt-neg-out99.6%
sin-neg99.6%
*-commutative99.6%
sin-neg99.6%
distribute-rgt-neg-out99.6%
neg-mul-199.6%
associate-*r*99.6%
*-commutative99.6%
distribute-lft-out--99.6%
sub-neg99.6%
neg-sub099.6%
Simplified99.6%
Applied egg-rr3.9%
Taylor expanded in re around 0 3.9%
Final simplification3.9%
(FPCore (re im) :precision binary64 re)
double code(double re, double im) {
return re;
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
code = re
end function
public static double code(double re, double im) {
return re;
}
def code(re, im): return re
function code(re, im) return re end
function tmp = code(re, im) tmp = re; end
code[re_, im_] := re
\begin{array}{l}
\\
re
\end{array}
Initial program 99.6%
distribute-lft-in99.6%
cancel-sign-sub99.6%
distribute-rgt-neg-out99.6%
sin-neg99.6%
*-commutative99.6%
sin-neg99.6%
distribute-rgt-neg-out99.6%
neg-mul-199.6%
associate-*r*99.6%
*-commutative99.6%
distribute-lft-out--99.6%
sub-neg99.6%
neg-sub099.6%
Simplified99.6%
Taylor expanded in re around 0 60.7%
Taylor expanded in im around 0 25.5%
Final simplification25.5%
herbie shell --seed 2023297
(FPCore (re im)
:name "math.sin on complex, real part"
:precision binary64
(* (* 0.5 (sin re)) (+ (exp (- 0.0 im)) (exp im))))