Falkner and Boettcher, Equation (22+)

Percentage Accurate: 98.5% → 98.5%

Time: 2.0s

Alternatives: 4

Speedup: 0.3×

Specification

Math

\[\begin{array}{l} \\ \frac{4}{\left(\left(3 \cdot \pi\right) \cdot \left(1 - v \cdot v\right)\right) \cdot \sqrt{2 - 6 \cdot \left(v \cdot v\right)}} \end{array} \]

FPCore

(FPCore (v)
 :precision binary64
 (/ 4.0 (* (* (* 3.0 PI) (- 1.0 (* v v))) (sqrt (- 2.0 (* 6.0 (* v v)))))))

C

double code(double v) {
	return 4.0 / (((3.0 * ((double) M_PI)) * (1.0 - (v * v))) * sqrt((2.0 - (6.0 * (v * v)))));
}

Java

public static double code(double v) {
	return 4.0 / (((3.0 * Math.PI) * (1.0 - (v * v))) * Math.sqrt((2.0 - (6.0 * (v * v)))));
}

Python

def code(v):
	return 4.0 / (((3.0 * math.pi) * (1.0 - (v * v))) * math.sqrt((2.0 - (6.0 * (v * v)))))

Julia

function code(v)
	return Float64(4.0 / Float64(Float64(Float64(3.0 * pi) * Float64(1.0 - Float64(v * v))) * sqrt(Float64(2.0 - Float64(6.0 * Float64(v * v))))))
end

MATLAB

function tmp = code(v)
	tmp = 4.0 / (((3.0 * pi) * (1.0 - (v * v))) * sqrt((2.0 - (6.0 * (v * v)))));
end

Wolfram

code[v_] := N[(4.0 / N[(N[(N[(3.0 * Pi), $MachinePrecision] * N[(1.0 - N[(v * v), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(2.0 - N[(6.0 * N[(v * v), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Initial Program: 98.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{4}{\left(\left(3 \cdot \pi\right) \cdot \left(1 - v \cdot v\right)\right) \cdot \sqrt{2 - 6 \cdot \left(v \cdot v\right)}} \end{array} \]

FPCore

(FPCore (v)
 :precision binary64
 (/ 4.0 (* (* (* 3.0 PI) (- 1.0 (* v v))) (sqrt (- 2.0 (* 6.0 (* v v)))))))

C

double code(double v) {
	return 4.0 / (((3.0 * ((double) M_PI)) * (1.0 - (v * v))) * sqrt((2.0 - (6.0 * (v * v)))));
}

Java

public static double code(double v) {
	return 4.0 / (((3.0 * Math.PI) * (1.0 - (v * v))) * Math.sqrt((2.0 - (6.0 * (v * v)))));
}

Python

def code(v):
	return 4.0 / (((3.0 * math.pi) * (1.0 - (v * v))) * math.sqrt((2.0 - (6.0 * (v * v)))))

Julia

function code(v)
	return Float64(4.0 / Float64(Float64(Float64(3.0 * pi) * Float64(1.0 - Float64(v * v))) * sqrt(Float64(2.0 - Float64(6.0 * Float64(v * v))))))
end

MATLAB

function tmp = code(v)
	tmp = 4.0 / (((3.0 * pi) * (1.0 - (v * v))) * sqrt((2.0 - (6.0 * (v * v)))));
end

Wolfram

code[v_] := N[(4.0 / N[(N[(N[(3.0 * Pi), $MachinePrecision] * N[(1.0 - N[(v * v), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(2.0 - N[(6.0 * N[(v * v), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Alternative 1: 98.5% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{\pi}{\sqrt{2}}\\ t_1 := \pi \cdot \sqrt{2}\\ \frac{4}{\mathsf{fma}\left(3, t\_1, {v}^{2} \cdot \mathsf{fma}\left(3, {v}^{2} \cdot \mathsf{fma}\left(-4.5, \frac{\pi}{{\left(\sqrt{2}\right)}^{3}}, 3 \cdot t\_0\right), 3 \cdot \mathsf{fma}\left(-3, t\_0, -1 \cdot t\_1\right)\right)\right)} \end{array} \end{array} \]

FPCore

(FPCore (v)
 :precision binary64
 (let* ((t_0 (/ PI (sqrt 2.0))) (t_1 (* PI (sqrt 2.0))))
   (/
    4.0
    (fma
     3.0
     t_1
     (*
      (pow v 2.0)
      (fma
       3.0
       (* (pow v 2.0) (fma -4.5 (/ PI (pow (sqrt 2.0) 3.0)) (* 3.0 t_0)))
       (* 3.0 (fma -3.0 t_0 (* -1.0 t_1)))))))))

C

double code(double v) {
	double t_0 = ((double) M_PI) / sqrt(2.0);
	double t_1 = ((double) M_PI) * sqrt(2.0);
	return 4.0 / fma(3.0, t_1, (pow(v, 2.0) * fma(3.0, (pow(v, 2.0) * fma(-4.5, (((double) M_PI) / pow(sqrt(2.0), 3.0)), (3.0 * t_0))), (3.0 * fma(-3.0, t_0, (-1.0 * t_1))))));
}

Julia

function code(v)
	t_0 = Float64(pi / sqrt(2.0))
	t_1 = Float64(pi * sqrt(2.0))
	return Float64(4.0 / fma(3.0, t_1, Float64((v ^ 2.0) * fma(3.0, Float64((v ^ 2.0) * fma(-4.5, Float64(pi / (sqrt(2.0) ^ 3.0)), Float64(3.0 * t_0))), Float64(3.0 * fma(-3.0, t_0, Float64(-1.0 * t_1)))))))
end

Wolfram

code[v_] := Block[{t$95$0 = N[(Pi / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(Pi * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]}, N[(4.0 / N[(3.0 * t$95$1 + N[(N[Power[v, 2.0], $MachinePrecision] * N[(3.0 * N[(N[Power[v, 2.0], $MachinePrecision] * N[(-4.5 * N[(Pi / N[Power[N[Sqrt[2.0], $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision] + N[(3.0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(3.0 * N[(-3.0 * t$95$0 + N[(-1.0 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Initial program 98.5%

   \[\frac{4}{\left(\left(3 \cdot \pi\right) \cdot \left(1 - v \cdot v\right)\right) \cdot \sqrt{2 - 6 \cdot \left(v \cdot v\right)}} \]

2. Taylor expanded in v around 0

   \[\leadsto \frac{4}{\color{blue}{3 \cdot \left(\mathsf{PI}\left(\right) \cdot \sqrt{2}\right) + {v}^{2} \cdot \left(3 \cdot \left({v}^{2} \cdot \left(\frac{-9}{2} \cdot \frac{\mathsf{PI}\left(\right)}{{\left(\sqrt{2}\right)}^{3}} + 3 \cdot \frac{\mathsf{PI}\left(\right)}{\sqrt{2}}\right)\right) + 3 \cdot \left(-3 \cdot \frac{\mathsf{PI}\left(\right)}{\sqrt{2}} + -1 \cdot \left(\mathsf{PI}\left(\right) \cdot \sqrt{2}\right)\right)\right)}} \]
3. Step-by-step derivation

   1. lower-fma.f64 N/A

      \[\leadsto \frac{4}{\mathsf{fma}\left(3, \color{blue}{\mathsf{PI}\left(\right) \cdot \sqrt{2}}, {v}^{2} \cdot \left(3 \cdot \left({v}^{2} \cdot \left(\frac{-9}{2} \cdot \frac{\mathsf{PI}\left(\right)}{{\left(\sqrt{2}\right)}^{3}} + 3 \cdot \frac{\mathsf{PI}\left(\right)}{\sqrt{2}}\right)\right) + 3 \cdot \left(-3 \cdot \frac{\mathsf{PI}\left(\right)}{\sqrt{2}} + -1 \cdot \left(\mathsf{PI}\left(\right) \cdot \sqrt{2}\right)\right)\right)\right)} \]

   2. lower-*.f64 N/A

      \[\leadsto \frac{4}{\mathsf{fma}\left(3, \mathsf{PI}\left(\right) \cdot \color{blue}{\sqrt{2}}, {v}^{2} \cdot \left(3 \cdot \left({v}^{2} \cdot \left(\frac{-9}{2} \cdot \frac{\mathsf{PI}\left(\right)}{{\left(\sqrt{2}\right)}^{3}} + 3 \cdot \frac{\mathsf{PI}\left(\right)}{\sqrt{2}}\right)\right) + 3 \cdot \left(-3 \cdot \frac{\mathsf{PI}\left(\right)}{\sqrt{2}} + -1 \cdot \left(\mathsf{PI}\left(\right) \cdot \sqrt{2}\right)\right)\right)\right)} \]

   3. lift-PI.f64 N/A

      \[\leadsto \frac{4}{\mathsf{fma}\left(3, \pi \cdot \sqrt{\color{blue}{2}}, {v}^{2} \cdot \left(3 \cdot \left({v}^{2} \cdot \left(\frac{-9}{2} \cdot \frac{\mathsf{PI}\left(\right)}{{\left(\sqrt{2}\right)}^{3}} + 3 \cdot \frac{\mathsf{PI}\left(\right)}{\sqrt{2}}\right)\right) + 3 \cdot \left(-3 \cdot \frac{\mathsf{PI}\left(\right)}{\sqrt{2}} + -1 \cdot \left(\mathsf{PI}\left(\right) \cdot \sqrt{2}\right)\right)\right)\right)} \]

   4. lower-sqrt.f64 N/A

      \[\leadsto \frac{4}{\mathsf{fma}\left(3, \pi \cdot \sqrt{2}, {v}^{2} \cdot \left(3 \cdot \left({v}^{2} \cdot \left(\frac{-9}{2} \cdot \frac{\mathsf{PI}\left(\right)}{{\left(\sqrt{2}\right)}^{3}} + 3 \cdot \frac{\mathsf{PI}\left(\right)}{\sqrt{2}}\right)\right) + 3 \cdot \left(-3 \cdot \frac{\mathsf{PI}\left(\right)}{\sqrt{2}} + -1 \cdot \left(\mathsf{PI}\left(\right) \cdot \sqrt{2}\right)\right)\right)\right)} \]

   5. lower-*.f64 N/A

      \[\leadsto \frac{4}{\mathsf{fma}\left(3, \pi \cdot \sqrt{2}, {v}^{2} \cdot \left(3 \cdot \left({v}^{2} \cdot \left(\frac{-9}{2} \cdot \frac{\mathsf{PI}\left(\right)}{{\left(\sqrt{2}\right)}^{3}} + 3 \cdot \frac{\mathsf{PI}\left(\right)}{\sqrt{2}}\right)\right) + 3 \cdot \left(-3 \cdot \frac{\mathsf{PI}\left(\right)}{\sqrt{2}} + -1 \cdot \left(\mathsf{PI}\left(\right) \cdot \sqrt{2}\right)\right)\right)\right)} \]

4. Applied rewrites 98.1%

   \[\leadsto \frac{4}{\color{blue}{\mathsf{fma}\left(3, \pi \cdot \sqrt{2}, {v}^{2} \cdot \mathsf{fma}\left(3, {v}^{2} \cdot \mathsf{fma}\left(-4.5, \frac{\pi}{{\left(\sqrt{2}\right)}^{3}}, 3 \cdot \frac{\pi}{\sqrt{2}}\right), 3 \cdot \mathsf{fma}\left(-3, \frac{\pi}{\sqrt{2}}, -1 \cdot \left(\pi \cdot \sqrt{2}\right)\right)\right)\right)}} \]
5. Add Preprocessing

Alternative 2: 98.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{4}{\left(\left(3 \cdot \pi\right) \cdot \left(1 - v \cdot v\right)\right) \cdot \sqrt{2 - 6 \cdot \left(v \cdot v\right)}} \end{array} \]

FPCore

(FPCore (v)
 :precision binary64
 (/ 4.0 (* (* (* 3.0 PI) (- 1.0 (* v v))) (sqrt (- 2.0 (* 6.0 (* v v)))))))

C

double code(double v) {
	return 4.0 / (((3.0 * ((double) M_PI)) * (1.0 - (v * v))) * sqrt((2.0 - (6.0 * (v * v)))));
}

Java

public static double code(double v) {
	return 4.0 / (((3.0 * Math.PI) * (1.0 - (v * v))) * Math.sqrt((2.0 - (6.0 * (v * v)))));
}

Python

def code(v):
	return 4.0 / (((3.0 * math.pi) * (1.0 - (v * v))) * math.sqrt((2.0 - (6.0 * (v * v)))))

Julia

function code(v)
	return Float64(4.0 / Float64(Float64(Float64(3.0 * pi) * Float64(1.0 - Float64(v * v))) * sqrt(Float64(2.0 - Float64(6.0 * Float64(v * v))))))
end

MATLAB

function tmp = code(v)
	tmp = 4.0 / (((3.0 * pi) * (1.0 - (v * v))) * sqrt((2.0 - (6.0 * (v * v)))));
end

Wolfram

code[v_] := N[(4.0 / N[(N[(N[(3.0 * Pi), $MachinePrecision] * N[(1.0 - N[(v * v), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(2.0 - N[(6.0 * N[(v * v), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 98.5%

   \[\frac{4}{\left(\left(3 \cdot \pi\right) \cdot \left(1 - v \cdot v\right)\right) \cdot \sqrt{2 - 6 \cdot \left(v \cdot v\right)}} \]
2. Add Preprocessing

Alternative 3: 97.4% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \frac{4}{\left(3 \cdot \pi\right) \cdot \sqrt{2 - 6 \cdot \left(v \cdot v\right)}} \end{array} \]

FPCore

(FPCore (v)
 :precision binary64
 (/ 4.0 (* (* 3.0 PI) (sqrt (- 2.0 (* 6.0 (* v v)))))))

C

double code(double v) {
	return 4.0 / ((3.0 * ((double) M_PI)) * sqrt((2.0 - (6.0 * (v * v)))));
}

Java

public static double code(double v) {
	return 4.0 / ((3.0 * Math.PI) * Math.sqrt((2.0 - (6.0 * (v * v)))));
}

Python

def code(v):
	return 4.0 / ((3.0 * math.pi) * math.sqrt((2.0 - (6.0 * (v * v)))))

Julia

function code(v)
	return Float64(4.0 / Float64(Float64(3.0 * pi) * sqrt(Float64(2.0 - Float64(6.0 * Float64(v * v))))))
end

MATLAB

function tmp = code(v)
	tmp = 4.0 / ((3.0 * pi) * sqrt((2.0 - (6.0 * (v * v)))));
end

Wolfram

code[v_] := N[(4.0 / N[(N[(3.0 * Pi), $MachinePrecision] * N[Sqrt[N[(2.0 - N[(6.0 * N[(v * v), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 98.5%

   \[\frac{4}{\left(\left(3 \cdot \pi\right) \cdot \left(1 - v \cdot v\right)\right) \cdot \sqrt{2 - 6 \cdot \left(v \cdot v\right)}} \]

2. Taylor expanded in v around 0

   \[\leadsto \frac{4}{\color{blue}{\left(3 \cdot \mathsf{PI}\left(\right)\right)} \cdot \sqrt{2 - 6 \cdot \left(v \cdot v\right)}} \]
3. Step-by-step derivation

   1. lift-*.f64 N/A

      \[\leadsto \frac{4}{\left(3 \cdot \color{blue}{\mathsf{PI}\left(\right)}\right) \cdot \sqrt{2 - 6 \cdot \left(v \cdot v\right)}} \]

   2. lift-PI.f64 97.4

      \[\leadsto \frac{4}{\left(3 \cdot \pi\right) \cdot \sqrt{2 - 6 \cdot \left(v \cdot v\right)}} \]

4. Applied rewrites 97.4%

   \[\leadsto \frac{4}{\color{blue}{\left(3 \cdot \pi\right)} \cdot \sqrt{2 - 6 \cdot \left(v \cdot v\right)}} \]
5. Add Preprocessing

Alternative 4: 97.3% accurate, 3.2× speedup

Math

\[\begin{array}{l} \\ 1.3333333333333333 \cdot \frac{\sqrt{0.5}}{\pi} \end{array} \]

FPCore

(FPCore (v) :precision binary64 (* 1.3333333333333333 (/ (sqrt 0.5) PI)))

C

double code(double v) {
	return 1.3333333333333333 * (sqrt(0.5) / ((double) M_PI));
}

Java

public static double code(double v) {
	return 1.3333333333333333 * (Math.sqrt(0.5) / Math.PI);
}

Python

def code(v):
	return 1.3333333333333333 * (math.sqrt(0.5) / math.pi)

Julia

function code(v)
	return Float64(1.3333333333333333 * Float64(sqrt(0.5) / pi))
end

MATLAB

function tmp = code(v)
	tmp = 1.3333333333333333 * (sqrt(0.5) / pi);
end

Wolfram

code[v_] := N[(1.3333333333333333 * N[(N[Sqrt[0.5], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 98.5%

   \[\frac{4}{\left(\left(3 \cdot \pi\right) \cdot \left(1 - v \cdot v\right)\right) \cdot \sqrt{2 - 6 \cdot \left(v \cdot v\right)}} \]

2. Taylor expanded in v around 0

   \[\leadsto \color{blue}{\frac{4}{3} \cdot \frac{\sqrt{\frac{1}{2}}}{\mathsf{PI}\left(\right)}} \]
3. Step-by-step derivation

   1. lower-*.f64 N/A

      \[\leadsto \frac{4}{3} \cdot \color{blue}{\frac{\sqrt{\frac{1}{2}}}{\mathsf{PI}\left(\right)}} \]

   2. lower-/.f64 N/A

      \[\leadsto \frac{4}{3} \cdot \frac{\sqrt{\frac{1}{2}}}{\color{blue}{\mathsf{PI}\left(\right)}} \]

   3. lower-sqrt.f64 N/A

      \[\leadsto \frac{4}{3} \cdot \frac{\sqrt{\frac{1}{2}}}{\mathsf{PI}\left(\right)} \]

   4. lift-PI.f64 97.3

      \[\leadsto 1.3333333333333333 \cdot \frac{\sqrt{0.5}}{\pi} \]

4. Applied rewrites 97.3%

   \[\leadsto \color{blue}{1.3333333333333333 \cdot \frac{\sqrt{0.5}}{\pi}} \]
5. Add Preprocessing

Reproduce

herbie shell --seed 2025134 
(FPCore (v)
  :name "Falkner and Boettcher, Equation (22+)"
  :precision binary64
  (/ 4.0 (* (* (* 3.0 PI) (- 1.0 (* v v))) (sqrt (- 2.0 (* 6.0 (* v v)))))))