VandenBroeck and Keller, Equation (6)

Percentage Accurate: 76.2% → 96.7%

Time: 1.6min

Alternatives: 9

Speedup: 1.0×

• could not determine a ground truth

  1. F = 5.337024520052709e+246
  2. l = 1976673924960277.5

Specification

Math

\[\begin{array}{l} \\ \pi \cdot \ell - \frac{1}{F \cdot F} \cdot \tan \left(\pi \cdot \ell\right) \end{array} \]

FPCore

(FPCore (F l)
 :precision binary64
 (- (* PI l) (* (/ 1.0 (* F F)) (tan (* PI l)))))

C

double code(double F, double l) {
	return (((double) M_PI) * l) - ((1.0 / (F * F)) * tan((((double) M_PI) * l)));
}

Java

public static double code(double F, double l) {
	return (Math.PI * l) - ((1.0 / (F * F)) * Math.tan((Math.PI * l)));
}

Python

def code(F, l):
	return (math.pi * l) - ((1.0 / (F * F)) * math.tan((math.pi * l)))

Julia

function code(F, l)
	return Float64(Float64(pi * l) - Float64(Float64(1.0 / Float64(F * F)) * tan(Float64(pi * l))))
end

MATLAB

function tmp = code(F, l)
	tmp = (pi * l) - ((1.0 / (F * F)) * tan((pi * l)));
end

Wolfram

code[F_, l_] := N[(N[(Pi * l), $MachinePrecision] - N[(N[(1.0 / N[(F * F), $MachinePrecision]), $MachinePrecision] * N[Tan[N[(Pi * l), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Initial Program: 76.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \pi \cdot \ell - \frac{1}{F \cdot F} \cdot \tan \left(\pi \cdot \ell\right) \end{array} \]

FPCore

(FPCore (F l)
 :precision binary64
 (- (* PI l) (* (/ 1.0 (* F F)) (tan (* PI l)))))

C

double code(double F, double l) {
	return (((double) M_PI) * l) - ((1.0 / (F * F)) * tan((((double) M_PI) * l)));
}

Java

public static double code(double F, double l) {
	return (Math.PI * l) - ((1.0 / (F * F)) * Math.tan((Math.PI * l)));
}

Python

def code(F, l):
	return (math.pi * l) - ((1.0 / (F * F)) * math.tan((math.pi * l)))

Julia

function code(F, l)
	return Float64(Float64(pi * l) - Float64(Float64(1.0 / Float64(F * F)) * tan(Float64(pi * l))))
end

MATLAB

function tmp = code(F, l)
	tmp = (pi * l) - ((1.0 / (F * F)) * tan((pi * l)));
end

Wolfram

code[F_, l_] := N[(N[(Pi * l), $MachinePrecision] - N[(N[(1.0 / N[(F * F), $MachinePrecision]), $MachinePrecision] * N[Tan[N[(Pi * l), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Alternative 1: 96.7% accurate, 0.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 0.008333333333333333 \cdot {\pi}^{5}\\ t_1 := {\pi}^{6} \cdot 0.1111111111111111\\ t_2 := \frac{F}{{\pi}^{2}}\\ t_3 := {\pi}^{3} \cdot 0.3333333333333333\\ t_4 := \mathsf{fma}\left(-0.5, {\pi}^{2} \cdot t_3, {\pi}^{5} \cdot 0.041666666666666664\right)\\ t_5 := t_4 - t_0\\ t_6 := t_0 - t_4\\ t_7 := \frac{F}{{\pi}^{3}}\\ \pi \cdot \ell + \frac{-1}{F \cdot \left(\left(\left(\frac{F}{\pi \cdot \ell} - \frac{F}{\frac{\frac{{\pi}^{2}}{\ell}}{t_3}}\right) - \mathsf{log1p}\left(\mathsf{expm1}\left(\left(\mathsf{fma}\left(t_2, -0.0001984126984126984 \cdot {\pi}^{7} - \mathsf{fma}\left(-0.5, {\pi}^{2} \cdot t_6, \mathsf{fma}\left(-0.001388888888888889, {\pi}^{7}, {\pi}^{3} \cdot \left(0.013888888888888888 \cdot {\pi}^{4}\right)\right)\right), \left(\frac{t_6}{\frac{{\pi}^{3}}{F}} - \frac{F \cdot t_1}{{\pi}^{4}}\right) \cdot \left({\pi}^{3} \cdot -0.3333333333333333\right)\right) + t_3 \cdot \left(t_7 \cdot t_5\right)\right) \cdot {\ell}^{5}\right)\right)\right) + {\ell}^{3} \cdot \left(t_1 \cdot t_7 + t_2 \cdot t_5\right)\right)} \end{array} \end{array} \]

FPCore

(FPCore (F l)
 :precision binary64
 (let* ((t_0 (* 0.008333333333333333 (pow PI 5.0)))
        (t_1 (* (pow PI 6.0) 0.1111111111111111))
        (t_2 (/ F (pow PI 2.0)))
        (t_3 (* (pow PI 3.0) 0.3333333333333333))
        (t_4
         (fma -0.5 (* (pow PI 2.0) t_3) (* (pow PI 5.0) 0.041666666666666664)))
        (t_5 (- t_4 t_0))
        (t_6 (- t_0 t_4))
        (t_7 (/ F (pow PI 3.0))))
   (+
    (* PI l)
    (/
     -1.0
     (*
      F
      (+
       (-
        (- (/ F (* PI l)) (/ F (/ (/ (pow PI 2.0) l) t_3)))
        (log1p
         (expm1
          (*
           (+
            (fma
             t_2
             (-
              (* -0.0001984126984126984 (pow PI 7.0))
              (fma
               -0.5
               (* (pow PI 2.0) t_6)
               (fma
                -0.001388888888888889
                (pow PI 7.0)
                (* (pow PI 3.0) (* 0.013888888888888888 (pow PI 4.0))))))
             (*
              (- (/ t_6 (/ (pow PI 3.0) F)) (/ (* F t_1) (pow PI 4.0)))
              (* (pow PI 3.0) -0.3333333333333333)))
            (* t_3 (* t_7 t_5)))
           (pow l 5.0)))))
       (* (pow l 3.0) (+ (* t_1 t_7) (* t_2 t_5)))))))))

C

double code(double F, double l) {
	double t_0 = 0.008333333333333333 * pow(((double) M_PI), 5.0);
	double t_1 = pow(((double) M_PI), 6.0) * 0.1111111111111111;
	double t_2 = F / pow(((double) M_PI), 2.0);
	double t_3 = pow(((double) M_PI), 3.0) * 0.3333333333333333;
	double t_4 = fma(-0.5, (pow(((double) M_PI), 2.0) * t_3), (pow(((double) M_PI), 5.0) * 0.041666666666666664));
	double t_5 = t_4 - t_0;
	double t_6 = t_0 - t_4;
	double t_7 = F / pow(((double) M_PI), 3.0);
	return (((double) M_PI) * l) + (-1.0 / (F * ((((F / (((double) M_PI) * l)) - (F / ((pow(((double) M_PI), 2.0) / l) / t_3))) - log1p(expm1(((fma(t_2, ((-0.0001984126984126984 * pow(((double) M_PI), 7.0)) - fma(-0.5, (pow(((double) M_PI), 2.0) * t_6), fma(-0.001388888888888889, pow(((double) M_PI), 7.0), (pow(((double) M_PI), 3.0) * (0.013888888888888888 * pow(((double) M_PI), 4.0)))))), (((t_6 / (pow(((double) M_PI), 3.0) / F)) - ((F * t_1) / pow(((double) M_PI), 4.0))) * (pow(((double) M_PI), 3.0) * -0.3333333333333333))) + (t_3 * (t_7 * t_5))) * pow(l, 5.0))))) + (pow(l, 3.0) * ((t_1 * t_7) + (t_2 * t_5))))));
}

Julia

function code(F, l)
	t_0 = Float64(0.008333333333333333 * (pi ^ 5.0))
	t_1 = Float64((pi ^ 6.0) * 0.1111111111111111)
	t_2 = Float64(F / (pi ^ 2.0))
	t_3 = Float64((pi ^ 3.0) * 0.3333333333333333)
	t_4 = fma(-0.5, Float64((pi ^ 2.0) * t_3), Float64((pi ^ 5.0) * 0.041666666666666664))
	t_5 = Float64(t_4 - t_0)
	t_6 = Float64(t_0 - t_4)
	t_7 = Float64(F / (pi ^ 3.0))
	return Float64(Float64(pi * l) + Float64(-1.0 / Float64(F * Float64(Float64(Float64(Float64(F / Float64(pi * l)) - Float64(F / Float64(Float64((pi ^ 2.0) / l) / t_3))) - log1p(expm1(Float64(Float64(fma(t_2, Float64(Float64(-0.0001984126984126984 * (pi ^ 7.0)) - fma(-0.5, Float64((pi ^ 2.0) * t_6), fma(-0.001388888888888889, (pi ^ 7.0), Float64((pi ^ 3.0) * Float64(0.013888888888888888 * (pi ^ 4.0)))))), Float64(Float64(Float64(t_6 / Float64((pi ^ 3.0) / F)) - Float64(Float64(F * t_1) / (pi ^ 4.0))) * Float64((pi ^ 3.0) * -0.3333333333333333))) + Float64(t_3 * Float64(t_7 * t_5))) * (l ^ 5.0))))) + Float64((l ^ 3.0) * Float64(Float64(t_1 * t_7) + Float64(t_2 * t_5)))))))
end

Wolfram

code[F_, l_] := Block[{t$95$0 = N[(0.008333333333333333 * N[Power[Pi, 5.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Power[Pi, 6.0], $MachinePrecision] * 0.1111111111111111), $MachinePrecision]}, Block[{t$95$2 = N[(F / N[Power[Pi, 2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[Power[Pi, 3.0], $MachinePrecision] * 0.3333333333333333), $MachinePrecision]}, Block[{t$95$4 = N[(-0.5 * N[(N[Power[Pi, 2.0], $MachinePrecision] * t$95$3), $MachinePrecision] + N[(N[Power[Pi, 5.0], $MachinePrecision] * 0.041666666666666664), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(t$95$4 - t$95$0), $MachinePrecision]}, Block[{t$95$6 = N[(t$95$0 - t$95$4), $MachinePrecision]}, Block[{t$95$7 = N[(F / N[Power[Pi, 3.0], $MachinePrecision]), $MachinePrecision]}, N[(N[(Pi * l), $MachinePrecision] + N[(-1.0 / N[(F * N[(N[(N[(N[(F / N[(Pi * l), $MachinePrecision]), $MachinePrecision] - N[(F / N[(N[(N[Power[Pi, 2.0], $MachinePrecision] / l), $MachinePrecision] / t$95$3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[Log[1 + N[(Exp[N[(N[(N[(t$95$2 * N[(N[(-0.0001984126984126984 * N[Power[Pi, 7.0], $MachinePrecision]), $MachinePrecision] - N[(-0.5 * N[(N[Power[Pi, 2.0], $MachinePrecision] * t$95$6), $MachinePrecision] + N[(-0.001388888888888889 * N[Power[Pi, 7.0], $MachinePrecision] + N[(N[Power[Pi, 3.0], $MachinePrecision] * N[(0.013888888888888888 * N[Power[Pi, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(t$95$6 / N[(N[Power[Pi, 3.0], $MachinePrecision] / F), $MachinePrecision]), $MachinePrecision] - N[(N[(F * t$95$1), $MachinePrecision] / N[Power[Pi, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Power[Pi, 3.0], $MachinePrecision] * -0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t$95$3 * N[(t$95$7 * t$95$5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Power[l, 5.0], $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + N[(N[Power[l, 3.0], $MachinePrecision] * N[(N[(t$95$1 * t$95$7), $MachinePrecision] + N[(t$95$2 * t$95$5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 2: 96.2% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := {\pi}^{3} \cdot 0.3333333333333333\\ t_1 := {\pi}^{5} \cdot 0.13333333333333333\\ \pi \cdot \ell + \frac{-1}{F \cdot \left(\left(\left(\frac{F}{\pi \cdot \ell} - \frac{F}{\frac{\frac{{\pi}^{2}}{\ell}}{t_0}}\right) + \left(F \cdot {\ell}^{5}\right) \cdot \left(\mathsf{fma}\left(-0.5, t_1, {\pi}^{5} \cdot 0.0125 - 0.3333333333333333 \cdot \left({\pi}^{2} \cdot \left({\pi}^{3} \cdot -0.013888888888888888 - {\pi}^{3} \cdot 0.008333333333333333\right) - t_1\right)\right) - -0.0001984126984126984 \cdot {\pi}^{5}\right)\right) + {\ell}^{3} \cdot \left(\left({\pi}^{6} \cdot 0.1111111111111111\right) \cdot \frac{F}{{\pi}^{3}} + \frac{F}{{\pi}^{2}} \cdot \left(\mathsf{fma}\left(-0.5, {\pi}^{2} \cdot t_0, {\pi}^{5} \cdot 0.041666666666666664\right) - 0.008333333333333333 \cdot {\pi}^{5}\right)\right)\right)} \end{array} \end{array} \]

FPCore

(FPCore (F l)
 :precision binary64
 (let* ((t_0 (* (pow PI 3.0) 0.3333333333333333))
        (t_1 (* (pow PI 5.0) 0.13333333333333333)))
   (+
    (* PI l)
    (/
     -1.0
     (*
      F
      (+
       (+
        (- (/ F (* PI l)) (/ F (/ (/ (pow PI 2.0) l) t_0)))
        (*
         (* F (pow l 5.0))
         (-
          (fma
           -0.5
           t_1
           (-
            (* (pow PI 5.0) 0.0125)
            (*
             0.3333333333333333
             (-
              (*
               (pow PI 2.0)
               (-
                (* (pow PI 3.0) -0.013888888888888888)
                (* (pow PI 3.0) 0.008333333333333333)))
              t_1))))
          (* -0.0001984126984126984 (pow PI 5.0)))))
       (*
        (pow l 3.0)
        (+
         (* (* (pow PI 6.0) 0.1111111111111111) (/ F (pow PI 3.0)))
         (*
          (/ F (pow PI 2.0))
          (-
           (fma
            -0.5
            (* (pow PI 2.0) t_0)
            (* (pow PI 5.0) 0.041666666666666664))
           (* 0.008333333333333333 (pow PI 5.0))))))))))))

C

double code(double F, double l) {
	double t_0 = pow(((double) M_PI), 3.0) * 0.3333333333333333;
	double t_1 = pow(((double) M_PI), 5.0) * 0.13333333333333333;
	return (((double) M_PI) * l) + (-1.0 / (F * ((((F / (((double) M_PI) * l)) - (F / ((pow(((double) M_PI), 2.0) / l) / t_0))) + ((F * pow(l, 5.0)) * (fma(-0.5, t_1, ((pow(((double) M_PI), 5.0) * 0.0125) - (0.3333333333333333 * ((pow(((double) M_PI), 2.0) * ((pow(((double) M_PI), 3.0) * -0.013888888888888888) - (pow(((double) M_PI), 3.0) * 0.008333333333333333))) - t_1)))) - (-0.0001984126984126984 * pow(((double) M_PI), 5.0))))) + (pow(l, 3.0) * (((pow(((double) M_PI), 6.0) * 0.1111111111111111) * (F / pow(((double) M_PI), 3.0))) + ((F / pow(((double) M_PI), 2.0)) * (fma(-0.5, (pow(((double) M_PI), 2.0) * t_0), (pow(((double) M_PI), 5.0) * 0.041666666666666664)) - (0.008333333333333333 * pow(((double) M_PI), 5.0)))))))));
}

Julia

function code(F, l)
	t_0 = Float64((pi ^ 3.0) * 0.3333333333333333)
	t_1 = Float64((pi ^ 5.0) * 0.13333333333333333)
	return Float64(Float64(pi * l) + Float64(-1.0 / Float64(F * Float64(Float64(Float64(Float64(F / Float64(pi * l)) - Float64(F / Float64(Float64((pi ^ 2.0) / l) / t_0))) + Float64(Float64(F * (l ^ 5.0)) * Float64(fma(-0.5, t_1, Float64(Float64((pi ^ 5.0) * 0.0125) - Float64(0.3333333333333333 * Float64(Float64((pi ^ 2.0) * Float64(Float64((pi ^ 3.0) * -0.013888888888888888) - Float64((pi ^ 3.0) * 0.008333333333333333))) - t_1)))) - Float64(-0.0001984126984126984 * (pi ^ 5.0))))) + Float64((l ^ 3.0) * Float64(Float64(Float64((pi ^ 6.0) * 0.1111111111111111) * Float64(F / (pi ^ 3.0))) + Float64(Float64(F / (pi ^ 2.0)) * Float64(fma(-0.5, Float64((pi ^ 2.0) * t_0), Float64((pi ^ 5.0) * 0.041666666666666664)) - Float64(0.008333333333333333 * (pi ^ 5.0))))))))))
end

Wolfram

code[F_, l_] := Block[{t$95$0 = N[(N[Power[Pi, 3.0], $MachinePrecision] * 0.3333333333333333), $MachinePrecision]}, Block[{t$95$1 = N[(N[Power[Pi, 5.0], $MachinePrecision] * 0.13333333333333333), $MachinePrecision]}, N[(N[(Pi * l), $MachinePrecision] + N[(-1.0 / N[(F * N[(N[(N[(N[(F / N[(Pi * l), $MachinePrecision]), $MachinePrecision] - N[(F / N[(N[(N[Power[Pi, 2.0], $MachinePrecision] / l), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(F * N[Power[l, 5.0], $MachinePrecision]), $MachinePrecision] * N[(N[(-0.5 * t$95$1 + N[(N[(N[Power[Pi, 5.0], $MachinePrecision] * 0.0125), $MachinePrecision] - N[(0.3333333333333333 * N[(N[(N[Power[Pi, 2.0], $MachinePrecision] * N[(N[(N[Power[Pi, 3.0], $MachinePrecision] * -0.013888888888888888), $MachinePrecision] - N[(N[Power[Pi, 3.0], $MachinePrecision] * 0.008333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(-0.0001984126984126984 * N[Power[Pi, 5.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Power[l, 3.0], $MachinePrecision] * N[(N[(N[(N[Power[Pi, 6.0], $MachinePrecision] * 0.1111111111111111), $MachinePrecision] * N[(F / N[Power[Pi, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(F / N[Power[Pi, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(-0.5 * N[(N[Power[Pi, 2.0], $MachinePrecision] * t$95$0), $MachinePrecision] + N[(N[Power[Pi, 5.0], $MachinePrecision] * 0.041666666666666664), $MachinePrecision]), $MachinePrecision] - N[(0.008333333333333333 * N[Power[Pi, 5.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 3: 94.4% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := {\pi}^{3} \cdot 0.3333333333333333\\ \pi \cdot \ell + \frac{-1}{F \cdot \left(\left(\frac{F}{\pi \cdot \ell} - \frac{F}{\frac{\frac{{\pi}^{2}}{\ell}}{t_0}}\right) + {\ell}^{3} \cdot \left(\left({\pi}^{6} \cdot 0.1111111111111111\right) \cdot \frac{F}{{\pi}^{3}} + \frac{F}{{\pi}^{2}} \cdot \left(\mathsf{fma}\left(-0.5, {\pi}^{2} \cdot t_0, {\pi}^{5} \cdot 0.041666666666666664\right) - 0.008333333333333333 \cdot {\pi}^{5}\right)\right)\right)} \end{array} \end{array} \]

FPCore

(FPCore (F l)
 :precision binary64
 (let* ((t_0 (* (pow PI 3.0) 0.3333333333333333)))
   (+
    (* PI l)
    (/
     -1.0
     (*
      F
      (+
       (- (/ F (* PI l)) (/ F (/ (/ (pow PI 2.0) l) t_0)))
       (*
        (pow l 3.0)
        (+
         (* (* (pow PI 6.0) 0.1111111111111111) (/ F (pow PI 3.0)))
         (*
          (/ F (pow PI 2.0))
          (-
           (fma
            -0.5
            (* (pow PI 2.0) t_0)
            (* (pow PI 5.0) 0.041666666666666664))
           (* 0.008333333333333333 (pow PI 5.0))))))))))))

C

double code(double F, double l) {
	double t_0 = pow(((double) M_PI), 3.0) * 0.3333333333333333;
	return (((double) M_PI) * l) + (-1.0 / (F * (((F / (((double) M_PI) * l)) - (F / ((pow(((double) M_PI), 2.0) / l) / t_0))) + (pow(l, 3.0) * (((pow(((double) M_PI), 6.0) * 0.1111111111111111) * (F / pow(((double) M_PI), 3.0))) + ((F / pow(((double) M_PI), 2.0)) * (fma(-0.5, (pow(((double) M_PI), 2.0) * t_0), (pow(((double) M_PI), 5.0) * 0.041666666666666664)) - (0.008333333333333333 * pow(((double) M_PI), 5.0)))))))));
}

Julia

function code(F, l)
	t_0 = Float64((pi ^ 3.0) * 0.3333333333333333)
	return Float64(Float64(pi * l) + Float64(-1.0 / Float64(F * Float64(Float64(Float64(F / Float64(pi * l)) - Float64(F / Float64(Float64((pi ^ 2.0) / l) / t_0))) + Float64((l ^ 3.0) * Float64(Float64(Float64((pi ^ 6.0) * 0.1111111111111111) * Float64(F / (pi ^ 3.0))) + Float64(Float64(F / (pi ^ 2.0)) * Float64(fma(-0.5, Float64((pi ^ 2.0) * t_0), Float64((pi ^ 5.0) * 0.041666666666666664)) - Float64(0.008333333333333333 * (pi ^ 5.0))))))))))
end

Wolfram

code[F_, l_] := Block[{t$95$0 = N[(N[Power[Pi, 3.0], $MachinePrecision] * 0.3333333333333333), $MachinePrecision]}, N[(N[(Pi * l), $MachinePrecision] + N[(-1.0 / N[(F * N[(N[(N[(F / N[(Pi * l), $MachinePrecision]), $MachinePrecision] - N[(F / N[(N[(N[Power[Pi, 2.0], $MachinePrecision] / l), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Power[l, 3.0], $MachinePrecision] * N[(N[(N[(N[Power[Pi, 6.0], $MachinePrecision] * 0.1111111111111111), $MachinePrecision] * N[(F / N[Power[Pi, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(F / N[Power[Pi, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(-0.5 * N[(N[Power[Pi, 2.0], $MachinePrecision] * t$95$0), $MachinePrecision] + N[(N[Power[Pi, 5.0], $MachinePrecision] * 0.041666666666666664), $MachinePrecision]), $MachinePrecision] - N[(0.008333333333333333 * N[Power[Pi, 5.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 4: 87.9% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \pi \cdot \ell + \frac{-1}{F \cdot \left(\frac{F}{\pi \cdot \ell} - \frac{F}{\frac{\frac{{\pi}^{2}}{\ell}}{{\pi}^{3} \cdot 0.3333333333333333}}\right)} \end{array} \]

FPCore

(FPCore (F l)
 :precision binary64
 (+
  (* PI l)
  (/
   -1.0
   (*
    F
    (-
     (/ F (* PI l))
     (/ F (/ (/ (pow PI 2.0) l) (* (pow PI 3.0) 0.3333333333333333))))))))

C

double code(double F, double l) {
	return (((double) M_PI) * l) + (-1.0 / (F * ((F / (((double) M_PI) * l)) - (F / ((pow(((double) M_PI), 2.0) / l) / (pow(((double) M_PI), 3.0) * 0.3333333333333333))))));
}

Java

public static double code(double F, double l) {
	return (Math.PI * l) + (-1.0 / (F * ((F / (Math.PI * l)) - (F / ((Math.pow(Math.PI, 2.0) / l) / (Math.pow(Math.PI, 3.0) * 0.3333333333333333))))));
}

Python

def code(F, l):
	return (math.pi * l) + (-1.0 / (F * ((F / (math.pi * l)) - (F / ((math.pow(math.pi, 2.0) / l) / (math.pow(math.pi, 3.0) * 0.3333333333333333))))))

Julia

function code(F, l)
	return Float64(Float64(pi * l) + Float64(-1.0 / Float64(F * Float64(Float64(F / Float64(pi * l)) - Float64(F / Float64(Float64((pi ^ 2.0) / l) / Float64((pi ^ 3.0) * 0.3333333333333333)))))))
end

MATLAB

function tmp = code(F, l)
	tmp = (pi * l) + (-1.0 / (F * ((F / (pi * l)) - (F / (((pi ^ 2.0) / l) / ((pi ^ 3.0) * 0.3333333333333333))))));
end

Wolfram

code[F_, l_] := N[(N[(Pi * l), $MachinePrecision] + N[(-1.0 / N[(F * N[(N[(F / N[(Pi * l), $MachinePrecision]), $MachinePrecision] - N[(F / N[(N[(N[Power[Pi, 2.0], $MachinePrecision] / l), $MachinePrecision] / N[(N[Power[Pi, 3.0], $MachinePrecision] * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 5: 78.9% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;\pi \cdot \ell \leq 10^{-16}:\\ \;\;\;\;\pi \cdot \ell - \frac{\frac{\ell}{F}}{\frac{F}{\pi}}\\ \mathbf{else}:\\ \;\;\;\;\pi \cdot \ell - \frac{\tan \left(\pi \cdot \ell\right)}{F \cdot F}\\ \end{array} \end{array} \]

FPCore

(FPCore (F l)
 :precision binary64
 (if (<= (* PI l) 1e-16)
   (- (* PI l) (/ (/ l F) (/ F PI)))
   (- (* PI l) (/ (tan (* PI l)) (* F F)))))

C

double code(double F, double l) {
	double tmp;
	if ((((double) M_PI) * l) <= 1e-16) {
		tmp = (((double) M_PI) * l) - ((l / F) / (F / ((double) M_PI)));
	} else {
		tmp = (((double) M_PI) * l) - (tan((((double) M_PI) * l)) / (F * F));
	}
	return tmp;
}

Java

public static double code(double F, double l) {
	double tmp;
	if ((Math.PI * l) <= 1e-16) {
		tmp = (Math.PI * l) - ((l / F) / (F / Math.PI));
	} else {
		tmp = (Math.PI * l) - (Math.tan((Math.PI * l)) / (F * F));
	}
	return tmp;
}

Python

def code(F, l):
	tmp = 0
	if (math.pi * l) <= 1e-16:
		tmp = (math.pi * l) - ((l / F) / (F / math.pi))
	else:
		tmp = (math.pi * l) - (math.tan((math.pi * l)) / (F * F))
	return tmp

Julia

function code(F, l)
	tmp = 0.0
	if (Float64(pi * l) <= 1e-16)
		tmp = Float64(Float64(pi * l) - Float64(Float64(l / F) / Float64(F / pi)));
	else
		tmp = Float64(Float64(pi * l) - Float64(tan(Float64(pi * l)) / Float64(F * F)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(F, l)
	tmp = 0.0;
	if ((pi * l) <= 1e-16)
		tmp = (pi * l) - ((l / F) / (F / pi));
	else
		tmp = (pi * l) - (tan((pi * l)) / (F * F));
	end
	tmp_2 = tmp;
end

Wolfram

code[F_, l_] := If[LessEqual[N[(Pi * l), $MachinePrecision], 1e-16], N[(N[(Pi * l), $MachinePrecision] - N[(N[(l / F), $MachinePrecision] / N[(F / Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(Pi * l), $MachinePrecision] - N[(N[Tan[N[(Pi * l), $MachinePrecision]], $MachinePrecision] / N[(F * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 6: 82.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \pi \cdot \ell + \frac{-1}{F \cdot \frac{F}{\tan \left(\pi \cdot \ell\right)}} \end{array} \]

FPCore

(FPCore (F l)
 :precision binary64
 (+ (* PI l) (/ -1.0 (* F (/ F (tan (* PI l)))))))

C

double code(double F, double l) {
	return (((double) M_PI) * l) + (-1.0 / (F * (F / tan((((double) M_PI) * l)))));
}

Java

public static double code(double F, double l) {
	return (Math.PI * l) + (-1.0 / (F * (F / Math.tan((Math.PI * l)))));
}

Python

def code(F, l):
	return (math.pi * l) + (-1.0 / (F * (F / math.tan((math.pi * l)))))

Julia

function code(F, l)
	return Float64(Float64(pi * l) + Float64(-1.0 / Float64(F * Float64(F / tan(Float64(pi * l))))))
end

MATLAB

function tmp = code(F, l)
	tmp = (pi * l) + (-1.0 / (F * (F / tan((pi * l)))));
end

Wolfram

code[F_, l_] := N[(N[(Pi * l), $MachinePrecision] + N[(-1.0 / N[(F * N[(F / N[Tan[N[(Pi * l), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 7: 82.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \pi \cdot \ell - \frac{\frac{\tan \left(\pi \cdot \ell\right)}{F}}{F} \end{array} \]

FPCore

(FPCore (F l) :precision binary64 (- (* PI l) (/ (/ (tan (* PI l)) F) F)))

C

double code(double F, double l) {
	return (((double) M_PI) * l) - ((tan((((double) M_PI) * l)) / F) / F);
}

Java

public static double code(double F, double l) {
	return (Math.PI * l) - ((Math.tan((Math.PI * l)) / F) / F);
}

Python

def code(F, l):
	return (math.pi * l) - ((math.tan((math.pi * l)) / F) / F)

Julia

function code(F, l)
	return Float64(Float64(pi * l) - Float64(Float64(tan(Float64(pi * l)) / F) / F))
end

MATLAB

function tmp = code(F, l)
	tmp = (pi * l) - ((tan((pi * l)) / F) / F);
end

Wolfram

code[F_, l_] := N[(N[(Pi * l), $MachinePrecision] - N[(N[(N[Tan[N[(Pi * l), $MachinePrecision]], $MachinePrecision] / F), $MachinePrecision] / F), $MachinePrecision]), $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 8: 74.8% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \pi \cdot \ell - \frac{\ell}{F} \cdot \frac{\pi}{F} \end{array} \]

FPCore

(FPCore (F l) :precision binary64 (- (* PI l) (* (/ l F) (/ PI F))))

C

double code(double F, double l) {
	return (((double) M_PI) * l) - ((l / F) * (((double) M_PI) / F));
}

Java

public static double code(double F, double l) {
	return (Math.PI * l) - ((l / F) * (Math.PI / F));
}

Python

def code(F, l):
	return (math.pi * l) - ((l / F) * (math.pi / F))

Julia

function code(F, l)
	return Float64(Float64(pi * l) - Float64(Float64(l / F) * Float64(pi / F)))
end

MATLAB

function tmp = code(F, l)
	tmp = (pi * l) - ((l / F) * (pi / F));
end

Wolfram

code[F_, l_] := N[(N[(Pi * l), $MachinePrecision] - N[(N[(l / F), $MachinePrecision] * N[(Pi / F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 9: 74.8% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \pi \cdot \ell - \frac{\frac{\ell}{F}}{\frac{F}{\pi}} \end{array} \]

FPCore

(FPCore (F l) :precision binary64 (- (* PI l) (/ (/ l F) (/ F PI))))

C

double code(double F, double l) {
	return (((double) M_PI) * l) - ((l / F) / (F / ((double) M_PI)));
}

Java

public static double code(double F, double l) {
	return (Math.PI * l) - ((l / F) / (F / Math.PI));
}

Python

def code(F, l):
	return (math.pi * l) - ((l / F) / (F / math.pi))

Julia

function code(F, l)
	return Float64(Float64(pi * l) - Float64(Float64(l / F) / Float64(F / pi)))
end

MATLAB

function tmp = code(F, l)
	tmp = (pi * l) - ((l / F) / (F / pi));
end

Wolfram

code[F_, l_] := N[(N[(Pi * l), $MachinePrecision] - N[(N[(l / F), $MachinePrecision] / N[(F / Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Reproduce

herbie shell --seed 2024010 
(FPCore (F l)
  :name "VandenBroeck and Keller, Equation (6)"
  :precision binary64
  (- (* PI l) (* (/ 1.0 (* F F)) (tan (* PI l)))))