math.sqrt on complex, real part

Average Error: 38.8 → 11.4

Time: 8.7s

Precision: binary64

Cost: 20040

Math

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

↓

\[\begin{array}{l} \mathbf{if}\;re \leq -3.6 \cdot 10^{+196}:\\ \;\;\;\;0.5 \cdot \sqrt{\frac{im}{re} \cdot \left(-im\right)}\\ \mathbf{elif}\;re \leq -4 \cdot 10^{+101}:\\ \;\;\;\;0.5 \cdot {\left(\frac{\sqrt[3]{im \cdot \left(-im\right)}}{\sqrt[3]{re}}\right)}^{1.5}\\ \mathbf{elif}\;re \leq -950:\\ \;\;\;\;0.5 \cdot \sqrt{2 \cdot \mathsf{fma}\left(\frac{im}{\frac{re}{im}}, -0.5, \left(\frac{im \cdot im}{re \cdot re} \cdot \left(im \cdot \frac{im}{re}\right)\right) \cdot 0.125\right)}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \sqrt{2 \cdot \left(re + \mathsf{hypot}\left(re, im\right)\right)}\\ \end{array} \]

FPCore

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

↓

(FPCore (re im)
 :precision binary64
 (if (<= re -3.6e+196)
   (* 0.5 (sqrt (* (/ im re) (- im))))
   (if (<= re -4e+101)
     (* 0.5 (pow (/ (cbrt (* im (- im))) (cbrt re)) 1.5))
     (if (<= re -950.0)
       (*
        0.5
        (sqrt
         (*
          2.0
          (fma
           (/ im (/ re im))
           -0.5
           (* (* (/ (* im im) (* re re)) (* im (/ im re))) 0.125)))))
       (* 0.5 (sqrt (* 2.0 (+ re (hypot re im)))))))))

C

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

↓

double code(double re, double im) {
	double tmp;
	if (re <= -3.6e+196) {
		tmp = 0.5 * sqrt(((im / re) * -im));
	} else if (re <= -4e+101) {
		tmp = 0.5 * pow((cbrt((im * -im)) / cbrt(re)), 1.5);
	} else if (re <= -950.0) {
		tmp = 0.5 * sqrt((2.0 * fma((im / (re / im)), -0.5, ((((im * im) / (re * re)) * (im * (im / re))) * 0.125))));
	} else {
		tmp = 0.5 * sqrt((2.0 * (re + hypot(re, im))));
	}
	return tmp;
}

Julia

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

↓

function code(re, im)
	tmp = 0.0
	if (re <= -3.6e+196)
		tmp = Float64(0.5 * sqrt(Float64(Float64(im / re) * Float64(-im))));
	elseif (re <= -4e+101)
		tmp = Float64(0.5 * (Float64(cbrt(Float64(im * Float64(-im))) / cbrt(re)) ^ 1.5));
	elseif (re <= -950.0)
		tmp = Float64(0.5 * sqrt(Float64(2.0 * fma(Float64(im / Float64(re / im)), -0.5, Float64(Float64(Float64(Float64(im * im) / Float64(re * re)) * Float64(im * Float64(im / re))) * 0.125)))));
	else
		tmp = Float64(0.5 * sqrt(Float64(2.0 * Float64(re + hypot(re, im)))));
	end
	return tmp
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]

↓

code[re_, im_] := If[LessEqual[re, -3.6e+196], N[(0.5 * N[Sqrt[N[(N[(im / re), $MachinePrecision] * (-im)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[re, -4e+101], N[(0.5 * N[Power[N[(N[Power[N[(im * (-im)), $MachinePrecision], 1/3], $MachinePrecision] / N[Power[re, 1/3], $MachinePrecision]), $MachinePrecision], 1.5], $MachinePrecision]), $MachinePrecision], If[LessEqual[re, -950.0], N[(0.5 * N[Sqrt[N[(2.0 * N[(N[(im / N[(re / im), $MachinePrecision]), $MachinePrecision] * -0.5 + N[(N[(N[(N[(im * im), $MachinePrecision] / N[(re * re), $MachinePrecision]), $MachinePrecision] * N[(im * N[(im / re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 0.125), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(0.5 * N[Sqrt[N[(2.0 * N[(re + N[Sqrt[re ^ 2 + im ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]

Target

Original	38.8
Target	33.9
Herbie	11.4

\[\begin{array}{l} \mathbf{if}\;re < 0:\\ \;\;\;\;0.5 \cdot \left(\sqrt{2} \cdot \sqrt{\frac{im \cdot im}{\sqrt{re \cdot re + im \cdot im} - re}}\right)\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \sqrt{2 \cdot \left(\sqrt{re \cdot re + im \cdot im} + re\right)}\\ \end{array} \]

Derivation

1. Split input into 4 regimes

2. if re < -3.60000000000000007e196

   1. Initial program 64.0

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

   2. Simplified 43.0

      \[\leadsto \color{blue}{0.5 \cdot \sqrt{2 \cdot \left(re + \mathsf{hypot}\left(re, im\right)\right)}} \]
      Proof
      (*.f64 1/2 (sqrt.f64 (*.f64 2 (+.f64 re (hypot.f64 re im))))): 0 points increase in error, 0 points decrease in error
      (*.f64 1/2 (sqrt.f64 (*.f64 2 (+.f64 re (Rewrite<= hypot-def_binary64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))))): 129 points increase in error, 1 points decrease in error
      (*.f64 1/2 (sqrt.f64 (*.f64 2 (Rewrite<= +-commutative_binary64 (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))): 0 points increase in error, 0 points decrease in error

   3. Taylor expanded in re around -inf 31.5

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

   4. Simplified 20.9

      \[\leadsto 0.5 \cdot \sqrt{2 \cdot \color{blue}{\left(\left(\frac{im}{re} \cdot im\right) \cdot -0.5\right)}} \]
      Proof
      (*.f64 (*.f64 (/.f64 im re) im) -1/2): 0 points increase in error, 0 points decrease in error
      (*.f64 (Rewrite<= associate-/r/_binary64 (/.f64 im (/.f64 re im))) -1/2): 26 points increase in error, 19 points decrease in error
      (*.f64 (Rewrite<= associate-/l*_binary64 (/.f64 (*.f64 im im) re)) -1/2): 41 points increase in error, 37 points decrease in error
      (*.f64 (/.f64 (Rewrite<= unpow2_binary64 (pow.f64 im 2)) re) -1/2): 0 points increase in error, 0 points decrease in error
      (Rewrite<= *-commutative_binary64 (*.f64 -1/2 (/.f64 (pow.f64 im 2) re))): 0 points increase in error, 0 points decrease in error

   5. Applied egg-rr 31.5

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

   6. Simplified 20.9

      \[\leadsto 0.5 \cdot \color{blue}{\sqrt{\left(-\frac{im}{re}\right) \cdot im}} \]
      Proof
      (sqrt.f64 (*.f64 (neg.f64 (/.f64 im re)) im)): 0 points increase in error, 0 points decrease in error
      (sqrt.f64 (*.f64 (neg.f64 (Rewrite<= rem-exp-log_binary64 (exp.f64 (log.f64 (/.f64 im re))))) im)): 59 points increase in error, 14 points decrease in error
      (sqrt.f64 (*.f64 (neg.f64 (exp.f64 (Rewrite<= *-rgt-identity_binary64 (*.f64 (log.f64 (/.f64 im re)) 1)))) im)): 0 points increase in error, 0 points decrease in error
      (sqrt.f64 (Rewrite<= distribute-lft-neg-in_binary64 (neg.f64 (*.f64 (exp.f64 (*.f64 (log.f64 (/.f64 im re)) 1)) im)))): 0 points increase in error, 0 points decrease in error
      (sqrt.f64 (Rewrite=> distribute-rgt-neg-in_binary64 (*.f64 (exp.f64 (*.f64 (log.f64 (/.f64 im re)) 1)) (neg.f64 im)))): 0 points increase in error, 0 points decrease in error
      (sqrt.f64 (*.f64 (exp.f64 (Rewrite=> *-rgt-identity_binary64 (log.f64 (/.f64 im re)))) (neg.f64 im))): 0 points increase in error, 0 points decrease in error
      (sqrt.f64 (*.f64 (Rewrite=> rem-exp-log_binary64 (/.f64 im re)) (neg.f64 im))): 14 points increase in error, 59 points decrease in error
      (sqrt.f64 (Rewrite<= associate-/r/_binary64 (/.f64 im (/.f64 re (neg.f64 im))))): 6 points increase in error, 5 points decrease in error
      (sqrt.f64 (/.f64 im (/.f64 re (Rewrite=> neg-mul-1_binary64 (*.f64 -1 im))))): 0 points increase in error, 0 points decrease in error
      (sqrt.f64 (/.f64 im (Rewrite=> associate-/r*_binary64 (/.f64 (/.f64 re -1) im)))): 0 points increase in error, 0 points decrease in error
      (sqrt.f64 (Rewrite<= associate-/l*_binary64 (/.f64 (*.f64 im im) (/.f64 re -1)))): 23 points increase in error, 16 points decrease in error
      (sqrt.f64 (Rewrite=> associate-/r/_binary64 (*.f64 (/.f64 (*.f64 im im) re) -1))): 0 points increase in error, 0 points decrease in error
      (Rewrite<= +-lft-identity_binary64 (+.f64 0 (sqrt.f64 (*.f64 (/.f64 (*.f64 im im) re) -1)))): 0 points increase in error, 0 points decrease in error

   if -3.60000000000000007e196 < re < -3.9999999999999999e101

   1. Initial program 57.6

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

   2. Simplified 36.7

      \[\leadsto \color{blue}{0.5 \cdot \sqrt{2 \cdot \left(re + \mathsf{hypot}\left(re, im\right)\right)}} \]
      Proof
      (*.f64 1/2 (sqrt.f64 (*.f64 2 (+.f64 re (hypot.f64 re im))))): 0 points increase in error, 0 points decrease in error
      (*.f64 1/2 (sqrt.f64 (*.f64 2 (+.f64 re (Rewrite<= hypot-def_binary64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))))): 129 points increase in error, 1 points decrease in error
      (*.f64 1/2 (sqrt.f64 (*.f64 2 (Rewrite<= +-commutative_binary64 (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))): 0 points increase in error, 0 points decrease in error

   3. Taylor expanded in re around -inf 35.3

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

   4. Simplified 33.1

      \[\leadsto 0.5 \cdot \sqrt{2 \cdot \color{blue}{\left(\left(\frac{im}{re} \cdot im\right) \cdot -0.5\right)}} \]
      Proof
      (*.f64 (*.f64 (/.f64 im re) im) -1/2): 0 points increase in error, 0 points decrease in error
      (*.f64 (Rewrite<= associate-/r/_binary64 (/.f64 im (/.f64 re im))) -1/2): 26 points increase in error, 19 points decrease in error
      (*.f64 (Rewrite<= associate-/l*_binary64 (/.f64 (*.f64 im im) re)) -1/2): 41 points increase in error, 37 points decrease in error
      (*.f64 (/.f64 (Rewrite<= unpow2_binary64 (pow.f64 im 2)) re) -1/2): 0 points increase in error, 0 points decrease in error
      (Rewrite<= *-commutative_binary64 (*.f64 -1/2 (/.f64 (pow.f64 im 2) re))): 0 points increase in error, 0 points decrease in error

   5. Applied egg-rr 35.5

      \[\leadsto 0.5 \cdot \color{blue}{{\left(\sqrt[3]{\frac{im \cdot im}{re} \cdot -1}\right)}^{1.5}} \]

   6. Applied egg-rr 29.1

      \[\leadsto 0.5 \cdot {\color{blue}{\left(\frac{\sqrt[3]{im \cdot \left(-im\right)}}{\sqrt[3]{re}}\right)}}^{1.5} \]

   if -3.9999999999999999e101 < re < -950

   1. Initial program 50.4

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

   2. Simplified 35.7

      \[\leadsto \color{blue}{0.5 \cdot \sqrt{2 \cdot \left(re + \mathsf{hypot}\left(re, im\right)\right)}} \]
      Proof
      (*.f64 1/2 (sqrt.f64 (*.f64 2 (+.f64 re (hypot.f64 re im))))): 0 points increase in error, 0 points decrease in error
      (*.f64 1/2 (sqrt.f64 (*.f64 2 (+.f64 re (Rewrite<= hypot-def_binary64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))))): 129 points increase in error, 1 points decrease in error
      (*.f64 1/2 (sqrt.f64 (*.f64 2 (Rewrite<= +-commutative_binary64 (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))): 0 points increase in error, 0 points decrease in error

   3. Taylor expanded in re around -inf 39.7

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

   4. Simplified 39.7

      \[\leadsto 0.5 \cdot \sqrt{2 \cdot \color{blue}{\mathsf{fma}\left(\frac{im}{\frac{re}{im}}, -0.5, \frac{{im}^{4}}{{re}^{3}} \cdot 0.125\right)}} \]
      Proof
      (fma.f64 (/.f64 im (/.f64 re im)) -1/2 (*.f64 (/.f64 (pow.f64 im 4) (pow.f64 re 3)) 1/8)): 0 points increase in error, 0 points decrease in error
      (fma.f64 (Rewrite<= associate-/l*_binary64 (/.f64 (*.f64 im im) re)) -1/2 (*.f64 (/.f64 (pow.f64 im 4) (pow.f64 re 3)) 1/8)): 13 points increase in error, 16 points decrease in error
      (fma.f64 (/.f64 (Rewrite<= unpow2_binary64 (pow.f64 im 2)) re) -1/2 (*.f64 (/.f64 (pow.f64 im 4) (pow.f64 re 3)) 1/8)): 0 points increase in error, 0 points decrease in error
      (fma.f64 (/.f64 (pow.f64 im 2) re) -1/2 (Rewrite<= *-commutative_binary64 (*.f64 1/8 (/.f64 (pow.f64 im 4) (pow.f64 re 3))))): 0 points increase in error, 0 points decrease in error
      (Rewrite<= fma-def_binary64 (+.f64 (*.f64 (/.f64 (pow.f64 im 2) re) -1/2) (*.f64 1/8 (/.f64 (pow.f64 im 4) (pow.f64 re 3))))): 0 points increase in error, 0 points decrease in error
      (+.f64 (Rewrite<= *-commutative_binary64 (*.f64 -1/2 (/.f64 (pow.f64 im 2) re))) (*.f64 1/8 (/.f64 (pow.f64 im 4) (pow.f64 re 3)))): 0 points increase in error, 0 points decrease in error
      (Rewrite<= +-commutative_binary64 (+.f64 (*.f64 1/8 (/.f64 (pow.f64 im 4) (pow.f64 re 3))) (*.f64 -1/2 (/.f64 (pow.f64 im 2) re)))): 0 points increase in error, 0 points decrease in error

   5. Applied egg-rr 39.5

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

   if -950 < re

   1. Initial program 32.6

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

   2. Simplified 5.5

      \[\leadsto \color{blue}{0.5 \cdot \sqrt{2 \cdot \left(re + \mathsf{hypot}\left(re, im\right)\right)}} \]
      Proof
      (*.f64 1/2 (sqrt.f64 (*.f64 2 (+.f64 re (hypot.f64 re im))))): 0 points increase in error, 0 points decrease in error
      (*.f64 1/2 (sqrt.f64 (*.f64 2 (+.f64 re (Rewrite<= hypot-def_binary64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))))): 129 points increase in error, 1 points decrease in error
      (*.f64 1/2 (sqrt.f64 (*.f64 2 (Rewrite<= +-commutative_binary64 (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))): 0 points increase in error, 0 points decrease in error
3. Recombined 4 regimes into one program.

4. Final simplification 11.4

   \[\leadsto \begin{array}{l} \mathbf{if}\;re \leq -3.6 \cdot 10^{+196}:\\ \;\;\;\;0.5 \cdot \sqrt{\frac{im}{re} \cdot \left(-im\right)}\\ \mathbf{elif}\;re \leq -4 \cdot 10^{+101}:\\ \;\;\;\;0.5 \cdot {\left(\frac{\sqrt[3]{im \cdot \left(-im\right)}}{\sqrt[3]{re}}\right)}^{1.5}\\ \mathbf{elif}\;re \leq -950:\\ \;\;\;\;0.5 \cdot \sqrt{2 \cdot \mathsf{fma}\left(\frac{im}{\frac{re}{im}}, -0.5, \left(\frac{im \cdot im}{re \cdot re} \cdot \left(im \cdot \frac{im}{re}\right)\right) \cdot 0.125\right)}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \sqrt{2 \cdot \left(re + \mathsf{hypot}\left(re, im\right)\right)}\\ \end{array} \]

Alternatives

Alternative 1
Error	11.6
Cost	13444

\[\begin{array}{l} \mathbf{if}\;re \leq -170:\\ \;\;\;\;0.5 \cdot \sqrt{\frac{im}{re} \cdot \left(-im\right)}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \sqrt{2 \cdot \left(re + \mathsf{hypot}\left(re, im\right)\right)}\\ \end{array} \]

Alternative 2
Error	30.9
Cost	8036

\[\begin{array}{l} t_0 := 0.5 \cdot \sqrt{im \cdot 2}\\ t_1 := 0.5 \cdot \sqrt{\frac{im}{re} \cdot \left(-im\right)}\\ t_2 := 0.5 \cdot \sqrt{2 \cdot \left(re + im\right)}\\ t_3 := 0.5 \cdot \sqrt{im \cdot -2}\\ t_4 := 0.5 \cdot \left(2 \cdot \sqrt{re}\right)\\ \mathbf{if}\;re \leq -1.7 \cdot 10^{-35}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;re \leq -1.4 \cdot 10^{-71}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;re \leq -3.9 \cdot 10^{-78}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;re \leq -3 \cdot 10^{-276}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;re \leq 2.8 \cdot 10^{-288}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;re \leq 1.05 \cdot 10^{-254}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;re \leq 1.55 \cdot 10^{-199}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;re \leq 1.6 \cdot 10^{-138}:\\ \;\;\;\;t_4\\ \mathbf{elif}\;re \leq 1.15 \cdot 10^{-34}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_4\\ \end{array} \]

Alternative 3
Error	31.1
Cost	8036

\[\begin{array}{l} t_0 := 0.5 \cdot \left(2 \cdot \sqrt{re}\right)\\ t_1 := 0.5 \cdot \sqrt{im \cdot 2}\\ t_2 := 0.5 \cdot \sqrt{2 \cdot \left(re + im\right)}\\ \mathbf{if}\;re \leq -9 \cdot 10^{-36}:\\ \;\;\;\;0.5 \cdot \sqrt{\frac{im}{re} \cdot \left(-im\right)}\\ \mathbf{elif}\;re \leq -2.2 \cdot 10^{-71}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;re \leq -1.25 \cdot 10^{-116}:\\ \;\;\;\;0.5 \cdot \left(im \cdot {\left(\frac{-1}{re}\right)}^{0.5}\right)\\ \mathbf{elif}\;re \leq -1.68 \cdot 10^{-273}:\\ \;\;\;\;0.5 \cdot \sqrt{2 \cdot \left(re - im\right)}\\ \mathbf{elif}\;re \leq 3.7 \cdot 10^{-290}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;re \leq 4.1 \cdot 10^{-254}:\\ \;\;\;\;0.5 \cdot \sqrt{im \cdot -2}\\ \mathbf{elif}\;re \leq 1.55 \cdot 10^{-199}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;re \leq 5.1 \cdot 10^{-139}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;re \leq 9.8 \cdot 10^{-33}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_0\\ \end{array} \]

Alternative 4
Error	31.0
Cost	8036

\[\begin{array}{l} t_0 := 0.5 \cdot \sqrt{im \cdot 2}\\ t_1 := 0.5 \cdot \sqrt{2 \cdot \left(re + im\right)}\\ t_2 := 0.5 \cdot \left(2 \cdot \sqrt{re}\right)\\ \mathbf{if}\;re \leq -1.75 \cdot 10^{-35}:\\ \;\;\;\;0.5 \cdot \sqrt{\frac{im}{re} \cdot \left(-im\right)}\\ \mathbf{elif}\;re \leq -2.3 \cdot 10^{-70}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;re \leq -1.05 \cdot 10^{-117}:\\ \;\;\;\;0.5 \cdot \left(im \cdot {\left(\frac{-1}{re}\right)}^{0.5}\right)\\ \mathbf{elif}\;re \leq -1.15 \cdot 10^{-273}:\\ \;\;\;\;0.5 \cdot \sqrt{2 \cdot \left(\frac{re \cdot -0.5}{\frac{im}{re}} + \left(re - im\right)\right)}\\ \mathbf{elif}\;re \leq 1.22 \cdot 10^{-287}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;re \leq 1.06 \cdot 10^{-252}:\\ \;\;\;\;0.5 \cdot \sqrt{im \cdot -2}\\ \mathbf{elif}\;re \leq 1.55 \cdot 10^{-199}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;re \leq 1.7 \cdot 10^{-138}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;re \leq 3.7 \cdot 10^{-35}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \]

Alternative 5
Error	26.5
Cost	7376

\[\begin{array}{l} t_0 := 0.5 \cdot \sqrt{im \cdot -2}\\ t_1 := 0.5 \cdot \left(2 \cdot \sqrt{re}\right)\\ \mathbf{if}\;im \leq -1.4 \cdot 10^{-25}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;im \leq -7.2 \cdot 10^{-46}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;im \leq -3.4 \cdot 10^{-112}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;im \leq 7.8 \cdot 10^{-63}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \sqrt{2 \cdot \left(re + im\right)}\\ \end{array} \]

Alternative 6
Error	26.7
Cost	7248

\[\begin{array}{l} t_0 := 0.5 \cdot \sqrt{im \cdot -2}\\ t_1 := 0.5 \cdot \left(2 \cdot \sqrt{re}\right)\\ \mathbf{if}\;im \leq -7.8 \cdot 10^{-26}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;im \leq -9.5 \cdot 10^{-44}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;im \leq -1.9 \cdot 10^{-113}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;im \leq 2.75 \cdot 10^{-65}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \sqrt{im \cdot 2}\\ \end{array} \]

Alternative 7
Error	37.0
Cost	7116

\[\begin{array}{l} t_0 := 0.5 \cdot \sqrt{im \cdot 2}\\ t_1 := 0.5 \cdot \left(2 \cdot \sqrt{re}\right)\\ \mathbf{if}\;re \leq 8.8 \cdot 10^{-200}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;re \leq 3.4 \cdot 10^{-139}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;re \leq 1.8 \cdot 10^{-35}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \]

Alternative 8
Error	26.0
Cost	7112

\[\begin{array}{l} \mathbf{if}\;im \leq -1.62 \cdot 10^{-167}:\\ \;\;\;\;0.5 \cdot \sqrt{2 \cdot \left(re - im\right)}\\ \mathbf{elif}\;im \leq 1.9 \cdot 10^{-68}:\\ \;\;\;\;0.5 \cdot \left(2 \cdot \sqrt{re}\right)\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \sqrt{2 \cdot \left(re + im\right)}\\ \end{array} \]

Alternative 9
Error	47.3
Cost	6720

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

Reproduce

herbie shell --seed 2022329 
(FPCore (re im)
  :name "math.sqrt on complex, real part"
  :precision binary64

  :herbie-target
  (if (< re 0.0) (* 0.5 (* (sqrt 2.0) (sqrt (/ (* im im) (- (sqrt (+ (* re re) (* im im))) re))))) (* 0.5 (sqrt (* 2.0 (+ (sqrt (+ (* re re) (* im im))) re)))))

  (* 0.5 (sqrt (* 2.0 (+ (sqrt (+ (* re re) (* im im))) re)))))