math.sin on complex, imaginary part

Percentage Accurate: 54.0% → 99.9%

Time: 3.9s

Alternatives: 6

Speedup: 4.2×

• 50.2% of points produce a very large (infinite) output. You may want to add a precondition.

• Could not converge on a ground truth

  1. re = +nan.0
  2. im = 2.764749691375634e-223

Specification

Math

\[\left(0.5 \cdot \cos re\right) \cdot \left(e^{0 - im} - e^{im}\right) \]

FPCore

(FPCore (re im)
  :precision binary64
  (* (* 0.5 (cos re)) (- (exp (- 0.0 im)) (exp im))))

C

double code(double re, double im) {
	return (0.5 * cos(re)) * (exp((0.0 - im)) - exp(im));
}

Fortran

real(8) function code(re, im)
use fmin_fmax_functions
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    code = (0.5d0 * cos(re)) * (exp((0.0d0 - im)) - exp(im))
end function

Java

public static double code(double re, double im) {
	return (0.5 * Math.cos(re)) * (Math.exp((0.0 - im)) - Math.exp(im));
}

Python

def code(re, im):
	return (0.5 * math.cos(re)) * (math.exp((0.0 - im)) - math.exp(im))

Julia

function code(re, im)
	return Float64(Float64(0.5 * cos(re)) * Float64(exp(Float64(0.0 - im)) - exp(im)))
end

MATLAB

function tmp = code(re, im)
	tmp = (0.5 * cos(re)) * (exp((0.0 - im)) - exp(im));
end

Wolfram

code[re_, im_] := N[(N[(0.5 * N[Cos[re], $MachinePrecision]), $MachinePrecision] * N[(N[Exp[N[(0.0 - im), $MachinePrecision]], $MachinePrecision] - N[Exp[im], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Initial Program: 54.0% accurate, 1.0× speedup

Math

\[\left(0.5 \cdot \cos re\right) \cdot \left(e^{0 - im} - e^{im}\right) \]

FPCore

(FPCore (re im)
  :precision binary64
  (* (* 0.5 (cos re)) (- (exp (- 0.0 im)) (exp im))))

C

double code(double re, double im) {
	return (0.5 * cos(re)) * (exp((0.0 - im)) - exp(im));
}

Fortran

real(8) function code(re, im)
use fmin_fmax_functions
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    code = (0.5d0 * cos(re)) * (exp((0.0d0 - im)) - exp(im))
end function

Java

public static double code(double re, double im) {
	return (0.5 * Math.cos(re)) * (Math.exp((0.0 - im)) - Math.exp(im));
}

Python

def code(re, im):
	return (0.5 * math.cos(re)) * (math.exp((0.0 - im)) - math.exp(im))

Julia

function code(re, im)
	return Float64(Float64(0.5 * cos(re)) * Float64(exp(Float64(0.0 - im)) - exp(im)))
end

MATLAB

function tmp = code(re, im)
	tmp = (0.5 * cos(re)) * (exp((0.0 - im)) - exp(im));
end

Wolfram

code[re_, im_] := N[(N[(0.5 * N[Cos[re], $MachinePrecision]), $MachinePrecision] * N[(N[Exp[N[(0.0 - im), $MachinePrecision]], $MachinePrecision] - N[Exp[im], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Alternative 1: 99.9% accurate, 1.3× speedup

Math

\[\sinh \left(-im\right) \cdot \cos re \]

FPCore

(FPCore (re im)
  :precision binary64
  (* (sinh (- im)) (cos re)))

C

double code(double re, double im) {
	return sinh(-im) * cos(re);
}

Fortran

real(8) function code(re, im)
use fmin_fmax_functions
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    code = sinh(-im) * cos(re)
end function

Java

public static double code(double re, double im) {
	return Math.sinh(-im) * Math.cos(re);
}

Python

def code(re, im):
	return math.sinh(-im) * math.cos(re)

Julia

function code(re, im)
	return Float64(sinh(Float64(-im)) * cos(re))
end

MATLAB

function tmp = code(re, im)
	tmp = sinh(-im) * cos(re);
end

Wolfram

code[re_, im_] := N[(N[Sinh[(-im)], $MachinePrecision] * N[Cos[re], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 54.0%

   \[\left(0.5 \cdot \cos re\right) \cdot \left(e^{0 - im} - e^{im}\right) \]
2. Step-by-step derivation

   1. lift-*.f64 N/A

      \[\leadsto \color{blue}{\left(\frac{1}{2} \cdot \cos re\right) \cdot \left(e^{0 - im} - e^{im}\right)} \]

   2. *-commutative N/A

      \[\leadsto \color{blue}{\left(e^{0 - im} - e^{im}\right) \cdot \left(\frac{1}{2} \cdot \cos re\right)} \]

   3. lift-*.f64 N/A

      \[\leadsto \left(e^{0 - im} - e^{im}\right) \cdot \color{blue}{\left(\frac{1}{2} \cdot \cos re\right)} \]

   4. associate-*r* N/A

      \[\leadsto \color{blue}{\left(\left(e^{0 - im} - e^{im}\right) \cdot \frac{1}{2}\right) \cdot \cos re} \]

   5. metadata-eval N/A

      \[\leadsto \left(\left(e^{0 - im} - e^{im}\right) \cdot \color{blue}{\frac{1}{2}}\right) \cdot \cos re \]

   6. mult-flip-rev N/A

      \[\leadsto \color{blue}{\frac{e^{0 - im} - e^{im}}{2}} \cdot \cos re \]

   7. lift--.f64 N/A

      \[\leadsto \frac{\color{blue}{e^{0 - im} - e^{im}}}{2} \cdot \cos re \]

   8. lift-exp.f64 N/A

      \[\leadsto \frac{\color{blue}{e^{0 - im}} - e^{im}}{2} \cdot \cos re \]

   9. lift-exp.f64 N/A

      \[\leadsto \frac{e^{0 - im} - \color{blue}{e^{im}}}{2} \cdot \cos re \]

   10. --rgt-identity N/A

       \[\leadsto \frac{e^{0 - im} - e^{\color{blue}{im - 0}}}{2} \cdot \cos re \]

   11. sub-negate-rev N/A

       \[\leadsto \frac{e^{0 - im} - e^{\color{blue}{\mathsf{neg}\left(\left(0 - im\right)\right)}}}{2} \cdot \cos re \]

   12. lift--.f64 N/A

       \[\leadsto \frac{e^{0 - im} - e^{\mathsf{neg}\left(\color{blue}{\left(0 - im\right)}\right)}}{2} \cdot \cos re \]

   13. sinh-def N/A

       \[\leadsto \color{blue}{\sinh \left(0 - im\right)} \cdot \cos re \]

   14. lower-*.f64 N/A

       \[\leadsto \color{blue}{\sinh \left(0 - im\right) \cdot \cos re} \]

   15. lower-sinh.f64 99.9%

       \[\leadsto \color{blue}{\sinh \left(0 - im\right)} \cdot \cos re \]

   16. lift--.f64 N/A

       \[\leadsto \sinh \color{blue}{\left(0 - im\right)} \cdot \cos re \]

   17. sub0-neg N/A

       \[\leadsto \sinh \color{blue}{\left(\mathsf{neg}\left(im\right)\right)} \cdot \cos re \]

   18. lower-neg.f64 99.9%

       \[\leadsto \sinh \color{blue}{\left(-im\right)} \cdot \cos re \]

3. Applied rewrites 99.9%

   \[\leadsto \color{blue}{\sinh \left(-im\right) \cdot \cos re} \]
4. Add Preprocessing

Alternative 2: 99.4% accurate, 0.4× speedup

Math

\[\begin{array}{l} t_0 := \sinh \left(-\left|im\right|\right)\\ t_1 := \left(0.5 \cdot \cos re\right) \cdot \left(e^{0 - \left|im\right|} - e^{\left|im\right|}\right)\\ \mathsf{copysign}\left(1, im\right) \cdot \begin{array}{l} \mathbf{if}\;t\_1 \leq -0.0005:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;t\_1 \leq 10^{-8}:\\ \;\;\;\;\left(-\cos re\right) \cdot \left|im\right|\\ \mathbf{else}:\\ \;\;\;\;t\_0 \cdot \left(1 + -0.5 \cdot {re}^{2}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (re im)
  :precision binary64
  (let* ((t_0 (sinh (- (fabs im))))
       (t_1
        (*
         (* 0.5 (cos re))
         (- (exp (- 0.0 (fabs im))) (exp (fabs im))))))
  (*
   (copysign 1.0 im)
   (if (<= t_1 -0.0005)
     t_0
     (if (<= t_1 1e-8)
       (* (- (cos re)) (fabs im))
       (* t_0 (+ 1.0 (* -0.5 (pow re 2.0)))))))))

C

double code(double re, double im) {
	double t_0 = sinh(-fabs(im));
	double t_1 = (0.5 * cos(re)) * (exp((0.0 - fabs(im))) - exp(fabs(im)));
	double tmp;
	if (t_1 <= -0.0005) {
		tmp = t_0;
	} else if (t_1 <= 1e-8) {
		tmp = -cos(re) * fabs(im);
	} else {
		tmp = t_0 * (1.0 + (-0.5 * pow(re, 2.0)));
	}
	return copysign(1.0, im) * tmp;
}

Java

public static double code(double re, double im) {
	double t_0 = Math.sinh(-Math.abs(im));
	double t_1 = (0.5 * Math.cos(re)) * (Math.exp((0.0 - Math.abs(im))) - Math.exp(Math.abs(im)));
	double tmp;
	if (t_1 <= -0.0005) {
		tmp = t_0;
	} else if (t_1 <= 1e-8) {
		tmp = -Math.cos(re) * Math.abs(im);
	} else {
		tmp = t_0 * (1.0 + (-0.5 * Math.pow(re, 2.0)));
	}
	return Math.copySign(1.0, im) * tmp;
}

Python

def code(re, im):
	t_0 = math.sinh(-math.fabs(im))
	t_1 = (0.5 * math.cos(re)) * (math.exp((0.0 - math.fabs(im))) - math.exp(math.fabs(im)))
	tmp = 0
	if t_1 <= -0.0005:
		tmp = t_0
	elif t_1 <= 1e-8:
		tmp = -math.cos(re) * math.fabs(im)
	else:
		tmp = t_0 * (1.0 + (-0.5 * math.pow(re, 2.0)))
	return math.copysign(1.0, im) * tmp

Julia

function code(re, im)
	t_0 = sinh(Float64(-abs(im)))
	t_1 = Float64(Float64(0.5 * cos(re)) * Float64(exp(Float64(0.0 - abs(im))) - exp(abs(im))))
	tmp = 0.0
	if (t_1 <= -0.0005)
		tmp = t_0;
	elseif (t_1 <= 1e-8)
		tmp = Float64(Float64(-cos(re)) * abs(im));
	else
		tmp = Float64(t_0 * Float64(1.0 + Float64(-0.5 * (re ^ 2.0))));
	end
	return Float64(copysign(1.0, im) * tmp)
end

MATLAB

function tmp_2 = code(re, im)
	t_0 = sinh(-abs(im));
	t_1 = (0.5 * cos(re)) * (exp((0.0 - abs(im))) - exp(abs(im)));
	tmp = 0.0;
	if (t_1 <= -0.0005)
		tmp = t_0;
	elseif (t_1 <= 1e-8)
		tmp = -cos(re) * abs(im);
	else
		tmp = t_0 * (1.0 + (-0.5 * (re ^ 2.0)));
	end
	tmp_2 = (sign(im) * abs(1.0)) * tmp;
end

Wolfram

code[re_, im_] := Block[{t$95$0 = N[Sinh[(-N[Abs[im], $MachinePrecision])], $MachinePrecision]}, Block[{t$95$1 = N[(N[(0.5 * N[Cos[re], $MachinePrecision]), $MachinePrecision] * N[(N[Exp[N[(0.0 - N[Abs[im], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - N[Exp[N[Abs[im], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$1, -0.0005], t$95$0, If[LessEqual[t$95$1, 1e-8], N[((-N[Cos[re], $MachinePrecision]) * N[Abs[im], $MachinePrecision]), $MachinePrecision], N[(t$95$0 * N[(1.0 + N[(-0.5 * N[Power[re, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if (*.f64 (*.f64 #s(literal 1/2 binary64) (cos.f64 re)) (-.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) < -5.0000000000000001e-4

   1. Initial program 54.0%

      \[\left(0.5 \cdot \cos re\right) \cdot \left(e^{0 - im} - e^{im}\right) \]

   2. Taylor expanded in re around 0

      \[\leadsto \color{blue}{\frac{1}{2} \cdot \left(e^{\mathsf{neg}\left(im\right)} - e^{im}\right)} \]
   3. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto \frac{1}{2} \cdot \color{blue}{\left(e^{\mathsf{neg}\left(im\right)} - e^{im}\right)} \]

      2. lower--.f64 N/A

         \[\leadsto \frac{1}{2} \cdot \left(e^{\mathsf{neg}\left(im\right)} - \color{blue}{e^{im}}\right) \]

      3. lower-exp.f64 N/A

         \[\leadsto \frac{1}{2} \cdot \left(e^{\mathsf{neg}\left(im\right)} - e^{\color{blue}{im}}\right) \]

      4. lower-neg.f64 N/A

         \[\leadsto \frac{1}{2} \cdot \left(e^{-im} - e^{im}\right) \]

      5. lower-exp.f64 40.9%

         \[\leadsto 0.5 \cdot \left(e^{-im} - e^{im}\right) \]

   4. Applied rewrites 40.9%

      \[\leadsto \color{blue}{0.5 \cdot \left(e^{-im} - e^{im}\right)} \]
   5. Step-by-step derivation

      1. lift-*.f64 N/A

         \[\leadsto \frac{1}{2} \cdot \color{blue}{\left(e^{-im} - e^{im}\right)} \]

      2. *-commutative N/A

         \[\leadsto \left(e^{-im} - e^{im}\right) \cdot \color{blue}{\frac{1}{2}} \]

      3. lift--.f64 N/A

         \[\leadsto \left(e^{-im} - e^{im}\right) \cdot \frac{1}{2} \]

      4. lift-exp.f64 N/A

         \[\leadsto \left(e^{-im} - e^{im}\right) \cdot \frac{1}{2} \]

      5. sinh-+-cosh-rev N/A

         \[\leadsto \left(e^{-im} - \left(\cosh im + \sinh im\right)\right) \cdot \frac{1}{2} \]

      6. lift-exp.f64 N/A

         \[\leadsto \left(e^{-im} - \left(\cosh im + \sinh im\right)\right) \cdot \frac{1}{2} \]

      7. sinh-+-cosh-rev N/A

         \[\leadsto \left(e^{-im} - e^{im}\right) \cdot \frac{1}{2} \]

      8. remove-double-neg N/A

         \[\leadsto \left(e^{-im} - e^{\mathsf{neg}\left(\left(\mathsf{neg}\left(im\right)\right)\right)}\right) \cdot \frac{1}{2} \]

      9. lift-neg.f64 N/A

         \[\leadsto \left(e^{-im} - e^{\mathsf{neg}\left(\left(-im\right)\right)}\right) \cdot \frac{1}{2} \]

      10. metadata-eval N/A

          \[\leadsto \left(e^{-im} - e^{\mathsf{neg}\left(\left(-im\right)\right)}\right) \cdot \frac{1}{\color{blue}{2}} \]

      11. mult-flip N/A

          \[\leadsto \frac{e^{-im} - e^{\mathsf{neg}\left(\left(-im\right)\right)}}{\color{blue}{2}} \]

      12. sinh-def N/A

          \[\leadsto \sinh \left(-im\right) \]

      13. lift-sinh.f64 65.7%

          \[\leadsto \sinh \left(-im\right) \]

   6. Applied rewrites 65.7%

      \[\leadsto \sinh \left(-im\right) \]

   if -5.0000000000000001e-4 < (*.f64 (*.f64 #s(literal 1/2 binary64) (cos.f64 re)) (-.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) < 1e-8

   1. Initial program 54.0%

      \[\left(0.5 \cdot \cos re\right) \cdot \left(e^{0 - im} - e^{im}\right) \]

   2. Taylor expanded in im around 0

      \[\leadsto \color{blue}{-1 \cdot \left(im \cdot \cos re\right)} \]
   3. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto -1 \cdot \color{blue}{\left(im \cdot \cos re\right)} \]

      2. lower-*.f64 N/A

         \[\leadsto -1 \cdot \left(im \cdot \color{blue}{\cos re}\right) \]

      3. lower-cos.f64 52.3%

         \[\leadsto -1 \cdot \left(im \cdot \cos re\right) \]

   4. Applied rewrites 52.3%

      \[\leadsto \color{blue}{-1 \cdot \left(im \cdot \cos re\right)} \]
   5. Step-by-step derivation

      1. lift-*.f64 N/A

         \[\leadsto -1 \cdot \color{blue}{\left(im \cdot \cos re\right)} \]

      2. mul-1-neg N/A

         \[\leadsto \mathsf{neg}\left(im \cdot \cos re\right) \]

      3. lift-*.f64 N/A

         \[\leadsto \mathsf{neg}\left(im \cdot \cos re\right) \]

      4. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\cos re \cdot im\right) \]

      5. distribute-lft-neg-in N/A

         \[\leadsto \left(\mathsf{neg}\left(\cos re\right)\right) \cdot \color{blue}{im} \]

      6. lower-*.f64 N/A

         \[\leadsto \left(\mathsf{neg}\left(\cos re\right)\right) \cdot \color{blue}{im} \]

      7. lower-neg.f64 52.3%

         \[\leadsto \left(-\cos re\right) \cdot im \]

   6. Applied rewrites 52.3%

      \[\leadsto \left(-\cos re\right) \cdot \color{blue}{im} \]

   if 1e-8 < (*.f64 (*.f64 #s(literal 1/2 binary64) (cos.f64 re)) (-.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))

   1. Initial program 54.0%

      \[\left(0.5 \cdot \cos re\right) \cdot \left(e^{0 - im} - e^{im}\right) \]
   2. Step-by-step derivation

      1. lift-*.f64 N/A

         \[\leadsto \color{blue}{\left(\frac{1}{2} \cdot \cos re\right) \cdot \left(e^{0 - im} - e^{im}\right)} \]

      2. *-commutative N/A

         \[\leadsto \color{blue}{\left(e^{0 - im} - e^{im}\right) \cdot \left(\frac{1}{2} \cdot \cos re\right)} \]

      3. lift-*.f64 N/A

         \[\leadsto \left(e^{0 - im} - e^{im}\right) \cdot \color{blue}{\left(\frac{1}{2} \cdot \cos re\right)} \]

      4. associate-*r* N/A

         \[\leadsto \color{blue}{\left(\left(e^{0 - im} - e^{im}\right) \cdot \frac{1}{2}\right) \cdot \cos re} \]

      5. metadata-eval N/A

         \[\leadsto \left(\left(e^{0 - im} - e^{im}\right) \cdot \color{blue}{\frac{1}{2}}\right) \cdot \cos re \]

      6. mult-flip-rev N/A

         \[\leadsto \color{blue}{\frac{e^{0 - im} - e^{im}}{2}} \cdot \cos re \]

      7. lift--.f64 N/A

         \[\leadsto \frac{\color{blue}{e^{0 - im} - e^{im}}}{2} \cdot \cos re \]

      8. lift-exp.f64 N/A

         \[\leadsto \frac{\color{blue}{e^{0 - im}} - e^{im}}{2} \cdot \cos re \]

      9. lift-exp.f64 N/A

         \[\leadsto \frac{e^{0 - im} - \color{blue}{e^{im}}}{2} \cdot \cos re \]

      10. --rgt-identity N/A

          \[\leadsto \frac{e^{0 - im} - e^{\color{blue}{im - 0}}}{2} \cdot \cos re \]

      11. sub-negate-rev N/A

          \[\leadsto \frac{e^{0 - im} - e^{\color{blue}{\mathsf{neg}\left(\left(0 - im\right)\right)}}}{2} \cdot \cos re \]

      12. lift--.f64 N/A

          \[\leadsto \frac{e^{0 - im} - e^{\mathsf{neg}\left(\color{blue}{\left(0 - im\right)}\right)}}{2} \cdot \cos re \]

      13. sinh-def N/A

          \[\leadsto \color{blue}{\sinh \left(0 - im\right)} \cdot \cos re \]

      14. lower-*.f64 N/A

          \[\leadsto \color{blue}{\sinh \left(0 - im\right) \cdot \cos re} \]

      15. lower-sinh.f64 99.9%

          \[\leadsto \color{blue}{\sinh \left(0 - im\right)} \cdot \cos re \]

      16. lift--.f64 N/A

          \[\leadsto \sinh \color{blue}{\left(0 - im\right)} \cdot \cos re \]

      17. sub0-neg N/A

          \[\leadsto \sinh \color{blue}{\left(\mathsf{neg}\left(im\right)\right)} \cdot \cos re \]

      18. lower-neg.f64 99.9%

          \[\leadsto \sinh \color{blue}{\left(-im\right)} \cdot \cos re \]

   3. Applied rewrites 99.9%

      \[\leadsto \color{blue}{\sinh \left(-im\right) \cdot \cos re} \]

   4. Taylor expanded in re around 0

      \[\leadsto \sinh \left(-im\right) \cdot \color{blue}{\left(1 + \frac{-1}{2} \cdot {re}^{2}\right)} \]
   5. Step-by-step derivation

      1. lower-+.f64 N/A

         \[\leadsto \sinh \left(-im\right) \cdot \left(1 + \color{blue}{\frac{-1}{2} \cdot {re}^{2}}\right) \]

      2. lower-*.f64 N/A

         \[\leadsto \sinh \left(-im\right) \cdot \left(1 + \frac{-1}{2} \cdot \color{blue}{{re}^{2}}\right) \]

      3. lower-pow.f64 63.6%

         \[\leadsto \sinh \left(-im\right) \cdot \left(1 + -0.5 \cdot {re}^{\color{blue}{2}}\right) \]

   6. Applied rewrites 63.6%

      \[\leadsto \sinh \left(-im\right) \cdot \color{blue}{\left(1 + -0.5 \cdot {re}^{2}\right)} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 3: 96.8% accurate, 0.4× speedup

Math

\[\begin{array}{l} t_0 := \left(0.5 \cdot \cos re\right) \cdot \left(e^{0 - \left|im\right|} - e^{\left|im\right|}\right)\\ \mathsf{copysign}\left(1, im\right) \cdot \begin{array}{l} \mathbf{if}\;t\_0 \leq -0.0005:\\ \;\;\;\;\sinh \left(-\left|im\right|\right)\\ \mathbf{elif}\;t\_0 \leq 10^{-8}:\\ \;\;\;\;\left(-\cos re\right) \cdot \left|im\right|\\ \mathbf{else}:\\ \;\;\;\;\left(0.5 \cdot {re}^{2} - 1\right) \cdot \left|im\right|\\ \end{array} \end{array} \]

FPCore

(FPCore (re im)
  :precision binary64
  (let* ((t_0
        (*
         (* 0.5 (cos re))
         (- (exp (- 0.0 (fabs im))) (exp (fabs im))))))
  (*
   (copysign 1.0 im)
   (if (<= t_0 -0.0005)
     (sinh (- (fabs im)))
     (if (<= t_0 1e-8)
       (* (- (cos re)) (fabs im))
       (* (- (* 0.5 (pow re 2.0)) 1.0) (fabs im)))))))

C

double code(double re, double im) {
	double t_0 = (0.5 * cos(re)) * (exp((0.0 - fabs(im))) - exp(fabs(im)));
	double tmp;
	if (t_0 <= -0.0005) {
		tmp = sinh(-fabs(im));
	} else if (t_0 <= 1e-8) {
		tmp = -cos(re) * fabs(im);
	} else {
		tmp = ((0.5 * pow(re, 2.0)) - 1.0) * fabs(im);
	}
	return copysign(1.0, im) * tmp;
}

Java

public static double code(double re, double im) {
	double t_0 = (0.5 * Math.cos(re)) * (Math.exp((0.0 - Math.abs(im))) - Math.exp(Math.abs(im)));
	double tmp;
	if (t_0 <= -0.0005) {
		tmp = Math.sinh(-Math.abs(im));
	} else if (t_0 <= 1e-8) {
		tmp = -Math.cos(re) * Math.abs(im);
	} else {
		tmp = ((0.5 * Math.pow(re, 2.0)) - 1.0) * Math.abs(im);
	}
	return Math.copySign(1.0, im) * tmp;
}

Python

def code(re, im):
	t_0 = (0.5 * math.cos(re)) * (math.exp((0.0 - math.fabs(im))) - math.exp(math.fabs(im)))
	tmp = 0
	if t_0 <= -0.0005:
		tmp = math.sinh(-math.fabs(im))
	elif t_0 <= 1e-8:
		tmp = -math.cos(re) * math.fabs(im)
	else:
		tmp = ((0.5 * math.pow(re, 2.0)) - 1.0) * math.fabs(im)
	return math.copysign(1.0, im) * tmp

Julia

function code(re, im)
	t_0 = Float64(Float64(0.5 * cos(re)) * Float64(exp(Float64(0.0 - abs(im))) - exp(abs(im))))
	tmp = 0.0
	if (t_0 <= -0.0005)
		tmp = sinh(Float64(-abs(im)));
	elseif (t_0 <= 1e-8)
		tmp = Float64(Float64(-cos(re)) * abs(im));
	else
		tmp = Float64(Float64(Float64(0.5 * (re ^ 2.0)) - 1.0) * abs(im));
	end
	return Float64(copysign(1.0, im) * tmp)
end

MATLAB

function tmp_2 = code(re, im)
	t_0 = (0.5 * cos(re)) * (exp((0.0 - abs(im))) - exp(abs(im)));
	tmp = 0.0;
	if (t_0 <= -0.0005)
		tmp = sinh(-abs(im));
	elseif (t_0 <= 1e-8)
		tmp = -cos(re) * abs(im);
	else
		tmp = ((0.5 * (re ^ 2.0)) - 1.0) * abs(im);
	end
	tmp_2 = (sign(im) * abs(1.0)) * tmp;
end

Wolfram

code[re_, im_] := Block[{t$95$0 = N[(N[(0.5 * N[Cos[re], $MachinePrecision]), $MachinePrecision] * N[(N[Exp[N[(0.0 - N[Abs[im], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - N[Exp[N[Abs[im], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$0, -0.0005], N[Sinh[(-N[Abs[im], $MachinePrecision])], $MachinePrecision], If[LessEqual[t$95$0, 1e-8], N[((-N[Cos[re], $MachinePrecision]) * N[Abs[im], $MachinePrecision]), $MachinePrecision], N[(N[(N[(0.5 * N[Power[re, 2.0], $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision] * N[Abs[im], $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]

Derivation

1. Split input into 3 regimes

2. if (*.f64 (*.f64 #s(literal 1/2 binary64) (cos.f64 re)) (-.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) < -5.0000000000000001e-4

   1. Initial program 54.0%

      \[\left(0.5 \cdot \cos re\right) \cdot \left(e^{0 - im} - e^{im}\right) \]

   2. Taylor expanded in re around 0

      \[\leadsto \color{blue}{\frac{1}{2} \cdot \left(e^{\mathsf{neg}\left(im\right)} - e^{im}\right)} \]
   3. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto \frac{1}{2} \cdot \color{blue}{\left(e^{\mathsf{neg}\left(im\right)} - e^{im}\right)} \]

      2. lower--.f64 N/A

         \[\leadsto \frac{1}{2} \cdot \left(e^{\mathsf{neg}\left(im\right)} - \color{blue}{e^{im}}\right) \]

      3. lower-exp.f64 N/A

         \[\leadsto \frac{1}{2} \cdot \left(e^{\mathsf{neg}\left(im\right)} - e^{\color{blue}{im}}\right) \]

      4. lower-neg.f64 N/A

         \[\leadsto \frac{1}{2} \cdot \left(e^{-im} - e^{im}\right) \]

      5. lower-exp.f64 40.9%

         \[\leadsto 0.5 \cdot \left(e^{-im} - e^{im}\right) \]

   4. Applied rewrites 40.9%

      \[\leadsto \color{blue}{0.5 \cdot \left(e^{-im} - e^{im}\right)} \]
   5. Step-by-step derivation

      1. lift-*.f64 N/A

         \[\leadsto \frac{1}{2} \cdot \color{blue}{\left(e^{-im} - e^{im}\right)} \]

      2. *-commutative N/A

         \[\leadsto \left(e^{-im} - e^{im}\right) \cdot \color{blue}{\frac{1}{2}} \]

      3. lift--.f64 N/A

         \[\leadsto \left(e^{-im} - e^{im}\right) \cdot \frac{1}{2} \]

      4. lift-exp.f64 N/A

         \[\leadsto \left(e^{-im} - e^{im}\right) \cdot \frac{1}{2} \]

      5. sinh-+-cosh-rev N/A

         \[\leadsto \left(e^{-im} - \left(\cosh im + \sinh im\right)\right) \cdot \frac{1}{2} \]

      6. lift-exp.f64 N/A

         \[\leadsto \left(e^{-im} - \left(\cosh im + \sinh im\right)\right) \cdot \frac{1}{2} \]

      7. sinh-+-cosh-rev N/A

         \[\leadsto \left(e^{-im} - e^{im}\right) \cdot \frac{1}{2} \]

      8. remove-double-neg N/A

         \[\leadsto \left(e^{-im} - e^{\mathsf{neg}\left(\left(\mathsf{neg}\left(im\right)\right)\right)}\right) \cdot \frac{1}{2} \]

      9. lift-neg.f64 N/A

         \[\leadsto \left(e^{-im} - e^{\mathsf{neg}\left(\left(-im\right)\right)}\right) \cdot \frac{1}{2} \]

      10. metadata-eval N/A

          \[\leadsto \left(e^{-im} - e^{\mathsf{neg}\left(\left(-im\right)\right)}\right) \cdot \frac{1}{\color{blue}{2}} \]

      11. mult-flip N/A

          \[\leadsto \frac{e^{-im} - e^{\mathsf{neg}\left(\left(-im\right)\right)}}{\color{blue}{2}} \]

      12. sinh-def N/A

          \[\leadsto \sinh \left(-im\right) \]

      13. lift-sinh.f64 65.7%

          \[\leadsto \sinh \left(-im\right) \]

   6. Applied rewrites 65.7%

      \[\leadsto \sinh \left(-im\right) \]

   if -5.0000000000000001e-4 < (*.f64 (*.f64 #s(literal 1/2 binary64) (cos.f64 re)) (-.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) < 1e-8

   1. Initial program 54.0%

      \[\left(0.5 \cdot \cos re\right) \cdot \left(e^{0 - im} - e^{im}\right) \]

   2. Taylor expanded in im around 0

      \[\leadsto \color{blue}{-1 \cdot \left(im \cdot \cos re\right)} \]
   3. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto -1 \cdot \color{blue}{\left(im \cdot \cos re\right)} \]

      2. lower-*.f64 N/A

         \[\leadsto -1 \cdot \left(im \cdot \color{blue}{\cos re}\right) \]

      3. lower-cos.f64 52.3%

         \[\leadsto -1 \cdot \left(im \cdot \cos re\right) \]

   4. Applied rewrites 52.3%

      \[\leadsto \color{blue}{-1 \cdot \left(im \cdot \cos re\right)} \]
   5. Step-by-step derivation

      1. lift-*.f64 N/A

         \[\leadsto -1 \cdot \color{blue}{\left(im \cdot \cos re\right)} \]

      2. mul-1-neg N/A

         \[\leadsto \mathsf{neg}\left(im \cdot \cos re\right) \]

      3. lift-*.f64 N/A

         \[\leadsto \mathsf{neg}\left(im \cdot \cos re\right) \]

      4. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\cos re \cdot im\right) \]

      5. distribute-lft-neg-in N/A

         \[\leadsto \left(\mathsf{neg}\left(\cos re\right)\right) \cdot \color{blue}{im} \]

      6. lower-*.f64 N/A

         \[\leadsto \left(\mathsf{neg}\left(\cos re\right)\right) \cdot \color{blue}{im} \]

      7. lower-neg.f64 52.3%

         \[\leadsto \left(-\cos re\right) \cdot im \]

   6. Applied rewrites 52.3%

      \[\leadsto \left(-\cos re\right) \cdot \color{blue}{im} \]

   if 1e-8 < (*.f64 (*.f64 #s(literal 1/2 binary64) (cos.f64 re)) (-.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))

   1. Initial program 54.0%

      \[\left(0.5 \cdot \cos re\right) \cdot \left(e^{0 - im} - e^{im}\right) \]

   2. Taylor expanded in im around 0

      \[\leadsto \color{blue}{-1 \cdot \left(im \cdot \cos re\right)} \]
   3. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto -1 \cdot \color{blue}{\left(im \cdot \cos re\right)} \]

      2. lower-*.f64 N/A

         \[\leadsto -1 \cdot \left(im \cdot \color{blue}{\cos re}\right) \]

      3. lower-cos.f64 52.3%

         \[\leadsto -1 \cdot \left(im \cdot \cos re\right) \]

   4. Applied rewrites 52.3%

      \[\leadsto \color{blue}{-1 \cdot \left(im \cdot \cos re\right)} \]
   5. Step-by-step derivation

      1. lift-*.f64 N/A

         \[\leadsto -1 \cdot \color{blue}{\left(im \cdot \cos re\right)} \]

      2. mul-1-neg N/A

         \[\leadsto \mathsf{neg}\left(im \cdot \cos re\right) \]

      3. lift-*.f64 N/A

         \[\leadsto \mathsf{neg}\left(im \cdot \cos re\right) \]

      4. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\cos re \cdot im\right) \]

      5. distribute-lft-neg-in N/A

         \[\leadsto \left(\mathsf{neg}\left(\cos re\right)\right) \cdot \color{blue}{im} \]

      6. lower-*.f64 N/A

         \[\leadsto \left(\mathsf{neg}\left(\cos re\right)\right) \cdot \color{blue}{im} \]

      7. lower-neg.f64 52.3%

         \[\leadsto \left(-\cos re\right) \cdot im \]

   6. Applied rewrites 52.3%

      \[\leadsto \left(-\cos re\right) \cdot \color{blue}{im} \]

   7. Taylor expanded in re around 0

      \[\leadsto \left(\frac{1}{2} \cdot {re}^{2} - 1\right) \cdot im \]
   8. Step-by-step derivation

      1. lower--.f64 N/A

         \[\leadsto \left(\frac{1}{2} \cdot {re}^{2} - 1\right) \cdot im \]

      2. lower-*.f64 N/A

         \[\leadsto \left(\frac{1}{2} \cdot {re}^{2} - 1\right) \cdot im \]

      3. lower-pow.f64 36.8%

         \[\leadsto \left(0.5 \cdot {re}^{2} - 1\right) \cdot im \]

   9. Applied rewrites 36.8%

      \[\leadsto \left(0.5 \cdot {re}^{2} - 1\right) \cdot im \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 4: 75.4% accurate, 0.6× speedup

Math

\[\mathsf{copysign}\left(1, im\right) \cdot \begin{array}{l} \mathbf{if}\;\left(0.5 \cdot \cos re\right) \cdot \left(e^{0 - \left|im\right|} - e^{\left|im\right|}\right) \leq 0:\\ \;\;\;\;\sinh \left(-\left|im\right|\right)\\ \mathbf{else}:\\ \;\;\;\;\left(0.5 \cdot {re}^{2} - 1\right) \cdot \left|im\right|\\ \end{array} \]

FPCore

(FPCore (re im)
  :precision binary64
  (*
 (copysign 1.0 im)
 (if (<=
      (* (* 0.5 (cos re)) (- (exp (- 0.0 (fabs im))) (exp (fabs im))))
      0.0)
   (sinh (- (fabs im)))
   (* (- (* 0.5 (pow re 2.0)) 1.0) (fabs im)))))

C

double code(double re, double im) {
	double tmp;
	if (((0.5 * cos(re)) * (exp((0.0 - fabs(im))) - exp(fabs(im)))) <= 0.0) {
		tmp = sinh(-fabs(im));
	} else {
		tmp = ((0.5 * pow(re, 2.0)) - 1.0) * fabs(im);
	}
	return copysign(1.0, im) * tmp;
}

Java

public static double code(double re, double im) {
	double tmp;
	if (((0.5 * Math.cos(re)) * (Math.exp((0.0 - Math.abs(im))) - Math.exp(Math.abs(im)))) <= 0.0) {
		tmp = Math.sinh(-Math.abs(im));
	} else {
		tmp = ((0.5 * Math.pow(re, 2.0)) - 1.0) * Math.abs(im);
	}
	return Math.copySign(1.0, im) * tmp;
}

Python

def code(re, im):
	tmp = 0
	if ((0.5 * math.cos(re)) * (math.exp((0.0 - math.fabs(im))) - math.exp(math.fabs(im)))) <= 0.0:
		tmp = math.sinh(-math.fabs(im))
	else:
		tmp = ((0.5 * math.pow(re, 2.0)) - 1.0) * math.fabs(im)
	return math.copysign(1.0, im) * tmp

Julia

function code(re, im)
	tmp = 0.0
	if (Float64(Float64(0.5 * cos(re)) * Float64(exp(Float64(0.0 - abs(im))) - exp(abs(im)))) <= 0.0)
		tmp = sinh(Float64(-abs(im)));
	else
		tmp = Float64(Float64(Float64(0.5 * (re ^ 2.0)) - 1.0) * abs(im));
	end
	return Float64(copysign(1.0, im) * tmp)
end

MATLAB

function tmp_2 = code(re, im)
	tmp = 0.0;
	if (((0.5 * cos(re)) * (exp((0.0 - abs(im))) - exp(abs(im)))) <= 0.0)
		tmp = sinh(-abs(im));
	else
		tmp = ((0.5 * (re ^ 2.0)) - 1.0) * abs(im);
	end
	tmp_2 = (sign(im) * abs(1.0)) * tmp;
end

Wolfram

code[re_, im_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[im]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[(N[(0.5 * N[Cos[re], $MachinePrecision]), $MachinePrecision] * N[(N[Exp[N[(0.0 - N[Abs[im], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - N[Exp[N[Abs[im], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.0], N[Sinh[(-N[Abs[im], $MachinePrecision])], $MachinePrecision], N[(N[(N[(0.5 * N[Power[re, 2.0], $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision] * N[Abs[im], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

1. Split input into 2 regimes

2. if (*.f64 (*.f64 #s(literal 1/2 binary64) (cos.f64 re)) (-.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) < 0.0

   1. Initial program 54.0%

      \[\left(0.5 \cdot \cos re\right) \cdot \left(e^{0 - im} - e^{im}\right) \]

   2. Taylor expanded in re around 0

      \[\leadsto \color{blue}{\frac{1}{2} \cdot \left(e^{\mathsf{neg}\left(im\right)} - e^{im}\right)} \]
   3. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto \frac{1}{2} \cdot \color{blue}{\left(e^{\mathsf{neg}\left(im\right)} - e^{im}\right)} \]

      2. lower--.f64 N/A

         \[\leadsto \frac{1}{2} \cdot \left(e^{\mathsf{neg}\left(im\right)} - \color{blue}{e^{im}}\right) \]

      3. lower-exp.f64 N/A

         \[\leadsto \frac{1}{2} \cdot \left(e^{\mathsf{neg}\left(im\right)} - e^{\color{blue}{im}}\right) \]

      4. lower-neg.f64 N/A

         \[\leadsto \frac{1}{2} \cdot \left(e^{-im} - e^{im}\right) \]

      5. lower-exp.f64 40.9%

         \[\leadsto 0.5 \cdot \left(e^{-im} - e^{im}\right) \]

   4. Applied rewrites 40.9%

      \[\leadsto \color{blue}{0.5 \cdot \left(e^{-im} - e^{im}\right)} \]
   5. Step-by-step derivation

      1. lift-*.f64 N/A

         \[\leadsto \frac{1}{2} \cdot \color{blue}{\left(e^{-im} - e^{im}\right)} \]

      2. *-commutative N/A

         \[\leadsto \left(e^{-im} - e^{im}\right) \cdot \color{blue}{\frac{1}{2}} \]

      3. lift--.f64 N/A

         \[\leadsto \left(e^{-im} - e^{im}\right) \cdot \frac{1}{2} \]

      4. lift-exp.f64 N/A

         \[\leadsto \left(e^{-im} - e^{im}\right) \cdot \frac{1}{2} \]

      5. sinh-+-cosh-rev N/A

         \[\leadsto \left(e^{-im} - \left(\cosh im + \sinh im\right)\right) \cdot \frac{1}{2} \]

      6. lift-exp.f64 N/A

         \[\leadsto \left(e^{-im} - \left(\cosh im + \sinh im\right)\right) \cdot \frac{1}{2} \]

      7. sinh-+-cosh-rev N/A

         \[\leadsto \left(e^{-im} - e^{im}\right) \cdot \frac{1}{2} \]

      8. remove-double-neg N/A

         \[\leadsto \left(e^{-im} - e^{\mathsf{neg}\left(\left(\mathsf{neg}\left(im\right)\right)\right)}\right) \cdot \frac{1}{2} \]

      9. lift-neg.f64 N/A

         \[\leadsto \left(e^{-im} - e^{\mathsf{neg}\left(\left(-im\right)\right)}\right) \cdot \frac{1}{2} \]

      10. metadata-eval N/A

          \[\leadsto \left(e^{-im} - e^{\mathsf{neg}\left(\left(-im\right)\right)}\right) \cdot \frac{1}{\color{blue}{2}} \]

      11. mult-flip N/A

          \[\leadsto \frac{e^{-im} - e^{\mathsf{neg}\left(\left(-im\right)\right)}}{\color{blue}{2}} \]

      12. sinh-def N/A

          \[\leadsto \sinh \left(-im\right) \]

      13. lift-sinh.f64 65.7%

          \[\leadsto \sinh \left(-im\right) \]

   6. Applied rewrites 65.7%

      \[\leadsto \sinh \left(-im\right) \]

   if 0.0 < (*.f64 (*.f64 #s(literal 1/2 binary64) (cos.f64 re)) (-.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))

   1. Initial program 54.0%

      \[\left(0.5 \cdot \cos re\right) \cdot \left(e^{0 - im} - e^{im}\right) \]

   2. Taylor expanded in im around 0

      \[\leadsto \color{blue}{-1 \cdot \left(im \cdot \cos re\right)} \]
   3. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto -1 \cdot \color{blue}{\left(im \cdot \cos re\right)} \]

      2. lower-*.f64 N/A

         \[\leadsto -1 \cdot \left(im \cdot \color{blue}{\cos re}\right) \]

      3. lower-cos.f64 52.3%

         \[\leadsto -1 \cdot \left(im \cdot \cos re\right) \]

   4. Applied rewrites 52.3%

      \[\leadsto \color{blue}{-1 \cdot \left(im \cdot \cos re\right)} \]
   5. Step-by-step derivation

      1. lift-*.f64 N/A

         \[\leadsto -1 \cdot \color{blue}{\left(im \cdot \cos re\right)} \]

      2. mul-1-neg N/A

         \[\leadsto \mathsf{neg}\left(im \cdot \cos re\right) \]

      3. lift-*.f64 N/A

         \[\leadsto \mathsf{neg}\left(im \cdot \cos re\right) \]

      4. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\cos re \cdot im\right) \]

      5. distribute-lft-neg-in N/A

         \[\leadsto \left(\mathsf{neg}\left(\cos re\right)\right) \cdot \color{blue}{im} \]

      6. lower-*.f64 N/A

         \[\leadsto \left(\mathsf{neg}\left(\cos re\right)\right) \cdot \color{blue}{im} \]

      7. lower-neg.f64 52.3%

         \[\leadsto \left(-\cos re\right) \cdot im \]

   6. Applied rewrites 52.3%

      \[\leadsto \left(-\cos re\right) \cdot \color{blue}{im} \]

   7. Taylor expanded in re around 0

      \[\leadsto \left(\frac{1}{2} \cdot {re}^{2} - 1\right) \cdot im \]
   8. Step-by-step derivation

      1. lower--.f64 N/A

         \[\leadsto \left(\frac{1}{2} \cdot {re}^{2} - 1\right) \cdot im \]

      2. lower-*.f64 N/A

         \[\leadsto \left(\frac{1}{2} \cdot {re}^{2} - 1\right) \cdot im \]

      3. lower-pow.f64 36.8%

         \[\leadsto \left(0.5 \cdot {re}^{2} - 1\right) \cdot im \]

   9. Applied rewrites 36.8%

      \[\leadsto \left(0.5 \cdot {re}^{2} - 1\right) \cdot im \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 5: 65.7% accurate, 4.2× speedup

Math

\[\sinh \left(-im\right) \]

FPCore

(FPCore (re im)
  :precision binary64
  (sinh (- im)))

C

double code(double re, double im) {
	return sinh(-im);
}

Fortran

real(8) function code(re, im)
use fmin_fmax_functions
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    code = sinh(-im)
end function

Java

public static double code(double re, double im) {
	return Math.sinh(-im);
}

Python

def code(re, im):
	return math.sinh(-im)

Julia

function code(re, im)
	return sinh(Float64(-im))
end

MATLAB

function tmp = code(re, im)
	tmp = sinh(-im);
end

Wolfram

code[re_, im_] := N[Sinh[(-im)], $MachinePrecision]

Derivation

1. Initial program 54.0%

   \[\left(0.5 \cdot \cos re\right) \cdot \left(e^{0 - im} - e^{im}\right) \]

2. Taylor expanded in re around 0

   \[\leadsto \color{blue}{\frac{1}{2} \cdot \left(e^{\mathsf{neg}\left(im\right)} - e^{im}\right)} \]
3. Step-by-step derivation

   1. lower-*.f64 N/A

      \[\leadsto \frac{1}{2} \cdot \color{blue}{\left(e^{\mathsf{neg}\left(im\right)} - e^{im}\right)} \]

   2. lower--.f64 N/A

      \[\leadsto \frac{1}{2} \cdot \left(e^{\mathsf{neg}\left(im\right)} - \color{blue}{e^{im}}\right) \]

   3. lower-exp.f64 N/A

      \[\leadsto \frac{1}{2} \cdot \left(e^{\mathsf{neg}\left(im\right)} - e^{\color{blue}{im}}\right) \]

   4. lower-neg.f64 N/A

      \[\leadsto \frac{1}{2} \cdot \left(e^{-im} - e^{im}\right) \]

   5. lower-exp.f64 40.9%

      \[\leadsto 0.5 \cdot \left(e^{-im} - e^{im}\right) \]

4. Applied rewrites 40.9%

   \[\leadsto \color{blue}{0.5 \cdot \left(e^{-im} - e^{im}\right)} \]
5. Step-by-step derivation

   1. lift-*.f64 N/A

      \[\leadsto \frac{1}{2} \cdot \color{blue}{\left(e^{-im} - e^{im}\right)} \]

   2. *-commutative N/A

      \[\leadsto \left(e^{-im} - e^{im}\right) \cdot \color{blue}{\frac{1}{2}} \]

   3. lift--.f64 N/A

      \[\leadsto \left(e^{-im} - e^{im}\right) \cdot \frac{1}{2} \]

   4. lift-exp.f64 N/A

      \[\leadsto \left(e^{-im} - e^{im}\right) \cdot \frac{1}{2} \]

   5. sinh-+-cosh-rev N/A

      \[\leadsto \left(e^{-im} - \left(\cosh im + \sinh im\right)\right) \cdot \frac{1}{2} \]

   6. lift-exp.f64 N/A

      \[\leadsto \left(e^{-im} - \left(\cosh im + \sinh im\right)\right) \cdot \frac{1}{2} \]

   7. sinh-+-cosh-rev N/A

      \[\leadsto \left(e^{-im} - e^{im}\right) \cdot \frac{1}{2} \]

   8. remove-double-neg N/A

      \[\leadsto \left(e^{-im} - e^{\mathsf{neg}\left(\left(\mathsf{neg}\left(im\right)\right)\right)}\right) \cdot \frac{1}{2} \]

   9. lift-neg.f64 N/A

      \[\leadsto \left(e^{-im} - e^{\mathsf{neg}\left(\left(-im\right)\right)}\right) \cdot \frac{1}{2} \]

   10. metadata-eval N/A

       \[\leadsto \left(e^{-im} - e^{\mathsf{neg}\left(\left(-im\right)\right)}\right) \cdot \frac{1}{\color{blue}{2}} \]

   11. mult-flip N/A

       \[\leadsto \frac{e^{-im} - e^{\mathsf{neg}\left(\left(-im\right)\right)}}{\color{blue}{2}} \]

   12. sinh-def N/A

       \[\leadsto \sinh \left(-im\right) \]

   13. lift-sinh.f64 65.7%

       \[\leadsto \sinh \left(-im\right) \]

6. Applied rewrites 65.7%

   \[\leadsto \sinh \left(-im\right) \]
7. Add Preprocessing

Alternative 6: 30.1% accurate, 33.9× speedup

Math

\[-im \]

FPCore

(FPCore (re im)
  :precision binary64
  (- im))

C

double code(double re, double im) {
	return -im;
}

Fortran

real(8) function code(re, im)
use fmin_fmax_functions
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    code = -im
end function

Java

public static double code(double re, double im) {
	return -im;
}

Python

def code(re, im):
	return -im

Julia

function code(re, im)
	return Float64(-im)
end

MATLAB

function tmp = code(re, im)
	tmp = -im;
end

Wolfram

code[re_, im_] := (-im)

Derivation

1. Initial program 54.0%

   \[\left(0.5 \cdot \cos re\right) \cdot \left(e^{0 - im} - e^{im}\right) \]

2. Taylor expanded in im around 0

   \[\leadsto \color{blue}{-1 \cdot \left(im \cdot \cos re\right)} \]
3. Step-by-step derivation

   1. lower-*.f64 N/A

      \[\leadsto -1 \cdot \color{blue}{\left(im \cdot \cos re\right)} \]

   2. lower-*.f64 N/A

      \[\leadsto -1 \cdot \left(im \cdot \color{blue}{\cos re}\right) \]

   3. lower-cos.f64 52.3%

      \[\leadsto -1 \cdot \left(im \cdot \cos re\right) \]

4. Applied rewrites 52.3%

   \[\leadsto \color{blue}{-1 \cdot \left(im \cdot \cos re\right)} \]

5. Taylor expanded in re around 0

   \[\leadsto -1 \cdot im \]
6. Step-by-step derivation

7. Applied rewrites 30.1%

   \[\leadsto -1 \cdot im \]
8. Step-by-step derivation

   1. lift-*.f64 N/A

      \[\leadsto -1 \cdot \color{blue}{im} \]

   2. mul-1-neg N/A

      \[\leadsto \mathsf{neg}\left(im\right) \]

   3. lower-neg.f64 30.1%

      \[\leadsto -im \]

9. Applied rewrites 30.1%

   \[\leadsto -im \]
10. Add Preprocessing

Reproduce

herbie shell --seed 2025313 -o setup:search
(FPCore (re im)
  :name "math.sin on complex, imaginary part"
  :precision binary64
  (* (* 0.5 (cos re)) (- (exp (- 0.0 im)) (exp im))))