Average Error: 13.7 → 8.3
Time: 11.2s
Precision: binary64
\[w0 \cdot \sqrt{1 - {\left(\frac{M \cdot D}{2 \cdot d}\right)}^{2} \cdot \frac{h}{\ell}} \]
↓
\[w0 \cdot \sqrt{1 - {\left(\ell \cdot \frac{2 \cdot d}{M \cdot D}\right)}^{-1} \cdot \frac{\frac{M \cdot D}{2 \cdot d}}{\frac{1}{h}}} \]
(FPCore (w0 M D h l d)
 :precision binary64
 (* w0 (sqrt (- 1.0 (* (pow (/ (* M D) (* 2.0 d)) 2.0) (/ h l))))))
↓
(FPCore (w0 M D h l d)
 :precision binary64
 (*
  w0
  (sqrt
   (-
    1.0
    (*
     (pow (* l (/ (* 2.0 d) (* M D))) -1.0)
     (/ (/ (* M D) (* 2.0 d)) (/ 1.0 h)))))))
double code(double w0, double M, double D, double h, double l, double d) {
	return w0 * sqrt((1.0 - (pow(((M * D) / (2.0 * d)), 2.0) * (h / l))));
}
↓
double code(double w0, double M, double D, double h, double l, double d) {
	return w0 * sqrt((1.0 - (pow((l * ((2.0 * d) / (M * D))), -1.0) * (((M * D) / (2.0 * d)) / (1.0 / h)))));
}

real(8) function code(w0, m, d, h, l, d_1)
    real(8), intent (in) :: w0
    real(8), intent (in) :: m
    real(8), intent (in) :: d
    real(8), intent (in) :: h
    real(8), intent (in) :: l
    real(8), intent (in) :: d_1
    code = w0 * sqrt((1.0d0 - ((((m * d) / (2.0d0 * d_1)) ** 2.0d0) * (h / l))))
end function
↓
real(8) function code(w0, m, d, h, l, d_1)
    real(8), intent (in) :: w0
    real(8), intent (in) :: m
    real(8), intent (in) :: d
    real(8), intent (in) :: h
    real(8), intent (in) :: l
    real(8), intent (in) :: d_1
    code = w0 * sqrt((1.0d0 - (((l * ((2.0d0 * d_1) / (m * d))) ** (-1.0d0)) * (((m * d) / (2.0d0 * d_1)) / (1.0d0 / h)))))
end function

public static double code(double w0, double M, double D, double h, double l, double d) {
	return w0 * Math.sqrt((1.0 - (Math.pow(((M * D) / (2.0 * d)), 2.0) * (h / l))));
}
↓
public static double code(double w0, double M, double D, double h, double l, double d) {
	return w0 * Math.sqrt((1.0 - (Math.pow((l * ((2.0 * d) / (M * D))), -1.0) * (((M * D) / (2.0 * d)) / (1.0 / h)))));
}

def code(w0, M, D, h, l, d):
	return w0 * math.sqrt((1.0 - (math.pow(((M * D) / (2.0 * d)), 2.0) * (h / l))))
↓
def code(w0, M, D, h, l, d):
	return w0 * math.sqrt((1.0 - (math.pow((l * ((2.0 * d) / (M * D))), -1.0) * (((M * D) / (2.0 * d)) / (1.0 / h)))))

function code(w0, M, D, h, l, d)
	return Float64(w0 * sqrt(Float64(1.0 - Float64((Float64(Float64(M * D) / Float64(2.0 * d)) ^ 2.0) * Float64(h / l)))))
end
↓
function code(w0, M, D, h, l, d)
	return Float64(w0 * sqrt(Float64(1.0 - Float64((Float64(l * Float64(Float64(2.0 * d) / Float64(M * D))) ^ -1.0) * Float64(Float64(Float64(M * D) / Float64(2.0 * d)) / Float64(1.0 / h))))))
end

function tmp = code(w0, M, D, h, l, d)
	tmp = w0 * sqrt((1.0 - ((((M * D) / (2.0 * d)) ^ 2.0) * (h / l))));
end
↓
function tmp = code(w0, M, D, h, l, d)
	tmp = w0 * sqrt((1.0 - (((l * ((2.0 * d) / (M * D))) ^ -1.0) * (((M * D) / (2.0 * d)) / (1.0 / h)))));
end

code[w0_, M_, D_, h_, l_, d_] := N[(w0 * N[Sqrt[N[(1.0 - N[(N[Power[N[(N[(M * D), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
↓
code[w0_, M_, D_, h_, l_, d_] := N[(w0 * N[Sqrt[N[(1.0 - N[(N[Power[N[(l * N[(N[(2.0 * d), $MachinePrecision] / N[(M * D), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -1.0], $MachinePrecision] * N[(N[(N[(M * D), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision] / N[(1.0 / h), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

w0 \cdot \sqrt{1 - {\left(\frac{M \cdot D}{2 \cdot d}\right)}^{2} \cdot \frac{h}{\ell}}
↓
w0 \cdot \sqrt{1 - {\left(\ell \cdot \frac{2 \cdot d}{M \cdot D}\right)}^{-1} \cdot \frac{\frac{M \cdot D}{2 \cdot d}}{\frac{1}{h}}}

Error

Bits error versus w0

Bits error versus M

Bits error versus D

Bits error versus h

Bits error versus l

Bits error versus d

Try it out

Your Program's Arguments

Results

Enter valid numbers for all inputs

Derivation

  1. Initial program 13.7

    \[w0 \cdot \sqrt{1 - {\left(\frac{M \cdot D}{2 \cdot d}\right)}^{2} \cdot \frac{h}{\ell}} \]

  2. Applied egg-rr13.4

    \[\leadsto w0 \cdot \sqrt{1 - \color{blue}{\frac{{\left(\frac{M \cdot D}{2 \cdot d}\right)}^{2}}{\frac{\ell}{h}}}} \]

  3. Applied egg-rr8.3

    \[\leadsto w0 \cdot \sqrt{1 - \color{blue}{\frac{\frac{M \cdot D}{2 \cdot d}}{\ell} \cdot \frac{\frac{M \cdot D}{2 \cdot d}}{\frac{1}{h}}}} \]

  4. Applied egg-rr8.3

    \[\leadsto w0 \cdot \sqrt{1 - \color{blue}{{\left(\ell \cdot \frac{2 \cdot d}{M \cdot D}\right)}^{-1}} \cdot \frac{\frac{M \cdot D}{2 \cdot d}}{\frac{1}{h}}} \]

  5. Final simplification8.3

    \[\leadsto w0 \cdot \sqrt{1 - {\left(\ell \cdot \frac{2 \cdot d}{M \cdot D}\right)}^{-1} \cdot \frac{\frac{M \cdot D}{2 \cdot d}}{\frac{1}{h}}} \]

Reproduce

herbie shell --seed 2022146 
(FPCore (w0 M D h l d)
  :name "Henrywood and Agarwal, Equation (9a)"
  :precision binary64
  (* w0 (sqrt (- 1.0 (* (pow (/ (* M D) (* 2.0 d)) 2.0) (/ h l))))))