math.sqrt on complex, imaginary part, im greater than 0 branch

Percentage Accurate: 28.4% → 53.3%

Time: 2.8s

Alternatives: 5

Speedup: 1.6×

• Could not converge on a ground truth

  1. re = 1.7533746046869366e+195
  2. im = -1.7030234586554808e+258

Specification

\[im > 0\]

Math

\[0.5 \cdot \sqrt{2 \cdot \left(\sqrt{re \cdot re + im \cdot im} - re\right)} \]

FPCore

(FPCore (re im)
  :precision binary64
  (* 0.5 (sqrt (* 2.0 (- (sqrt (+ (* re re) (* im im))) re)))))

C

double code(double re, double im) {
	return 0.5 * sqrt((2.0 * (sqrt(((re * re) + (im * im))) - re)));
}

Fortran

real(8) function code(re, im)
use fmin_fmax_functions
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    code = 0.5d0 * sqrt((2.0d0 * (sqrt(((re * re) + (im * im))) - re)))
end function

Java

public static double code(double re, double im) {
	return 0.5 * Math.sqrt((2.0 * (Math.sqrt(((re * re) + (im * im))) - re)));
}

Python

def code(re, im):
	return 0.5 * math.sqrt((2.0 * (math.sqrt(((re * re) + (im * im))) - re)))

Julia

function code(re, im)
	return Float64(0.5 * sqrt(Float64(2.0 * Float64(sqrt(Float64(Float64(re * re) + Float64(im * im))) - re))))
end

MATLAB

function tmp = code(re, im)
	tmp = 0.5 * sqrt((2.0 * (sqrt(((re * re) + (im * im))) - re)));
end

Wolfram

code[re_, im_] := N[(0.5 * N[Sqrt[N[(2.0 * N[(N[Sqrt[N[(N[(re * re), $MachinePrecision] + N[(im * im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Initial Program: 28.4% accurate, 1.0× speedup

Math

\[0.5 \cdot \sqrt{2 \cdot \left(\sqrt{re \cdot re + im \cdot im} - re\right)} \]

FPCore

(FPCore (re im)
  :precision binary64
  (* 0.5 (sqrt (* 2.0 (- (sqrt (+ (* re re) (* im im))) re)))))

C

double code(double re, double im) {
	return 0.5 * sqrt((2.0 * (sqrt(((re * re) + (im * im))) - re)));
}

Fortran

real(8) function code(re, im)
use fmin_fmax_functions
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    code = 0.5d0 * sqrt((2.0d0 * (sqrt(((re * re) + (im * im))) - re)))
end function

Java

public static double code(double re, double im) {
	return 0.5 * Math.sqrt((2.0 * (Math.sqrt(((re * re) + (im * im))) - re)));
}

Python

def code(re, im):
	return 0.5 * math.sqrt((2.0 * (math.sqrt(((re * re) + (im * im))) - re)))

Julia

function code(re, im)
	return Float64(0.5 * sqrt(Float64(2.0 * Float64(sqrt(Float64(Float64(re * re) + Float64(im * im))) - re))))
end

MATLAB

function tmp = code(re, im)
	tmp = 0.5 * sqrt((2.0 * (sqrt(((re * re) + (im * im))) - re)));
end

Wolfram

code[re_, im_] := N[(0.5 * N[Sqrt[N[(2.0 * N[(N[Sqrt[N[(N[(re * re), $MachinePrecision] + N[(im * im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Alternative 1: 53.3% accurate, 0.3× speedup

Math

\[\begin{array}{l} t_0 := 0 \cdot \sqrt{\left|im\right| \cdot 2}\\ t_1 := 0.5 \cdot \sqrt{2 \cdot \left(\sqrt{re \cdot re + \left|im\right| \cdot \left|im\right|} - re\right)}\\ \mathbf{if}\;t\_1 \leq 2 \cdot 10^{+55}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;t\_1 \leq 10^{+76}:\\ \;\;\;\;\sqrt{\left(\sqrt{\mathsf{fma}\left(\left|im\right|, \left|im\right|, re \cdot re\right)} - re\right) \cdot 2} \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \]

FPCore

(FPCore (re im)
  :precision binary64
  (let* ((t_0 (* 0.0 (sqrt (* (fabs im) 2.0))))
       (t_1
        (*
         0.5
         (sqrt
          (*
           2.0
           (- (sqrt (+ (* re re) (* (fabs im) (fabs im)))) re))))))
  (if (<= t_1 2e+55)
    t_0
    (if (<= t_1 1e+76)
      (*
       (sqrt
        (* (- (sqrt (fma (fabs im) (fabs im) (* re re))) re) 2.0))
       0.5)
      t_0))))

C

double code(double re, double im) {
	double t_0 = 0.0 * sqrt((fabs(im) * 2.0));
	double t_1 = 0.5 * sqrt((2.0 * (sqrt(((re * re) + (fabs(im) * fabs(im)))) - re)));
	double tmp;
	if (t_1 <= 2e+55) {
		tmp = t_0;
	} else if (t_1 <= 1e+76) {
		tmp = sqrt(((sqrt(fma(fabs(im), fabs(im), (re * re))) - re) * 2.0)) * 0.5;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Julia

function code(re, im)
	t_0 = Float64(0.0 * sqrt(Float64(abs(im) * 2.0)))
	t_1 = Float64(0.5 * sqrt(Float64(2.0 * Float64(sqrt(Float64(Float64(re * re) + Float64(abs(im) * abs(im)))) - re))))
	tmp = 0.0
	if (t_1 <= 2e+55)
		tmp = t_0;
	elseif (t_1 <= 1e+76)
		tmp = Float64(sqrt(Float64(Float64(sqrt(fma(abs(im), abs(im), Float64(re * re))) - re) * 2.0)) * 0.5);
	else
		tmp = t_0;
	end
	return tmp
end

Wolfram

code[re_, im_] := Block[{t$95$0 = N[(0.0 * N[Sqrt[N[(N[Abs[im], $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(0.5 * N[Sqrt[N[(2.0 * N[(N[Sqrt[N[(N[(re * re), $MachinePrecision] + N[(N[Abs[im], $MachinePrecision] * N[Abs[im], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 2e+55], t$95$0, If[LessEqual[t$95$1, 1e+76], N[(N[Sqrt[N[(N[(N[Sqrt[N[(N[Abs[im], $MachinePrecision] * N[Abs[im], $MachinePrecision] + N[(re * re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - re), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] * 0.5), $MachinePrecision], t$95$0]]]]

Derivation

1. Split input into 2 regimes

2. if (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) < 2e55 or 1e76 < (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))

   1. Initial program 28.4%

      \[0.5 \cdot \sqrt{2 \cdot \left(\sqrt{re \cdot re + im \cdot im} - re\right)} \]

   2. Taylor expanded in im around inf

      \[\leadsto 0.5 \cdot \sqrt{\color{blue}{im \cdot \left(2 + -2 \cdot \frac{re}{im}\right)}} \]
   3. Step-by-step derivation

      1. lower-*.f64 N/A

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

      2. lower-+.f64 N/A

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

      3. lower-*.f64 N/A

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

      4. lower-/.f64 27.9%

         \[\leadsto 0.5 \cdot \sqrt{im \cdot \left(2 + -2 \cdot \frac{re}{\color{blue}{im}}\right)} \]

   4. Applied rewrites 27.9%

      \[\leadsto 0.5 \cdot \sqrt{\color{blue}{im \cdot \left(2 + -2 \cdot \frac{re}{im}\right)}} \]

   5. Taylor expanded in re around 0

      \[\leadsto 0.5 \cdot \sqrt{im \cdot 2} \]
   6. Step-by-step derivation

   7. Applied rewrites 26.9%

      \[\leadsto 0.5 \cdot \sqrt{im \cdot 2} \]

   8. Taylor expanded in undef-var around zero

      \[\leadsto \color{blue}{0} \cdot \sqrt{im \cdot 2} \]
   9. Step-by-step derivation

   10. Applied rewrites 3.3%

       \[\leadsto \color{blue}{0} \cdot \sqrt{im \cdot 2} \]

   if 2e55 < (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) < 1e76

   1. Initial program 28.4%

      \[0.5 \cdot \sqrt{2 \cdot \left(\sqrt{re \cdot re + im \cdot im} - re\right)} \]
   2. Step-by-step derivation

      1. lift-*.f64 N/A

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

      2. *-commutative N/A

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

      3. lower-*.f64 28.4%

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

      4. lift-*.f64 N/A

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

      5. *-commutative N/A

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

      6. lower-*.f64 28.4%

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

      7. lift-+.f64 N/A

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

      8. +-commutative N/A

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

      9. lift-*.f64 N/A

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

      10. lower-fma.f64 28.4%

          \[\leadsto \sqrt{\left(\sqrt{\color{blue}{\mathsf{fma}\left(im, im, re \cdot re\right)}} - re\right) \cdot 2} \cdot 0.5 \]

   3. Applied rewrites 28.4%

      \[\leadsto \color{blue}{\sqrt{\left(\sqrt{\mathsf{fma}\left(im, im, re \cdot re\right)} - re\right) \cdot 2} \cdot 0.5} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 2: 52.7% accurate, 1.6× speedup

Math

\[\begin{array}{l} \mathbf{if}\;re \leq -3.9 \cdot 10^{+220}:\\ \;\;\;\;0.5 \cdot \sqrt{-4 \cdot re}\\ \mathbf{else}:\\ \;\;\;\;0 \cdot \sqrt{\left|im\right| \cdot 2}\\ \end{array} \]

FPCore

(FPCore (re im)
  :precision binary64
  (if (<= re -3.9e+220)
  (* 0.5 (sqrt (* -4.0 re)))
  (* 0.0 (sqrt (* (fabs im) 2.0)))))

C

double code(double re, double im) {
	double tmp;
	if (re <= -3.9e+220) {
		tmp = 0.5 * sqrt((-4.0 * re));
	} else {
		tmp = 0.0 * sqrt((fabs(im) * 2.0));
	}
	return tmp;
}

Fortran

real(8) function code(re, im)
use fmin_fmax_functions
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    real(8) :: tmp
    if (re <= (-3.9d+220)) then
        tmp = 0.5d0 * sqrt(((-4.0d0) * re))
    else
        tmp = 0.0d0 * sqrt((abs(im) * 2.0d0))
    end if
    code = tmp
end function

Java

public static double code(double re, double im) {
	double tmp;
	if (re <= -3.9e+220) {
		tmp = 0.5 * Math.sqrt((-4.0 * re));
	} else {
		tmp = 0.0 * Math.sqrt((Math.abs(im) * 2.0));
	}
	return tmp;
}

Python

def code(re, im):
	tmp = 0
	if re <= -3.9e+220:
		tmp = 0.5 * math.sqrt((-4.0 * re))
	else:
		tmp = 0.0 * math.sqrt((math.fabs(im) * 2.0))
	return tmp

Julia

function code(re, im)
	tmp = 0.0
	if (re <= -3.9e+220)
		tmp = Float64(0.5 * sqrt(Float64(-4.0 * re)));
	else
		tmp = Float64(0.0 * sqrt(Float64(abs(im) * 2.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(re, im)
	tmp = 0.0;
	if (re <= -3.9e+220)
		tmp = 0.5 * sqrt((-4.0 * re));
	else
		tmp = 0.0 * sqrt((abs(im) * 2.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[re_, im_] := If[LessEqual[re, -3.9e+220], N[(0.5 * N[Sqrt[N[(-4.0 * re), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(0.0 * N[Sqrt[N[(N[Abs[im], $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if re < -3.9000000000000002e220

   1. Initial program 28.4%

      \[0.5 \cdot \sqrt{2 \cdot \left(\sqrt{re \cdot re + im \cdot im} - re\right)} \]

   2. Taylor expanded in re around -inf

      \[\leadsto 0.5 \cdot \sqrt{\color{blue}{-4 \cdot re}} \]
   3. Step-by-step derivation

      1. lower-*.f64 13.6%

         \[\leadsto 0.5 \cdot \sqrt{-4 \cdot \color{blue}{re}} \]

   4. Applied rewrites 13.6%

      \[\leadsto 0.5 \cdot \sqrt{\color{blue}{-4 \cdot re}} \]

   if -3.9000000000000002e220 < re

   1. Initial program 28.4%

      \[0.5 \cdot \sqrt{2 \cdot \left(\sqrt{re \cdot re + im \cdot im} - re\right)} \]

   2. Taylor expanded in im around inf

      \[\leadsto 0.5 \cdot \sqrt{\color{blue}{im \cdot \left(2 + -2 \cdot \frac{re}{im}\right)}} \]
   3. Step-by-step derivation

      1. lower-*.f64 N/A

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

      2. lower-+.f64 N/A

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

      3. lower-*.f64 N/A

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

      4. lower-/.f64 27.9%

         \[\leadsto 0.5 \cdot \sqrt{im \cdot \left(2 + -2 \cdot \frac{re}{\color{blue}{im}}\right)} \]

   4. Applied rewrites 27.9%

      \[\leadsto 0.5 \cdot \sqrt{\color{blue}{im \cdot \left(2 + -2 \cdot \frac{re}{im}\right)}} \]

   5. Taylor expanded in re around 0

      \[\leadsto 0.5 \cdot \sqrt{im \cdot 2} \]
   6. Step-by-step derivation

   7. Applied rewrites 26.9%

      \[\leadsto 0.5 \cdot \sqrt{im \cdot 2} \]

   8. Taylor expanded in undef-var around zero

      \[\leadsto \color{blue}{0} \cdot \sqrt{im \cdot 2} \]
   9. Step-by-step derivation

   10. Applied rewrites 3.3%

       \[\leadsto \color{blue}{0} \cdot \sqrt{im \cdot 2} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 3: 39.2% accurate, 1.3× speedup

Math

\[\begin{array}{l} t_0 := \sqrt{-4 \cdot re}\\ \mathbf{if}\;re \leq -3.9 \cdot 10^{+220}:\\ \;\;\;\;0.5 \cdot t\_0\\ \mathbf{elif}\;re \leq -1.3 \cdot 10^{-298}:\\ \;\;\;\;0 \cdot t\_0\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \sqrt{2 \cdot \left|im\right|}\\ \end{array} \]

FPCore

(FPCore (re im)
  :precision binary64
  (let* ((t_0 (sqrt (* -4.0 re))))
  (if (<= re -3.9e+220)
    (* 0.5 t_0)
    (if (<= re -1.3e-298)
      (* 0.0 t_0)
      (* 0.5 (sqrt (* 2.0 (fabs im))))))))

C

double code(double re, double im) {
	double t_0 = sqrt((-4.0 * re));
	double tmp;
	if (re <= -3.9e+220) {
		tmp = 0.5 * t_0;
	} else if (re <= -1.3e-298) {
		tmp = 0.0 * t_0;
	} else {
		tmp = 0.5 * sqrt((2.0 * fabs(im)));
	}
	return tmp;
}

Fortran

real(8) function code(re, im)
use fmin_fmax_functions
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    real(8) :: t_0
    real(8) :: tmp
    t_0 = sqrt(((-4.0d0) * re))
    if (re <= (-3.9d+220)) then
        tmp = 0.5d0 * t_0
    else if (re <= (-1.3d-298)) then
        tmp = 0.0d0 * t_0
    else
        tmp = 0.5d0 * sqrt((2.0d0 * abs(im)))
    end if
    code = tmp
end function

Java

public static double code(double re, double im) {
	double t_0 = Math.sqrt((-4.0 * re));
	double tmp;
	if (re <= -3.9e+220) {
		tmp = 0.5 * t_0;
	} else if (re <= -1.3e-298) {
		tmp = 0.0 * t_0;
	} else {
		tmp = 0.5 * Math.sqrt((2.0 * Math.abs(im)));
	}
	return tmp;
}

Python

def code(re, im):
	t_0 = math.sqrt((-4.0 * re))
	tmp = 0
	if re <= -3.9e+220:
		tmp = 0.5 * t_0
	elif re <= -1.3e-298:
		tmp = 0.0 * t_0
	else:
		tmp = 0.5 * math.sqrt((2.0 * math.fabs(im)))
	return tmp

Julia

function code(re, im)
	t_0 = sqrt(Float64(-4.0 * re))
	tmp = 0.0
	if (re <= -3.9e+220)
		tmp = Float64(0.5 * t_0);
	elseif (re <= -1.3e-298)
		tmp = Float64(0.0 * t_0);
	else
		tmp = Float64(0.5 * sqrt(Float64(2.0 * abs(im))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(re, im)
	t_0 = sqrt((-4.0 * re));
	tmp = 0.0;
	if (re <= -3.9e+220)
		tmp = 0.5 * t_0;
	elseif (re <= -1.3e-298)
		tmp = 0.0 * t_0;
	else
		tmp = 0.5 * sqrt((2.0 * abs(im)));
	end
	tmp_2 = tmp;
end

Wolfram

code[re_, im_] := Block[{t$95$0 = N[Sqrt[N[(-4.0 * re), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[re, -3.9e+220], N[(0.5 * t$95$0), $MachinePrecision], If[LessEqual[re, -1.3e-298], N[(0.0 * t$95$0), $MachinePrecision], N[(0.5 * N[Sqrt[N[(2.0 * N[Abs[im], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if re < -3.9000000000000002e220

   1. Initial program 28.4%

      \[0.5 \cdot \sqrt{2 \cdot \left(\sqrt{re \cdot re + im \cdot im} - re\right)} \]

   2. Taylor expanded in re around -inf

      \[\leadsto 0.5 \cdot \sqrt{\color{blue}{-4 \cdot re}} \]
   3. Step-by-step derivation

      1. lower-*.f64 13.6%

         \[\leadsto 0.5 \cdot \sqrt{-4 \cdot \color{blue}{re}} \]

   4. Applied rewrites 13.6%

      \[\leadsto 0.5 \cdot \sqrt{\color{blue}{-4 \cdot re}} \]

   if -3.9000000000000002e220 < re < -1.2999999999999999e-298

   1. Initial program 28.4%

      \[0.5 \cdot \sqrt{2 \cdot \left(\sqrt{re \cdot re + im \cdot im} - re\right)} \]

   2. Taylor expanded in re around -inf

      \[\leadsto 0.5 \cdot \sqrt{\color{blue}{-4 \cdot re}} \]
   3. Step-by-step derivation

      1. lower-*.f64 13.6%

         \[\leadsto 0.5 \cdot \sqrt{-4 \cdot \color{blue}{re}} \]

   4. Applied rewrites 13.6%

      \[\leadsto 0.5 \cdot \sqrt{\color{blue}{-4 \cdot re}} \]

   5. Taylor expanded in undef-var around zero

      \[\leadsto \color{blue}{0} \cdot \sqrt{-4 \cdot re} \]
   6. Step-by-step derivation

   7. Applied rewrites 25.3%

      \[\leadsto \color{blue}{0} \cdot \sqrt{-4 \cdot re} \]

   if -1.2999999999999999e-298 < re

   1. Initial program 28.4%

      \[0.5 \cdot \sqrt{2 \cdot \left(\sqrt{re \cdot re + im \cdot im} - re\right)} \]

   2. Taylor expanded in re around inf

      \[\leadsto 0.5 \cdot \sqrt{\color{blue}{\frac{{im}^{2}}{re}}} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{1}{2} \cdot \sqrt{\frac{{im}^{2}}{\color{blue}{re}}} \]

      2. lower-pow.f64 23.0%

         \[\leadsto 0.5 \cdot \sqrt{\frac{{im}^{2}}{re}} \]

   4. Applied rewrites 23.0%

      \[\leadsto 0.5 \cdot \sqrt{\color{blue}{\frac{{im}^{2}}{re}}} \]

   5. Taylor expanded in im around inf

      \[\leadsto 0.5 \cdot \sqrt{\color{blue}{2 \cdot im}} \]
   6. Step-by-step derivation

      1. lower-*.f64 26.9%

         \[\leadsto 0.5 \cdot \sqrt{2 \cdot \color{blue}{im}} \]

   7. Applied rewrites 26.9%

      \[\leadsto 0.5 \cdot \sqrt{\color{blue}{2 \cdot im}} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 4: 33.9% accurate, 1.6× speedup

Math

\[\begin{array}{l} \mathbf{if}\;re \leq -2.2 \cdot 10^{+62}:\\ \;\;\;\;0.5 \cdot \sqrt{-4 \cdot re}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \sqrt{2 \cdot \left|im\right|}\\ \end{array} \]

FPCore

(FPCore (re im)
  :precision binary64
  (if (<= re -2.2e+62)
  (* 0.5 (sqrt (* -4.0 re)))
  (* 0.5 (sqrt (* 2.0 (fabs im))))))

C

double code(double re, double im) {
	double tmp;
	if (re <= -2.2e+62) {
		tmp = 0.5 * sqrt((-4.0 * re));
	} else {
		tmp = 0.5 * sqrt((2.0 * fabs(im)));
	}
	return tmp;
}

Fortran

real(8) function code(re, im)
use fmin_fmax_functions
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    real(8) :: tmp
    if (re <= (-2.2d+62)) then
        tmp = 0.5d0 * sqrt(((-4.0d0) * re))
    else
        tmp = 0.5d0 * sqrt((2.0d0 * abs(im)))
    end if
    code = tmp
end function

Java

public static double code(double re, double im) {
	double tmp;
	if (re <= -2.2e+62) {
		tmp = 0.5 * Math.sqrt((-4.0 * re));
	} else {
		tmp = 0.5 * Math.sqrt((2.0 * Math.abs(im)));
	}
	return tmp;
}

Python

def code(re, im):
	tmp = 0
	if re <= -2.2e+62:
		tmp = 0.5 * math.sqrt((-4.0 * re))
	else:
		tmp = 0.5 * math.sqrt((2.0 * math.fabs(im)))
	return tmp

Julia

function code(re, im)
	tmp = 0.0
	if (re <= -2.2e+62)
		tmp = Float64(0.5 * sqrt(Float64(-4.0 * re)));
	else
		tmp = Float64(0.5 * sqrt(Float64(2.0 * abs(im))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(re, im)
	tmp = 0.0;
	if (re <= -2.2e+62)
		tmp = 0.5 * sqrt((-4.0 * re));
	else
		tmp = 0.5 * sqrt((2.0 * abs(im)));
	end
	tmp_2 = tmp;
end

Wolfram

code[re_, im_] := If[LessEqual[re, -2.2e+62], N[(0.5 * N[Sqrt[N[(-4.0 * re), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(0.5 * N[Sqrt[N[(2.0 * N[Abs[im], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if re < -2.2000000000000001e62

   1. Initial program 28.4%

      \[0.5 \cdot \sqrt{2 \cdot \left(\sqrt{re \cdot re + im \cdot im} - re\right)} \]

   2. Taylor expanded in re around -inf

      \[\leadsto 0.5 \cdot \sqrt{\color{blue}{-4 \cdot re}} \]
   3. Step-by-step derivation

      1. lower-*.f64 13.6%

         \[\leadsto 0.5 \cdot \sqrt{-4 \cdot \color{blue}{re}} \]

   4. Applied rewrites 13.6%

      \[\leadsto 0.5 \cdot \sqrt{\color{blue}{-4 \cdot re}} \]

   if -2.2000000000000001e62 < re

   1. Initial program 28.4%

      \[0.5 \cdot \sqrt{2 \cdot \left(\sqrt{re \cdot re + im \cdot im} - re\right)} \]

   2. Taylor expanded in re around inf

      \[\leadsto 0.5 \cdot \sqrt{\color{blue}{\frac{{im}^{2}}{re}}} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{1}{2} \cdot \sqrt{\frac{{im}^{2}}{\color{blue}{re}}} \]

      2. lower-pow.f64 23.0%

         \[\leadsto 0.5 \cdot \sqrt{\frac{{im}^{2}}{re}} \]

   4. Applied rewrites 23.0%

      \[\leadsto 0.5 \cdot \sqrt{\color{blue}{\frac{{im}^{2}}{re}}} \]

   5. Taylor expanded in im around inf

      \[\leadsto 0.5 \cdot \sqrt{\color{blue}{2 \cdot im}} \]
   6. Step-by-step derivation

      1. lower-*.f64 26.9%

         \[\leadsto 0.5 \cdot \sqrt{2 \cdot \color{blue}{im}} \]

   7. Applied rewrites 26.9%

      \[\leadsto 0.5 \cdot \sqrt{\color{blue}{2 \cdot im}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 5: 13.6% accurate, 2.5× speedup

Math

\[0.5 \cdot \sqrt{-4 \cdot re} \]

FPCore

(FPCore (re im)
  :precision binary64
  (* 0.5 (sqrt (* -4.0 re))))

C

double code(double re, double im) {
	return 0.5 * sqrt((-4.0 * re));
}

Fortran

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

Java

public static double code(double re, double im) {
	return 0.5 * Math.sqrt((-4.0 * re));
}

Python

def code(re, im):
	return 0.5 * math.sqrt((-4.0 * re))

Julia

function code(re, im)
	return Float64(0.5 * sqrt(Float64(-4.0 * re)))
end

MATLAB

function tmp = code(re, im)
	tmp = 0.5 * sqrt((-4.0 * re));
end

Wolfram

code[re_, im_] := N[(0.5 * N[Sqrt[N[(-4.0 * re), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 28.4%

   \[0.5 \cdot \sqrt{2 \cdot \left(\sqrt{re \cdot re + im \cdot im} - re\right)} \]

2. Taylor expanded in re around -inf

   \[\leadsto 0.5 \cdot \sqrt{\color{blue}{-4 \cdot re}} \]
3. Step-by-step derivation

   1. lower-*.f64 13.6%

      \[\leadsto 0.5 \cdot \sqrt{-4 \cdot \color{blue}{re}} \]

4. Applied rewrites 13.6%

   \[\leadsto 0.5 \cdot \sqrt{\color{blue}{-4 \cdot re}} \]
5. Add Preprocessing

Reproduce

herbie shell --seed 2025313 -o setup:search
(FPCore (re im)
  :name "math.sqrt on complex, imaginary part, im greater than 0 branch"
  :precision binary64
  :pre (> im 0.0)
  (* 0.5 (sqrt (* 2.0 (- (sqrt (+ (* re re) (* im im))) re)))))