VandenBroeck and Keller, Equation (6)

Percentage Accurate: 76.2% → 98.1%

Time: 1.2min

Alternatives: 15

Speedup: 1.0×

• could not determine a ground truth

  1. F = 7.323875381153708e+122
  2. l = 485146094092115.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: 98.1% accurate, 0.0× speedup

Math

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

FPCore

(FPCore (F l)
 :precision binary64
 (let* ((t_0 (/ F (pow PI 3.0)))
        (t_1 (* (pow PI 3.0) 0.3333333333333333))
        (t_2
         (-
          (* 0.008333333333333333 (pow PI 5.0))
          (fma
           -0.5
           (* (pow PI 2.0) t_1)
           (* (pow PI 5.0) 0.041666666666666664))))
        (t_3 (/ F (pow PI 2.0))))
   (+
    (* PI l)
    (/
     (/ -1.0 F)
     (+
      (-
       (-
        (/ F (* PI l))
        (/ F (/ (pow PI 2.0) (* (pow PI 3.0) (* l 0.3333333333333333)))))
       (log
        (pow
         (exp (pow l 5.0))
         (-
          (*
           t_3
           (-
            (* -0.0001984126984126984 (pow PI 7.0))
            (fma
             (* (pow PI 2.0) -0.5)
             t_2
             (fma
              0.041666666666666664
              (* (pow PI 3.0) (* 0.3333333333333333 (pow PI 4.0)))
              (* (pow PI 7.0) -0.001388888888888889)))))
          (+
           (/
            (- (* t_3 t_2) (* t_0 (* (pow PI 6.0) 0.1111111111111111)))
            (/ (pow PI -2.0) 0.3333333333333333))
           (* t_0 (* (pow PI 3.0) (* 0.3333333333333333 t_2))))))))
      (*
       (pow l 3.0)
       (-
        (/ F (/ (pow PI 3.0) (pow t_1 2.0)))
        (/ F (/ (pow PI 2.0) t_2)))))))))

C

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

Julia

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

Wolfram

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

Derivation

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

Alternative 2: 96.4% accurate, 0.0× speedup

Math

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

FPCore

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

C

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

Julia

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

Wolfram

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

Derivation

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

Alternative 3: 96.1% 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{\frac{1}{F}}{\left(\left(\frac{F}{\pi \cdot \ell} - \frac{F}{\frac{{\pi}^{2}}{{\pi}^{3} \cdot \left(\ell \cdot 0.3333333333333333\right)}}\right) - \left(-0.0001984126984126984 \cdot {\pi}^{5} - \mathsf{fma}\left(t_1, -0.5, 0.3333333333333333 \cdot \mathsf{fma}\left({\pi}^{2}, {\pi}^{3} \cdot 0.008333333333333333 - {\pi}^{3} \cdot -0.013888888888888888, t_1\right) + {\pi}^{5} \cdot 0.0125\right)\right) \cdot \left(F \cdot {\ell}^{5}\right)\right) + {\ell}^{3} \cdot \left(\frac{F}{\frac{{\pi}^{3}}{{t_0}^{2}}} - \frac{F}{\frac{{\pi}^{2}}{0.008333333333333333 \cdot {\pi}^{5} - \mathsf{fma}\left(-0.5, {\pi}^{2} \cdot t_0, {\pi}^{5} \cdot 0.041666666666666664\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) (* (pow PI 3.0) (* l 0.3333333333333333)))))
       (*
        (-
         (* -0.0001984126984126984 (pow PI 5.0))
         (fma
          t_1
          -0.5
          (+
           (*
            0.3333333333333333
            (fma
             (pow PI 2.0)
             (-
              (* (pow PI 3.0) 0.008333333333333333)
              (* (pow PI 3.0) -0.013888888888888888))
             t_1))
           (* (pow PI 5.0) 0.0125))))
        (* F (pow l 5.0))))
      (*
       (pow l 3.0)
       (-
        (/ F (/ (pow PI 3.0) (pow t_0 2.0)))
        (/
         F
         (/
          (pow PI 2.0)
          (-
           (* 0.008333333333333333 (pow PI 5.0))
           (fma
            -0.5
            (* (pow PI 2.0) t_0)
            (* (pow PI 5.0) 0.041666666666666664))))))))))))

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) / (pow(((double) M_PI), 3.0) * (l * 0.3333333333333333))))) - (((-0.0001984126984126984 * pow(((double) M_PI), 5.0)) - fma(t_1, -0.5, ((0.3333333333333333 * fma(pow(((double) M_PI), 2.0), ((pow(((double) M_PI), 3.0) * 0.008333333333333333) - (pow(((double) M_PI), 3.0) * -0.013888888888888888)), t_1)) + (pow(((double) M_PI), 5.0) * 0.0125)))) * (F * pow(l, 5.0)))) + (pow(l, 3.0) * ((F / (pow(((double) M_PI), 3.0) / pow(t_0, 2.0))) - (F / (pow(((double) M_PI), 2.0) / ((0.008333333333333333 * pow(((double) M_PI), 5.0)) - fma(-0.5, (pow(((double) M_PI), 2.0) * t_0), (pow(((double) M_PI), 5.0) * 0.041666666666666664)))))))));
}

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(Float64(1.0 / F) / Float64(Float64(Float64(Float64(F / Float64(pi * l)) - Float64(F / Float64((pi ^ 2.0) / Float64((pi ^ 3.0) * Float64(l * 0.3333333333333333))))) - Float64(Float64(Float64(-0.0001984126984126984 * (pi ^ 5.0)) - fma(t_1, -0.5, Float64(Float64(0.3333333333333333 * fma((pi ^ 2.0), Float64(Float64((pi ^ 3.0) * 0.008333333333333333) - Float64((pi ^ 3.0) * -0.013888888888888888)), t_1)) + Float64((pi ^ 5.0) * 0.0125)))) * Float64(F * (l ^ 5.0)))) + Float64((l ^ 3.0) * Float64(Float64(F / Float64((pi ^ 3.0) / (t_0 ^ 2.0))) - Float64(F / Float64((pi ^ 2.0) / Float64(Float64(0.008333333333333333 * (pi ^ 5.0)) - fma(-0.5, Float64((pi ^ 2.0) * t_0), Float64((pi ^ 5.0) * 0.041666666666666664))))))))))
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[(N[(1.0 / F), $MachinePrecision] / N[(N[(N[(N[(F / N[(Pi * l), $MachinePrecision]), $MachinePrecision] - N[(F / N[(N[Power[Pi, 2.0], $MachinePrecision] / N[(N[Power[Pi, 3.0], $MachinePrecision] * N[(l * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(-0.0001984126984126984 * N[Power[Pi, 5.0], $MachinePrecision]), $MachinePrecision] - N[(t$95$1 * -0.5 + N[(N[(0.3333333333333333 * N[(N[Power[Pi, 2.0], $MachinePrecision] * N[(N[(N[Power[Pi, 3.0], $MachinePrecision] * 0.008333333333333333), $MachinePrecision] - N[(N[Power[Pi, 3.0], $MachinePrecision] * -0.013888888888888888), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]), $MachinePrecision] + N[(N[Power[Pi, 5.0], $MachinePrecision] * 0.0125), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(F * N[Power[l, 5.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Power[l, 3.0], $MachinePrecision] * N[(N[(F / N[(N[Power[Pi, 3.0], $MachinePrecision] / N[Power[t$95$0, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(F / N[(N[Power[Pi, 2.0], $MachinePrecision] / N[(N[(0.008333333333333333 * N[Power[Pi, 5.0], $MachinePrecision]), $MachinePrecision] - 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]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 4: 94.0% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := {\pi}^{3} \cdot 0.3333333333333333\\ \pi \cdot \ell + \frac{\frac{-1}{F}}{\left(\frac{F}{\pi \cdot \ell} - \frac{F}{\frac{{\pi}^{2}}{{\pi}^{3} \cdot \left(\ell \cdot 0.3333333333333333\right)}}\right) - {\ell}^{3} \cdot \left(\frac{F}{\frac{{\pi}^{2}}{0.008333333333333333 \cdot {\pi}^{5} - \mathsf{fma}\left(-0.5, {\pi}^{2} \cdot t_0, {\pi}^{5} \cdot 0.041666666666666664\right)}} - \frac{F}{\frac{{\pi}^{3}}{{t_0}^{2}}}\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) (* (pow PI 3.0) (* l 0.3333333333333333)))))
      (*
       (pow l 3.0)
       (-
        (/
         F
         (/
          (pow PI 2.0)
          (-
           (* 0.008333333333333333 (pow PI 5.0))
           (fma
            -0.5
            (* (pow PI 2.0) t_0)
            (* (pow PI 5.0) 0.041666666666666664)))))
        (/ F (/ (pow PI 3.0) (pow t_0 2.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) / (pow(((double) M_PI), 3.0) * (l * 0.3333333333333333))))) - (pow(l, 3.0) * ((F / (pow(((double) M_PI), 2.0) / ((0.008333333333333333 * pow(((double) M_PI), 5.0)) - fma(-0.5, (pow(((double) M_PI), 2.0) * t_0), (pow(((double) M_PI), 5.0) * 0.041666666666666664))))) - (F / (pow(((double) M_PI), 3.0) / pow(t_0, 2.0)))))));
}

Julia

function code(F, l)
	t_0 = Float64((pi ^ 3.0) * 0.3333333333333333)
	return Float64(Float64(pi * l) + Float64(Float64(-1.0 / F) / Float64(Float64(Float64(F / Float64(pi * l)) - Float64(F / Float64((pi ^ 2.0) / Float64((pi ^ 3.0) * Float64(l * 0.3333333333333333))))) - Float64((l ^ 3.0) * Float64(Float64(F / Float64((pi ^ 2.0) / Float64(Float64(0.008333333333333333 * (pi ^ 5.0)) - fma(-0.5, Float64((pi ^ 2.0) * t_0), Float64((pi ^ 5.0) * 0.041666666666666664))))) - Float64(F / Float64((pi ^ 3.0) / (t_0 ^ 2.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[(N[(-1.0 / F), $MachinePrecision] / N[(N[(N[(F / N[(Pi * l), $MachinePrecision]), $MachinePrecision] - N[(F / N[(N[Power[Pi, 2.0], $MachinePrecision] / N[(N[Power[Pi, 3.0], $MachinePrecision] * N[(l * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[Power[l, 3.0], $MachinePrecision] * N[(N[(F / N[(N[Power[Pi, 2.0], $MachinePrecision] / N[(N[(0.008333333333333333 * N[Power[Pi, 5.0], $MachinePrecision]), $MachinePrecision] - 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]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(F / N[(N[Power[Pi, 3.0], $MachinePrecision] / N[Power[t$95$0, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 5: 88.0% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \pi \cdot \ell + \frac{\frac{-1}{F}}{\frac{F}{\pi \cdot \ell} - \frac{F}{\frac{{\pi}^{2}}{{\pi}^{3} \cdot \left(\ell \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) (* (pow PI 3.0) (* l 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) / (pow(((double) M_PI), 3.0) * (l * 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) / (Math.pow(Math.PI, 3.0) * (l * 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) / (math.pow(math.pi, 3.0) * (l * 0.3333333333333333))))))

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 6: 66.4% accurate, 0.5× speedup

Math

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

FPCore

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

C

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

Julia

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

Wolfram

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

Derivation

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

Alternative 7: 82.0% accurate, 0.6× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 8: 78.5% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;\pi \cdot \ell \leq 2 \cdot 10^{-80}:\\ \;\;\;\;\pi \cdot \ell - \frac{\frac{\pi}{F}}{\frac{F}{\ell}}\\ \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) 2e-80)
   (- (* PI l) (/ (/ PI F) (/ F l)))
   (- (* PI l) (/ (tan (* PI l)) (* F F)))))

C

double code(double F, double l) {
	double tmp;
	if ((((double) M_PI) * l) <= 2e-80) {
		tmp = (((double) M_PI) * l) - ((((double) M_PI) / F) / (F / l));
	} 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) <= 2e-80) {
		tmp = (Math.PI * l) - ((Math.PI / F) / (F / l));
	} 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) <= 2e-80:
		tmp = (math.pi * l) - ((math.pi / F) / (F / l))
	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) <= 2e-80)
		tmp = Float64(Float64(pi * l) - Float64(Float64(pi / F) / Float64(F / l)));
	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) <= 2e-80)
		tmp = (pi * l) - ((pi / F) / (F / l));
	else
		tmp = (pi * l) - (tan((pi * l)) / (F * F));
	end
	tmp_2 = tmp;
end

Wolfram

code[F_, l_] := If[LessEqual[N[(Pi * l), $MachinePrecision], 2e-80], N[(N[(Pi * l), $MachinePrecision] - N[(N[(Pi / F), $MachinePrecision] / N[(F / l), $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 9: 78.2% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (F l)
 :precision binary64
 (if (<= l 59000.0)
   (- (* PI l) (/ (/ PI F) (/ F l)))
   (+ (* PI l) (/ (/ (tan (* PI l)) F) F))))

C

double code(double F, double l) {
	double tmp;
	if (l <= 59000.0) {
		tmp = (((double) M_PI) * l) - ((((double) M_PI) / F) / (F / l));
	} 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 (l <= 59000.0) {
		tmp = (Math.PI * l) - ((Math.PI / F) / (F / l));
	} else {
		tmp = (Math.PI * l) + ((Math.tan((Math.PI * l)) / F) / F);
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

code[F_, l_] := If[LessEqual[l, 59000.0], N[(N[(Pi * l), $MachinePrecision] - N[(N[(Pi / F), $MachinePrecision] / N[(F / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 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 10: 82.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \pi \cdot \ell + \frac{\frac{-1}{F}}{\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(Float64(-1.0 / 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[(N[(-1.0 / F), $MachinePrecision] / N[(F / N[Tan[N[(Pi * l), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 11: 75.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;\ell \leq 59000:\\ \;\;\;\;\pi \cdot \ell - \frac{\frac{\pi}{F}}{\frac{F}{\ell}}\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(\pi, \ell, \frac{\ell \cdot \frac{\pi}{F}}{F}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (F l)
 :precision binary64
 (if (<= l 59000.0)
   (- (* PI l) (/ (/ PI F) (/ F l)))
   (fma PI l (/ (* l (/ PI F)) F))))

C

double code(double F, double l) {
	double tmp;
	if (l <= 59000.0) {
		tmp = (((double) M_PI) * l) - ((((double) M_PI) / F) / (F / l));
	} else {
		tmp = fma(((double) M_PI), l, ((l * (((double) M_PI) / F)) / F));
	}
	return tmp;
}

Julia

function code(F, l)
	tmp = 0.0
	if (l <= 59000.0)
		tmp = Float64(Float64(pi * l) - Float64(Float64(pi / F) / Float64(F / l)));
	else
		tmp = fma(pi, l, Float64(Float64(l * Float64(pi / F)) / F));
	end
	return tmp
end

Wolfram

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

Derivation

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

Alternative 12: 82.2% 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 13: 74.7% accurate, 1.5× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 14: 74.6% accurate, 1.5× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 15: 74.7% accurate, 1.5× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Reproduce

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