Henrywood and Agarwal, Equation (9a)

Percentage Accurate: 81.3% → 81.3%

Time: 3.2s

Alternatives: 7

Speedup: 1.0×

Specification

\[\mathsf{TRUE}\left(\right)\]

Math

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

FPCore

(FPCore (w0 M D h l d)
 :precision binary64
 (* w0 (sqrt (- 1.0 (* (pow (/ (* M D) (* 2.0 d)) 2.0) (/ h l))))))

C

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))));
}

Fortran

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

Java

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))));
}

Python

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))))

Julia

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

MATLAB

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

Wolfram

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]

Initial Program: 81.3% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (w0 M D h l d)
 :precision binary64
 (* w0 (sqrt (- 1.0 (* (pow (/ (* M D) (* 2.0 d)) 2.0) (/ h l))))))

C

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))));
}

Fortran

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

Java

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))));
}

Python

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))))

Julia

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

MATLAB

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

Wolfram

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]

Alternative 1: 81.3% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (w0 M D h l d)
 :precision binary64
 (* w0 (sqrt (- 1.0 (* (pow (/ (* M D) (* 2.0 d)) 2.0) (/ h l))))))

C

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))));
}

Fortran

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

Java

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))));
}

Python

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))))

Julia

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

MATLAB

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

Wolfram

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]

Derivation

1. Initial program 78.7%

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

Alternative 2: 16.6% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := {\left(\frac{M \cdot D}{2 \cdot d}\right)}^{2} \cdot \frac{h}{\ell}\\ t_1 := 1 - t\_0\\ \mathbf{if}\;w0 \cdot \sqrt{t\_1} \leq 5 \cdot 10^{-156}:\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (w0 M D h l d)
 :precision binary64
 (let* ((t_0 (* (pow (/ (* M D) (* 2.0 d)) 2.0) (/ h l))) (t_1 (- 1.0 t_0)))
   (if (<= (* w0 (sqrt t_1)) 5e-156) t_0 t_1)))

C

double code(double w0, double M, double D, double h, double l, double d) {
	double t_0 = pow(((M * D) / (2.0 * d)), 2.0) * (h / l);
	double t_1 = 1.0 - t_0;
	double tmp;
	if ((w0 * sqrt(t_1)) <= 5e-156) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

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
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = (((m * d) / (2.0d0 * d_1)) ** 2.0d0) * (h / l)
    t_1 = 1.0d0 - t_0
    if ((w0 * sqrt(t_1)) <= 5d-156) then
        tmp = t_0
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double w0, double M, double D, double h, double l, double d) {
	double t_0 = Math.pow(((M * D) / (2.0 * d)), 2.0) * (h / l);
	double t_1 = 1.0 - t_0;
	double tmp;
	if ((w0 * Math.sqrt(t_1)) <= 5e-156) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(w0, M, D, h, l, d):
	t_0 = math.pow(((M * D) / (2.0 * d)), 2.0) * (h / l)
	t_1 = 1.0 - t_0
	tmp = 0
	if (w0 * math.sqrt(t_1)) <= 5e-156:
		tmp = t_0
	else:
		tmp = t_1
	return tmp

Julia

function code(w0, M, D, h, l, d)
	t_0 = Float64((Float64(Float64(M * D) / Float64(2.0 * d)) ^ 2.0) * Float64(h / l))
	t_1 = Float64(1.0 - t_0)
	tmp = 0.0
	if (Float64(w0 * sqrt(t_1)) <= 5e-156)
		tmp = t_0;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(w0, M, D, h, l, d)
	t_0 = (((M * D) / (2.0 * d)) ^ 2.0) * (h / l);
	t_1 = 1.0 - t_0;
	tmp = 0.0;
	if ((w0 * sqrt(t_1)) <= 5e-156)
		tmp = t_0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[w0_, M_, D_, h_, l_, d_] := Block[{t$95$0 = N[(N[Power[N[(N[(M * D), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(1.0 - t$95$0), $MachinePrecision]}, If[LessEqual[N[(w0 * N[Sqrt[t$95$1], $MachinePrecision]), $MachinePrecision], 5e-156], t$95$0, t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if (*.f64 w0 (sqrt.f64 (-.f64 #s(literal 1 binary64) (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l))))) < 5.00000000000000007e-156

   1. Initial program 91.0%

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

   3. Taylor expanded in M around 0

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

   5. Applied rewrites 16.9%

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

   if 5.00000000000000007e-156 < (*.f64 w0 (sqrt.f64 (-.f64 #s(literal 1 binary64) (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)))))

   1. Initial program 64.3%

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

   3. Taylor expanded in M around 0

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

   5. Applied rewrites 11.9%

      \[\leadsto \color{blue}{1 - {\left(\frac{M \cdot D}{2 \cdot d}\right)}^{2} \cdot \frac{h}{\ell}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 3: 15.9% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := {\left(\frac{M \cdot D}{2 \cdot d}\right)}^{2}\\ t_1 := t\_0 \cdot \frac{h}{\ell}\\ \mathbf{if}\;w0 \cdot \sqrt{1 - t\_1} \leq 5 \cdot 10^{-282}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (w0 M D h l d)
 :precision binary64
 (let* ((t_0 (pow (/ (* M D) (* 2.0 d)) 2.0)) (t_1 (* t_0 (/ h l))))
   (if (<= (* w0 (sqrt (- 1.0 t_1))) 5e-282) t_1 t_0)))

C

double code(double w0, double M, double D, double h, double l, double d) {
	double t_0 = pow(((M * D) / (2.0 * d)), 2.0);
	double t_1 = t_0 * (h / l);
	double tmp;
	if ((w0 * sqrt((1.0 - t_1))) <= 5e-282) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

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
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ((m * d) / (2.0d0 * d_1)) ** 2.0d0
    t_1 = t_0 * (h / l)
    if ((w0 * sqrt((1.0d0 - t_1))) <= 5d-282) then
        tmp = t_1
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double w0, double M, double D, double h, double l, double d) {
	double t_0 = Math.pow(((M * D) / (2.0 * d)), 2.0);
	double t_1 = t_0 * (h / l);
	double tmp;
	if ((w0 * Math.sqrt((1.0 - t_1))) <= 5e-282) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(w0, M, D, h, l, d):
	t_0 = math.pow(((M * D) / (2.0 * d)), 2.0)
	t_1 = t_0 * (h / l)
	tmp = 0
	if (w0 * math.sqrt((1.0 - t_1))) <= 5e-282:
		tmp = t_1
	else:
		tmp = t_0
	return tmp

Julia

function code(w0, M, D, h, l, d)
	t_0 = Float64(Float64(M * D) / Float64(2.0 * d)) ^ 2.0
	t_1 = Float64(t_0 * Float64(h / l))
	tmp = 0.0
	if (Float64(w0 * sqrt(Float64(1.0 - t_1))) <= 5e-282)
		tmp = t_1;
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(w0, M, D, h, l, d)
	t_0 = ((M * D) / (2.0 * d)) ^ 2.0;
	t_1 = t_0 * (h / l);
	tmp = 0.0;
	if ((w0 * sqrt((1.0 - t_1))) <= 5e-282)
		tmp = t_1;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[w0_, M_, D_, h_, l_, d_] := Block[{t$95$0 = N[Power[N[(N[(M * D), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 * N[(h / l), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(w0 * N[Sqrt[N[(1.0 - t$95$1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 5e-282], t$95$1, t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if (*.f64 w0 (sqrt.f64 (-.f64 #s(literal 1 binary64) (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l))))) < 5.0000000000000001e-282

   1. Initial program 89.7%

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

   3. Taylor expanded in M around 0

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

   5. Applied rewrites 18.7%

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

   if 5.0000000000000001e-282 < (*.f64 w0 (sqrt.f64 (-.f64 #s(literal 1 binary64) (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)))))

   1. Initial program 69.0%

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

   3. Taylor expanded in M around 0

      \[\leadsto \color{blue}{w0} \]

   5. Applied rewrites 10.8%

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

   6. Taylor expanded in M around 0

      \[\leadsto 1 \]

   8. Applied rewrites 9.7%

      \[\leadsto {\left(\frac{M \cdot D}{2 \cdot d}\right)}^{\color{blue}{2}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 4: 11.3% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{M \cdot D}{2 \cdot d}\\ \mathbf{if}\;w0 \leq -1.95 \cdot 10^{-306}:\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;{t\_0}^{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (w0 M D h l d)
 :precision binary64
 (let* ((t_0 (/ (* M D) (* 2.0 d))))
   (if (<= w0 -1.95e-306) t_0 (pow t_0 2.0))))

C

double code(double w0, double M, double D, double h, double l, double d) {
	double t_0 = (M * D) / (2.0 * d);
	double tmp;
	if (w0 <= -1.95e-306) {
		tmp = t_0;
	} else {
		tmp = pow(t_0, 2.0);
	}
	return tmp;
}

Fortran

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
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (m * d) / (2.0d0 * d_1)
    if (w0 <= (-1.95d-306)) then
        tmp = t_0
    else
        tmp = t_0 ** 2.0d0
    end if
    code = tmp
end function

Java

public static double code(double w0, double M, double D, double h, double l, double d) {
	double t_0 = (M * D) / (2.0 * d);
	double tmp;
	if (w0 <= -1.95e-306) {
		tmp = t_0;
	} else {
		tmp = Math.pow(t_0, 2.0);
	}
	return tmp;
}

Python

def code(w0, M, D, h, l, d):
	t_0 = (M * D) / (2.0 * d)
	tmp = 0
	if w0 <= -1.95e-306:
		tmp = t_0
	else:
		tmp = math.pow(t_0, 2.0)
	return tmp

Julia

function code(w0, M, D, h, l, d)
	t_0 = Float64(Float64(M * D) / Float64(2.0 * d))
	tmp = 0.0
	if (w0 <= -1.95e-306)
		tmp = t_0;
	else
		tmp = t_0 ^ 2.0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(w0, M, D, h, l, d)
	t_0 = (M * D) / (2.0 * d);
	tmp = 0.0;
	if (w0 <= -1.95e-306)
		tmp = t_0;
	else
		tmp = t_0 ^ 2.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[w0_, M_, D_, h_, l_, d_] := Block[{t$95$0 = N[(N[(M * D), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[w0, -1.95e-306], t$95$0, N[Power[t$95$0, 2.0], $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if w0 < -1.95e-306

   1. Initial program 79.7%

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

   3. Taylor expanded in M around 0

      \[\leadsto \color{blue}{w0 + {M}^{2} \cdot \left(\frac{-1}{8} \cdot \frac{{D}^{2} \cdot \left(h \cdot w0\right)}{{d}^{2} \cdot \ell} + {M}^{2} \cdot \left(\frac{-1}{128} \cdot \frac{{D}^{4} \cdot \left({h}^{2} \cdot w0\right)}{{d}^{4} \cdot {\ell}^{2}} + \frac{-1}{1024} \cdot \frac{{D}^{6} \cdot \left({M}^{2} \cdot \left({h}^{3} \cdot w0\right)\right)}{{d}^{6} \cdot {\ell}^{3}}\right)\right)} \]

   5. Applied rewrites 10.2%

      \[\leadsto \color{blue}{\frac{M \cdot D}{2 \cdot d}} \]

   if -1.95e-306 < w0

   1. Initial program 77.7%

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

   3. Taylor expanded in M around 0

      \[\leadsto \color{blue}{w0} \]

   5. Applied rewrites 11.7%

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

   6. Taylor expanded in M around 0

      \[\leadsto 1 \]

   8. Applied rewrites 10.6%

      \[\leadsto {\left(\frac{M \cdot D}{2 \cdot d}\right)}^{\color{blue}{2}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 5: 7.5% accurate, 7.1× speedup

Math

\[\begin{array}{l} \\ \frac{M \cdot D}{2 \cdot d} \end{array} \]

FPCore

(FPCore (w0 M D h l d) :precision binary64 (/ (* M D) (* 2.0 d)))

C

double code(double w0, double M, double D, double h, double l, double d) {
	return (M * D) / (2.0 * d);
}

Fortran

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 = (m * d) / (2.0d0 * d_1)
end function

Java

public static double code(double w0, double M, double D, double h, double l, double d) {
	return (M * D) / (2.0 * d);
}

Python

def code(w0, M, D, h, l, d):
	return (M * D) / (2.0 * d)

Julia

function code(w0, M, D, h, l, d)
	return Float64(Float64(M * D) / Float64(2.0 * d))
end

MATLAB

function tmp = code(w0, M, D, h, l, d)
	tmp = (M * D) / (2.0 * d);
end

Wolfram

code[w0_, M_, D_, h_, l_, d_] := N[(N[(M * D), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 78.7%

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

3. Taylor expanded in M around 0

   \[\leadsto \color{blue}{w0 + {M}^{2} \cdot \left(\frac{-1}{8} \cdot \frac{{D}^{2} \cdot \left(h \cdot w0\right)}{{d}^{2} \cdot \ell} + {M}^{2} \cdot \left(\frac{-1}{128} \cdot \frac{{D}^{4} \cdot \left({h}^{2} \cdot w0\right)}{{d}^{4} \cdot {\ell}^{2}} + \frac{-1}{1024} \cdot \frac{{D}^{6} \cdot \left({M}^{2} \cdot \left({h}^{3} \cdot w0\right)\right)}{{d}^{6} \cdot {\ell}^{3}}\right)\right)} \]

5. Applied rewrites 7.6%

   \[\leadsto \color{blue}{\frac{M \cdot D}{2 \cdot d}} \]
6. Add Preprocessing

Alternative 6: 6.0% accurate, 26.2× speedup

Math

\[\begin{array}{l} \\ M \cdot D \end{array} \]

FPCore

(FPCore (w0 M D h l d) :precision binary64 (* M D))

C

double code(double w0, double M, double D, double h, double l, double d) {
	return M * D;
}

Fortran

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 = m * d
end function

Java

public static double code(double w0, double M, double D, double h, double l, double d) {
	return M * D;
}

Python

def code(w0, M, D, h, l, d):
	return M * D

Julia

function code(w0, M, D, h, l, d)
	return Float64(M * D)
end

MATLAB

function tmp = code(w0, M, D, h, l, d)
	tmp = M * D;
end

Wolfram

code[w0_, M_, D_, h_, l_, d_] := N[(M * D), $MachinePrecision]

Derivation

1. Initial program 78.7%

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

3. Taylor expanded in M around 0

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

5. Applied rewrites 6.4%

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

6. Taylor expanded in M around 0

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

8. Applied rewrites 4.8%

   \[\leadsto M \cdot \color{blue}{D} \]
9. Add Preprocessing

Alternative 7: 3.0% accurate, 26.2× speedup

Math

\[\begin{array}{l} \\ 2 \cdot d \end{array} \]

FPCore

(FPCore (w0 M D h l d) :precision binary64 (* 2.0 d))

C

double code(double w0, double M, double D, double h, double l, double d) {
	return 2.0 * d;
}

Fortran

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 = 2.0d0 * d_1
end function

Java

public static double code(double w0, double M, double D, double h, double l, double d) {
	return 2.0 * d;
}

Python

def code(w0, M, D, h, l, d):
	return 2.0 * d

Julia

function code(w0, M, D, h, l, d)
	return Float64(2.0 * d)
end

MATLAB

function tmp = code(w0, M, D, h, l, d)
	tmp = 2.0 * d;
end

Wolfram

code[w0_, M_, D_, h_, l_, d_] := N[(2.0 * d), $MachinePrecision]

Derivation

1. Initial program 78.7%

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

3. Taylor expanded in M around 0

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

5. Applied rewrites 9.9%

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

6. Taylor expanded in M around 0

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

8. Applied rewrites 3.0%

   \[\leadsto 2 \cdot \color{blue}{d} \]
9. Add Preprocessing

Reproduce

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