sqrt D (should all be same)

Average Error: 30.0 → 0.0

Time: 2.7s

Precision: binary64

Cost: 6528

Math

\[\sqrt{2 \cdot {x}^{2}} \]

↓

\[\mathsf{hypot}\left(x, x\right) \]

FPCore

(FPCore (x) :precision binary64 (sqrt (* 2.0 (pow x 2.0))))

↓

(FPCore (x) :precision binary64 (hypot x x))

C

double code(double x) {
	return sqrt((2.0 * pow(x, 2.0)));
}

↓

double code(double x) {
	return hypot(x, x);
}

Java

public static double code(double x) {
	return Math.sqrt((2.0 * Math.pow(x, 2.0)));
}

↓

public static double code(double x) {
	return Math.hypot(x, x);
}

Python

def code(x):
	return math.sqrt((2.0 * math.pow(x, 2.0)))

↓

def code(x):
	return math.hypot(x, x)

Julia

function code(x)
	return sqrt(Float64(2.0 * (x ^ 2.0)))
end

↓

function code(x)
	return hypot(x, x)
end

MATLAB

function tmp = code(x)
	tmp = sqrt((2.0 * (x ^ 2.0)));
end

↓

function tmp = code(x)
	tmp = hypot(x, x);
end

Wolfram

code[x_] := N[Sqrt[N[(2.0 * N[Power[x, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]

↓

code[x_] := N[Sqrt[x ^ 2 + x ^ 2], $MachinePrecision]

Derivation

1. Initial program 30.0

   \[\sqrt{2 \cdot {x}^{2}} \]

2. Applied egg-rr 30.4

   \[\leadsto \sqrt{2 \cdot \color{blue}{\left({\left(\sqrt[3]{x}\right)}^{2} \cdot \left(\sqrt[3]{x} \cdot x\right)\right)}} \]

3. Taylor expanded in x around 0 31.9

   \[\leadsto \color{blue}{\sqrt{2} \cdot x} \]

4. Simplified 0.0

   \[\leadsto \color{blue}{\mathsf{hypot}\left(x, x\right)} \]
   Proof
   (hypot.f64 x x): 0 points increase in error, 0 points decrease in error
   (Rewrite<= hypot-def_binary64 (sqrt.f64 (+.f64 (*.f64 x x) (*.f64 x x)))): 138 points increase in error, 1 points decrease in error
   (sqrt.f64 (Rewrite=> count-2_binary64 (*.f64 2 (*.f64 x x)))): 0 points increase in error, 0 points decrease in error
   (sqrt.f64 (Rewrite=> *-commutative_binary64 (*.f64 (*.f64 x x) 2))): 0 points increase in error, 0 points decrease in error
   (sqrt.f64 (*.f64 (*.f64 x x) (Rewrite<= rem-square-sqrt_binary64 (*.f64 (sqrt.f64 2) (sqrt.f64 2))))): 85 points increase in error, 10 points decrease in error
   (sqrt.f64 (Rewrite<= swap-sqr_binary64 (*.f64 (*.f64 x (sqrt.f64 2)) (*.f64 x (sqrt.f64 2))))): 3 points increase in error, 36 points decrease in error
   (Rewrite=> rem-sqrt-square_binary64 (fabs.f64 (*.f64 x (sqrt.f64 2)))): 0 points increase in error, 121 points decrease in error
   (fabs.f64 (Rewrite<= rem-square-sqrt_binary64 (*.f64 (sqrt.f64 (*.f64 x (sqrt.f64 2))) (sqrt.f64 (*.f64 x (sqrt.f64 2)))))): 179 points increase in error, 13 points decrease in error
   (Rewrite=> fabs-sqr_binary64 (*.f64 (sqrt.f64 (*.f64 x (sqrt.f64 2))) (sqrt.f64 (*.f64 x (sqrt.f64 2))))): 0 points increase in error, 0 points decrease in error
   (Rewrite=> rem-square-sqrt_binary64 (*.f64 x (sqrt.f64 2))): 13 points increase in error, 179 points decrease in error
   (Rewrite<= *-commutative_binary64 (*.f64 (sqrt.f64 2) x)): 0 points increase in error, 0 points decrease in error

5. Final simplification 0.0

   \[\leadsto \mathsf{hypot}\left(x, x\right) \]

Alternatives

Alternative 1
Error	55.9
Cost	452

\[\begin{array}{l} \mathbf{if}\;x \leq -5 \cdot 10^{-310}:\\ \;\;\;\;x \cdot \left(x + x\right)\\ \mathbf{else}:\\ \;\;\;\;x + x\\ \end{array} \]

Alternative 2
Error	56.9
Cost	192

\[x + x \]

Alternative 3
Error	62.9
Cost	64

\[-2 \]

Reproduce

herbie shell --seed 2022332 
(FPCore (x)
  :name "sqrt D (should all be same)"
  :precision binary64
  (sqrt (* 2.0 (pow x 2.0))))