Jmat.Real.erf

Percentage Accurate: 79.6% → 99.2%

Time: 26.8s

Alternatives: 11

Speedup: 1.5×

Specification

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{1}{1 + 0.3275911 \cdot \left|x\right|}\\ 1 - \left(t_0 \cdot \left(0.254829592 + t_0 \cdot \left(-0.284496736 + t_0 \cdot \left(1.421413741 + t_0 \cdot \left(-1.453152027 + t_0 \cdot 1.061405429\right)\right)\right)\right)\right) \cdot e^{-\left|x\right| \cdot \left|x\right|} \end{array} \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (let* ((t_0 (/ 1.0 (+ 1.0 (* 0.3275911 (fabs x))))))
   (-
    1.0
    (*
     (*
      t_0
      (+
       0.254829592
       (*
        t_0
        (+
         -0.284496736
         (*
          t_0
          (+ 1.421413741 (* t_0 (+ -1.453152027 (* t_0 1.061405429)))))))))
     (exp (- (* (fabs x) (fabs x))))))))

C

double code(double x) {
	double t_0 = 1.0 / (1.0 + (0.3275911 * fabs(x)));
	return 1.0 - ((t_0 * (0.254829592 + (t_0 * (-0.284496736 + (t_0 * (1.421413741 + (t_0 * (-1.453152027 + (t_0 * 1.061405429))))))))) * exp(-(fabs(x) * fabs(x))));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    real(8) :: t_0
    t_0 = 1.0d0 / (1.0d0 + (0.3275911d0 * abs(x)))
    code = 1.0d0 - ((t_0 * (0.254829592d0 + (t_0 * ((-0.284496736d0) + (t_0 * (1.421413741d0 + (t_0 * ((-1.453152027d0) + (t_0 * 1.061405429d0))))))))) * exp(-(abs(x) * abs(x))))
end function

Java

public static double code(double x) {
	double t_0 = 1.0 / (1.0 + (0.3275911 * Math.abs(x)));
	return 1.0 - ((t_0 * (0.254829592 + (t_0 * (-0.284496736 + (t_0 * (1.421413741 + (t_0 * (-1.453152027 + (t_0 * 1.061405429))))))))) * Math.exp(-(Math.abs(x) * Math.abs(x))));
}

Python

def code(x):
	t_0 = 1.0 / (1.0 + (0.3275911 * math.fabs(x)))
	return 1.0 - ((t_0 * (0.254829592 + (t_0 * (-0.284496736 + (t_0 * (1.421413741 + (t_0 * (-1.453152027 + (t_0 * 1.061405429))))))))) * math.exp(-(math.fabs(x) * math.fabs(x))))

Julia

function code(x)
	t_0 = Float64(1.0 / Float64(1.0 + Float64(0.3275911 * abs(x))))
	return Float64(1.0 - Float64(Float64(t_0 * Float64(0.254829592 + Float64(t_0 * Float64(-0.284496736 + Float64(t_0 * Float64(1.421413741 + Float64(t_0 * Float64(-1.453152027 + Float64(t_0 * 1.061405429))))))))) * exp(Float64(-Float64(abs(x) * abs(x))))))
end

MATLAB

function tmp = code(x)
	t_0 = 1.0 / (1.0 + (0.3275911 * abs(x)));
	tmp = 1.0 - ((t_0 * (0.254829592 + (t_0 * (-0.284496736 + (t_0 * (1.421413741 + (t_0 * (-1.453152027 + (t_0 * 1.061405429))))))))) * exp(-(abs(x) * abs(x))));
end

Wolfram

code[x_] := Block[{t$95$0 = N[(1.0 / N[(1.0 + N[(0.3275911 * N[Abs[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, N[(1.0 - N[(N[(t$95$0 * N[(0.254829592 + N[(t$95$0 * N[(-0.284496736 + N[(t$95$0 * N[(1.421413741 + N[(t$95$0 * N[(-1.453152027 + N[(t$95$0 * 1.061405429), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Exp[(-N[(N[Abs[x], $MachinePrecision] * N[Abs[x], $MachinePrecision]), $MachinePrecision])], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Initial Program: 79.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{1}{1 + 0.3275911 \cdot \left|x\right|}\\ 1 - \left(t_0 \cdot \left(0.254829592 + t_0 \cdot \left(-0.284496736 + t_0 \cdot \left(1.421413741 + t_0 \cdot \left(-1.453152027 + t_0 \cdot 1.061405429\right)\right)\right)\right)\right) \cdot e^{-\left|x\right| \cdot \left|x\right|} \end{array} \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (let* ((t_0 (/ 1.0 (+ 1.0 (* 0.3275911 (fabs x))))))
   (-
    1.0
    (*
     (*
      t_0
      (+
       0.254829592
       (*
        t_0
        (+
         -0.284496736
         (*
          t_0
          (+ 1.421413741 (* t_0 (+ -1.453152027 (* t_0 1.061405429)))))))))
     (exp (- (* (fabs x) (fabs x))))))))

C

double code(double x) {
	double t_0 = 1.0 / (1.0 + (0.3275911 * fabs(x)));
	return 1.0 - ((t_0 * (0.254829592 + (t_0 * (-0.284496736 + (t_0 * (1.421413741 + (t_0 * (-1.453152027 + (t_0 * 1.061405429))))))))) * exp(-(fabs(x) * fabs(x))));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    real(8) :: t_0
    t_0 = 1.0d0 / (1.0d0 + (0.3275911d0 * abs(x)))
    code = 1.0d0 - ((t_0 * (0.254829592d0 + (t_0 * ((-0.284496736d0) + (t_0 * (1.421413741d0 + (t_0 * ((-1.453152027d0) + (t_0 * 1.061405429d0))))))))) * exp(-(abs(x) * abs(x))))
end function

Java

public static double code(double x) {
	double t_0 = 1.0 / (1.0 + (0.3275911 * Math.abs(x)));
	return 1.0 - ((t_0 * (0.254829592 + (t_0 * (-0.284496736 + (t_0 * (1.421413741 + (t_0 * (-1.453152027 + (t_0 * 1.061405429))))))))) * Math.exp(-(Math.abs(x) * Math.abs(x))));
}

Python

def code(x):
	t_0 = 1.0 / (1.0 + (0.3275911 * math.fabs(x)))
	return 1.0 - ((t_0 * (0.254829592 + (t_0 * (-0.284496736 + (t_0 * (1.421413741 + (t_0 * (-1.453152027 + (t_0 * 1.061405429))))))))) * math.exp(-(math.fabs(x) * math.fabs(x))))

Julia

function code(x)
	t_0 = Float64(1.0 / Float64(1.0 + Float64(0.3275911 * abs(x))))
	return Float64(1.0 - Float64(Float64(t_0 * Float64(0.254829592 + Float64(t_0 * Float64(-0.284496736 + Float64(t_0 * Float64(1.421413741 + Float64(t_0 * Float64(-1.453152027 + Float64(t_0 * 1.061405429))))))))) * exp(Float64(-Float64(abs(x) * abs(x))))))
end

MATLAB

function tmp = code(x)
	t_0 = 1.0 / (1.0 + (0.3275911 * abs(x)));
	tmp = 1.0 - ((t_0 * (0.254829592 + (t_0 * (-0.284496736 + (t_0 * (1.421413741 + (t_0 * (-1.453152027 + (t_0 * 1.061405429))))))))) * exp(-(abs(x) * abs(x))));
end

Wolfram

code[x_] := Block[{t$95$0 = N[(1.0 / N[(1.0 + N[(0.3275911 * N[Abs[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, N[(1.0 - N[(N[(t$95$0 * N[(0.254829592 + N[(t$95$0 * N[(-0.284496736 + N[(t$95$0 * N[(1.421413741 + N[(t$95$0 * N[(-1.453152027 + N[(t$95$0 * 1.061405429), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Exp[(-N[(N[Abs[x], $MachinePrecision] * N[Abs[x], $MachinePrecision]), $MachinePrecision])], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Alternative 1: 99.2% accurate, 0.5× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ \begin{array}{l} t_0 := \mathsf{fma}\left(0.3275911, \left|x_m\right|, 1\right)\\ t_1 := 1.421413741 + \frac{-1.453152027 + \frac{1.061405429}{\mathsf{fma}\left(0.3275911, x_m, 1\right)}}{\mathsf{fma}\left(0.3275911, x_m, 1\right)}\\ t_2 := \frac{0.254829592 + \frac{-0.284496736 + \frac{t_1}{\mathsf{fma}\left(0.3275911, x_m, 1\right)}}{\mathsf{fma}\left(0.3275911, x_m, 1\right)}}{\mathsf{fma}\left(0.3275911, x_m, 1\right) \cdot e^{{x_m}^{2}}}\\ \mathbf{if}\;\left|x_m\right| \leq 5 \cdot 10^{-5}:\\ \;\;\;\;\frac{2.999999997 \cdot 10^{-9} + \left(-3.820122044248399 \cdot {x_m}^{2} + \left(0.3111712305105463 \cdot {x_m}^{3} + x_m \cdot 3.385159067440336\right)\right)}{\mathsf{fma}\left(1 + t_2, t_2, 1\right)}\\ \mathbf{else}:\\ \;\;\;\;\log \left(e^{1 - \frac{e^{-{x_m}^{2}} \cdot \left(0.254829592 + \frac{-0.284496736 + \frac{t_1}{t_0}}{t_0}\right)}{1 + x_m \cdot 0.3275911}}\right)\\ \end{array} \end{array} \]

FPCore

x_m = (fabs.f64 x)
(FPCore (x_m)
 :precision binary64
 (let* ((t_0 (fma 0.3275911 (fabs x_m) 1.0))
        (t_1
         (+
          1.421413741
          (/
           (+ -1.453152027 (/ 1.061405429 (fma 0.3275911 x_m 1.0)))
           (fma 0.3275911 x_m 1.0))))
        (t_2
         (/
          (+
           0.254829592
           (/
            (+ -0.284496736 (/ t_1 (fma 0.3275911 x_m 1.0)))
            (fma 0.3275911 x_m 1.0)))
          (* (fma 0.3275911 x_m 1.0) (exp (pow x_m 2.0))))))
   (if (<= (fabs x_m) 5e-5)
     (/
      (+
       2.999999997e-9
       (+
        (* -3.820122044248399 (pow x_m 2.0))
        (+ (* 0.3111712305105463 (pow x_m 3.0)) (* x_m 3.385159067440336))))
      (fma (+ 1.0 t_2) t_2 1.0))
     (log
      (exp
       (-
        1.0
        (/
         (*
          (exp (- (pow x_m 2.0)))
          (+ 0.254829592 (/ (+ -0.284496736 (/ t_1 t_0)) t_0)))
         (+ 1.0 (* x_m 0.3275911)))))))))

C

x_m = fabs(x);
double code(double x_m) {
	double t_0 = fma(0.3275911, fabs(x_m), 1.0);
	double t_1 = 1.421413741 + ((-1.453152027 + (1.061405429 / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0));
	double t_2 = (0.254829592 + ((-0.284496736 + (t_1 / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0))) / (fma(0.3275911, x_m, 1.0) * exp(pow(x_m, 2.0)));
	double tmp;
	if (fabs(x_m) <= 5e-5) {
		tmp = (2.999999997e-9 + ((-3.820122044248399 * pow(x_m, 2.0)) + ((0.3111712305105463 * pow(x_m, 3.0)) + (x_m * 3.385159067440336)))) / fma((1.0 + t_2), t_2, 1.0);
	} else {
		tmp = log(exp((1.0 - ((exp(-pow(x_m, 2.0)) * (0.254829592 + ((-0.284496736 + (t_1 / t_0)) / t_0))) / (1.0 + (x_m * 0.3275911))))));
	}
	return tmp;
}

Julia

x_m = abs(x)
function code(x_m)
	t_0 = fma(0.3275911, abs(x_m), 1.0)
	t_1 = Float64(1.421413741 + Float64(Float64(-1.453152027 + Float64(1.061405429 / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0)))
	t_2 = Float64(Float64(0.254829592 + Float64(Float64(-0.284496736 + Float64(t_1 / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0))) / Float64(fma(0.3275911, x_m, 1.0) * exp((x_m ^ 2.0))))
	tmp = 0.0
	if (abs(x_m) <= 5e-5)
		tmp = Float64(Float64(2.999999997e-9 + Float64(Float64(-3.820122044248399 * (x_m ^ 2.0)) + Float64(Float64(0.3111712305105463 * (x_m ^ 3.0)) + Float64(x_m * 3.385159067440336)))) / fma(Float64(1.0 + t_2), t_2, 1.0));
	else
		tmp = log(exp(Float64(1.0 - Float64(Float64(exp(Float64(-(x_m ^ 2.0))) * Float64(0.254829592 + Float64(Float64(-0.284496736 + Float64(t_1 / t_0)) / t_0))) / Float64(1.0 + Float64(x_m * 0.3275911))))));
	end
	return tmp
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
code[x$95$m_] := Block[{t$95$0 = N[(0.3275911 * N[Abs[x$95$m], $MachinePrecision] + 1.0), $MachinePrecision]}, Block[{t$95$1 = N[(1.421413741 + N[(N[(-1.453152027 + N[(1.061405429 / N[(0.3275911 * x$95$m + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(0.3275911 * x$95$m + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(0.254829592 + N[(N[(-0.284496736 + N[(t$95$1 / N[(0.3275911 * x$95$m + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(0.3275911 * x$95$m + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(0.3275911 * x$95$m + 1.0), $MachinePrecision] * N[Exp[N[Power[x$95$m, 2.0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Abs[x$95$m], $MachinePrecision], 5e-5], N[(N[(2.999999997e-9 + N[(N[(-3.820122044248399 * N[Power[x$95$m, 2.0], $MachinePrecision]), $MachinePrecision] + N[(N[(0.3111712305105463 * N[Power[x$95$m, 3.0], $MachinePrecision]), $MachinePrecision] + N[(x$95$m * 3.385159067440336), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(1.0 + t$95$2), $MachinePrecision] * t$95$2 + 1.0), $MachinePrecision]), $MachinePrecision], N[Log[N[Exp[N[(1.0 - N[(N[(N[Exp[(-N[Power[x$95$m, 2.0], $MachinePrecision])], $MachinePrecision] * N[(0.254829592 + N[(N[(-0.284496736 + N[(t$95$1 / t$95$0), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[(x$95$m * 0.3275911), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]]]]]

Derivation

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

Alternative 2: 78.5% accurate, 0.4× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ \begin{array}{l} t_0 := \frac{1}{1 + \left|x_m\right| \cdot 0.3275911}\\ t_1 := 1.421413741 + \frac{-1.453152027 + \frac{1.061405429}{\mathsf{fma}\left(0.3275911, x_m, 1\right)}}{\mathsf{fma}\left(0.3275911, x_m, 1\right)}\\ t_2 := \frac{0.254829592 + \frac{-0.284496736 + \frac{t_1}{\mathsf{fma}\left(0.3275911, x_m, 1\right)}}{\mathsf{fma}\left(0.3275911, x_m, 1\right)}}{\mathsf{fma}\left(0.3275911, x_m, 1\right) \cdot e^{{x_m}^{2}}}\\ t_3 := \mathsf{fma}\left(0.3275911, \left|x_m\right|, 1\right)\\ \mathbf{if}\;\left(t_0 \cdot \left(0.254829592 + t_0 \cdot \left(-0.284496736 + t_0 \cdot \left(1.421413741 + t_0 \cdot \left(-1.453152027 + 1.061405429 \cdot t_0\right)\right)\right)\right)\right) \cdot e^{x_m \cdot \left(-x_m\right)} \leq 0.999999999:\\ \;\;\;\;\log \left(e^{1 - \frac{e^{-{x_m}^{2}} \cdot \left(0.254829592 + \frac{-0.284496736 + \frac{t_1}{t_3}}{t_3}\right)}{1 + x_m \cdot 0.3275911}}\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{2.999999997 \cdot 10^{-9}}{\mathsf{fma}\left(1 + t_2, t_2, 1\right)}\\ \end{array} \end{array} \]

FPCore

x_m = (fabs.f64 x)
(FPCore (x_m)
 :precision binary64
 (let* ((t_0 (/ 1.0 (+ 1.0 (* (fabs x_m) 0.3275911))))
        (t_1
         (+
          1.421413741
          (/
           (+ -1.453152027 (/ 1.061405429 (fma 0.3275911 x_m 1.0)))
           (fma 0.3275911 x_m 1.0))))
        (t_2
         (/
          (+
           0.254829592
           (/
            (+ -0.284496736 (/ t_1 (fma 0.3275911 x_m 1.0)))
            (fma 0.3275911 x_m 1.0)))
          (* (fma 0.3275911 x_m 1.0) (exp (pow x_m 2.0)))))
        (t_3 (fma 0.3275911 (fabs x_m) 1.0)))
   (if (<=
        (*
         (*
          t_0
          (+
           0.254829592
           (*
            t_0
            (+
             -0.284496736
             (*
              t_0
              (+ 1.421413741 (* t_0 (+ -1.453152027 (* 1.061405429 t_0)))))))))
         (exp (* x_m (- x_m))))
        0.999999999)
     (log
      (exp
       (-
        1.0
        (/
         (*
          (exp (- (pow x_m 2.0)))
          (+ 0.254829592 (/ (+ -0.284496736 (/ t_1 t_3)) t_3)))
         (+ 1.0 (* x_m 0.3275911))))))
     (/ 2.999999997e-9 (fma (+ 1.0 t_2) t_2 1.0)))))

C

x_m = fabs(x);
double code(double x_m) {
	double t_0 = 1.0 / (1.0 + (fabs(x_m) * 0.3275911));
	double t_1 = 1.421413741 + ((-1.453152027 + (1.061405429 / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0));
	double t_2 = (0.254829592 + ((-0.284496736 + (t_1 / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0))) / (fma(0.3275911, x_m, 1.0) * exp(pow(x_m, 2.0)));
	double t_3 = fma(0.3275911, fabs(x_m), 1.0);
	double tmp;
	if (((t_0 * (0.254829592 + (t_0 * (-0.284496736 + (t_0 * (1.421413741 + (t_0 * (-1.453152027 + (1.061405429 * t_0))))))))) * exp((x_m * -x_m))) <= 0.999999999) {
		tmp = log(exp((1.0 - ((exp(-pow(x_m, 2.0)) * (0.254829592 + ((-0.284496736 + (t_1 / t_3)) / t_3))) / (1.0 + (x_m * 0.3275911))))));
	} else {
		tmp = 2.999999997e-9 / fma((1.0 + t_2), t_2, 1.0);
	}
	return tmp;
}

Julia

x_m = abs(x)
function code(x_m)
	t_0 = Float64(1.0 / Float64(1.0 + Float64(abs(x_m) * 0.3275911)))
	t_1 = Float64(1.421413741 + Float64(Float64(-1.453152027 + Float64(1.061405429 / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0)))
	t_2 = Float64(Float64(0.254829592 + Float64(Float64(-0.284496736 + Float64(t_1 / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0))) / Float64(fma(0.3275911, x_m, 1.0) * exp((x_m ^ 2.0))))
	t_3 = fma(0.3275911, abs(x_m), 1.0)
	tmp = 0.0
	if (Float64(Float64(t_0 * Float64(0.254829592 + Float64(t_0 * Float64(-0.284496736 + Float64(t_0 * Float64(1.421413741 + Float64(t_0 * Float64(-1.453152027 + Float64(1.061405429 * t_0))))))))) * exp(Float64(x_m * Float64(-x_m)))) <= 0.999999999)
		tmp = log(exp(Float64(1.0 - Float64(Float64(exp(Float64(-(x_m ^ 2.0))) * Float64(0.254829592 + Float64(Float64(-0.284496736 + Float64(t_1 / t_3)) / t_3))) / Float64(1.0 + Float64(x_m * 0.3275911))))));
	else
		tmp = Float64(2.999999997e-9 / fma(Float64(1.0 + t_2), t_2, 1.0));
	end
	return tmp
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
code[x$95$m_] := Block[{t$95$0 = N[(1.0 / N[(1.0 + N[(N[Abs[x$95$m], $MachinePrecision] * 0.3275911), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(1.421413741 + N[(N[(-1.453152027 + N[(1.061405429 / N[(0.3275911 * x$95$m + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(0.3275911 * x$95$m + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(0.254829592 + N[(N[(-0.284496736 + N[(t$95$1 / N[(0.3275911 * x$95$m + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(0.3275911 * x$95$m + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(0.3275911 * x$95$m + 1.0), $MachinePrecision] * N[Exp[N[Power[x$95$m, 2.0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(0.3275911 * N[Abs[x$95$m], $MachinePrecision] + 1.0), $MachinePrecision]}, If[LessEqual[N[(N[(t$95$0 * N[(0.254829592 + N[(t$95$0 * N[(-0.284496736 + N[(t$95$0 * N[(1.421413741 + N[(t$95$0 * N[(-1.453152027 + N[(1.061405429 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Exp[N[(x$95$m * (-x$95$m)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 0.999999999], N[Log[N[Exp[N[(1.0 - N[(N[(N[Exp[(-N[Power[x$95$m, 2.0], $MachinePrecision])], $MachinePrecision] * N[(0.254829592 + N[(N[(-0.284496736 + N[(t$95$1 / t$95$3), $MachinePrecision]), $MachinePrecision] / t$95$3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[(x$95$m * 0.3275911), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision], N[(2.999999997e-9 / N[(N[(1.0 + t$95$2), $MachinePrecision] * t$95$2 + 1.0), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

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

Alternative 3: 99.0% accurate, 0.5× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ \begin{array}{l} t_0 := \mathsf{fma}\left(0.3275911, \left|x_m\right|, 1\right)\\ t_1 := 1.421413741 + \frac{-1.453152027 + \frac{1.061405429}{\mathsf{fma}\left(0.3275911, x_m, 1\right)}}{\mathsf{fma}\left(0.3275911, x_m, 1\right)}\\ t_2 := \frac{0.254829592 + \frac{-0.284496736 + \frac{t_1}{\mathsf{fma}\left(0.3275911, x_m, 1\right)}}{\mathsf{fma}\left(0.3275911, x_m, 1\right)}}{\mathsf{fma}\left(0.3275911, x_m, 1\right) \cdot e^{{x_m}^{2}}}\\ \mathbf{if}\;\left|x_m\right| \leq 10^{-8}:\\ \;\;\;\;\frac{2.999999997 \cdot 10^{-9} + \left(-3.820122044248399 \cdot {x_m}^{2} + x_m \cdot 3.385159067440336\right)}{\mathsf{fma}\left(1 + t_2, t_2, 1\right)}\\ \mathbf{else}:\\ \;\;\;\;\log \left(e^{1 - \frac{e^{-{x_m}^{2}} \cdot \left(0.254829592 + \frac{-0.284496736 + \frac{t_1}{t_0}}{t_0}\right)}{1 + x_m \cdot 0.3275911}}\right)\\ \end{array} \end{array} \]

FPCore

x_m = (fabs.f64 x)
(FPCore (x_m)
 :precision binary64
 (let* ((t_0 (fma 0.3275911 (fabs x_m) 1.0))
        (t_1
         (+
          1.421413741
          (/
           (+ -1.453152027 (/ 1.061405429 (fma 0.3275911 x_m 1.0)))
           (fma 0.3275911 x_m 1.0))))
        (t_2
         (/
          (+
           0.254829592
           (/
            (+ -0.284496736 (/ t_1 (fma 0.3275911 x_m 1.0)))
            (fma 0.3275911 x_m 1.0)))
          (* (fma 0.3275911 x_m 1.0) (exp (pow x_m 2.0))))))
   (if (<= (fabs x_m) 1e-8)
     (/
      (+
       2.999999997e-9
       (+ (* -3.820122044248399 (pow x_m 2.0)) (* x_m 3.385159067440336)))
      (fma (+ 1.0 t_2) t_2 1.0))
     (log
      (exp
       (-
        1.0
        (/
         (*
          (exp (- (pow x_m 2.0)))
          (+ 0.254829592 (/ (+ -0.284496736 (/ t_1 t_0)) t_0)))
         (+ 1.0 (* x_m 0.3275911)))))))))

C

x_m = fabs(x);
double code(double x_m) {
	double t_0 = fma(0.3275911, fabs(x_m), 1.0);
	double t_1 = 1.421413741 + ((-1.453152027 + (1.061405429 / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0));
	double t_2 = (0.254829592 + ((-0.284496736 + (t_1 / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0))) / (fma(0.3275911, x_m, 1.0) * exp(pow(x_m, 2.0)));
	double tmp;
	if (fabs(x_m) <= 1e-8) {
		tmp = (2.999999997e-9 + ((-3.820122044248399 * pow(x_m, 2.0)) + (x_m * 3.385159067440336))) / fma((1.0 + t_2), t_2, 1.0);
	} else {
		tmp = log(exp((1.0 - ((exp(-pow(x_m, 2.0)) * (0.254829592 + ((-0.284496736 + (t_1 / t_0)) / t_0))) / (1.0 + (x_m * 0.3275911))))));
	}
	return tmp;
}

Julia

x_m = abs(x)
function code(x_m)
	t_0 = fma(0.3275911, abs(x_m), 1.0)
	t_1 = Float64(1.421413741 + Float64(Float64(-1.453152027 + Float64(1.061405429 / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0)))
	t_2 = Float64(Float64(0.254829592 + Float64(Float64(-0.284496736 + Float64(t_1 / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0))) / Float64(fma(0.3275911, x_m, 1.0) * exp((x_m ^ 2.0))))
	tmp = 0.0
	if (abs(x_m) <= 1e-8)
		tmp = Float64(Float64(2.999999997e-9 + Float64(Float64(-3.820122044248399 * (x_m ^ 2.0)) + Float64(x_m * 3.385159067440336))) / fma(Float64(1.0 + t_2), t_2, 1.0));
	else
		tmp = log(exp(Float64(1.0 - Float64(Float64(exp(Float64(-(x_m ^ 2.0))) * Float64(0.254829592 + Float64(Float64(-0.284496736 + Float64(t_1 / t_0)) / t_0))) / Float64(1.0 + Float64(x_m * 0.3275911))))));
	end
	return tmp
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
code[x$95$m_] := Block[{t$95$0 = N[(0.3275911 * N[Abs[x$95$m], $MachinePrecision] + 1.0), $MachinePrecision]}, Block[{t$95$1 = N[(1.421413741 + N[(N[(-1.453152027 + N[(1.061405429 / N[(0.3275911 * x$95$m + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(0.3275911 * x$95$m + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(0.254829592 + N[(N[(-0.284496736 + N[(t$95$1 / N[(0.3275911 * x$95$m + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(0.3275911 * x$95$m + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(0.3275911 * x$95$m + 1.0), $MachinePrecision] * N[Exp[N[Power[x$95$m, 2.0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Abs[x$95$m], $MachinePrecision], 1e-8], N[(N[(2.999999997e-9 + N[(N[(-3.820122044248399 * N[Power[x$95$m, 2.0], $MachinePrecision]), $MachinePrecision] + N[(x$95$m * 3.385159067440336), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(1.0 + t$95$2), $MachinePrecision] * t$95$2 + 1.0), $MachinePrecision]), $MachinePrecision], N[Log[N[Exp[N[(1.0 - N[(N[(N[Exp[(-N[Power[x$95$m, 2.0], $MachinePrecision])], $MachinePrecision] * N[(0.254829592 + N[(N[(-0.284496736 + N[(t$95$1 / t$95$0), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[(x$95$m * 0.3275911), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]]]]]

Derivation

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

Alternative 4: 98.9% accurate, 0.5× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ \begin{array}{l} t_0 := 1.421413741 + \frac{-1.453152027 + \frac{1.061405429}{\mathsf{fma}\left(0.3275911, x_m, 1\right)}}{\mathsf{fma}\left(0.3275911, x_m, 1\right)}\\ t_1 := \mathsf{fma}\left(0.3275911, \left|x_m\right|, 1\right)\\ t_2 := \frac{0.254829592 + \frac{-0.284496736 + \frac{t_0}{\mathsf{fma}\left(0.3275911, x_m, 1\right)}}{\mathsf{fma}\left(0.3275911, x_m, 1\right)}}{\mathsf{fma}\left(0.3275911, x_m, 1\right) \cdot e^{{x_m}^{2}}}\\ \mathbf{if}\;\left|x_m\right| \leq 10^{-8}:\\ \;\;\;\;\frac{2.999999997 \cdot 10^{-9} + x_m \cdot 3.385159067440336}{\mathsf{fma}\left(1 + t_2, t_2, 1\right)}\\ \mathbf{else}:\\ \;\;\;\;\log \left(e^{1 - \frac{e^{-{x_m}^{2}} \cdot \left(0.254829592 + \frac{-0.284496736 + \frac{t_0}{t_1}}{t_1}\right)}{1 + x_m \cdot 0.3275911}}\right)\\ \end{array} \end{array} \]

FPCore

x_m = (fabs.f64 x)
(FPCore (x_m)
 :precision binary64
 (let* ((t_0
         (+
          1.421413741
          (/
           (+ -1.453152027 (/ 1.061405429 (fma 0.3275911 x_m 1.0)))
           (fma 0.3275911 x_m 1.0))))
        (t_1 (fma 0.3275911 (fabs x_m) 1.0))
        (t_2
         (/
          (+
           0.254829592
           (/
            (+ -0.284496736 (/ t_0 (fma 0.3275911 x_m 1.0)))
            (fma 0.3275911 x_m 1.0)))
          (* (fma 0.3275911 x_m 1.0) (exp (pow x_m 2.0))))))
   (if (<= (fabs x_m) 1e-8)
     (/ (+ 2.999999997e-9 (* x_m 3.385159067440336)) (fma (+ 1.0 t_2) t_2 1.0))
     (log
      (exp
       (-
        1.0
        (/
         (*
          (exp (- (pow x_m 2.0)))
          (+ 0.254829592 (/ (+ -0.284496736 (/ t_0 t_1)) t_1)))
         (+ 1.0 (* x_m 0.3275911)))))))))

C

x_m = fabs(x);
double code(double x_m) {
	double t_0 = 1.421413741 + ((-1.453152027 + (1.061405429 / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0));
	double t_1 = fma(0.3275911, fabs(x_m), 1.0);
	double t_2 = (0.254829592 + ((-0.284496736 + (t_0 / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0))) / (fma(0.3275911, x_m, 1.0) * exp(pow(x_m, 2.0)));
	double tmp;
	if (fabs(x_m) <= 1e-8) {
		tmp = (2.999999997e-9 + (x_m * 3.385159067440336)) / fma((1.0 + t_2), t_2, 1.0);
	} else {
		tmp = log(exp((1.0 - ((exp(-pow(x_m, 2.0)) * (0.254829592 + ((-0.284496736 + (t_0 / t_1)) / t_1))) / (1.0 + (x_m * 0.3275911))))));
	}
	return tmp;
}

Julia

x_m = abs(x)
function code(x_m)
	t_0 = Float64(1.421413741 + Float64(Float64(-1.453152027 + Float64(1.061405429 / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0)))
	t_1 = fma(0.3275911, abs(x_m), 1.0)
	t_2 = Float64(Float64(0.254829592 + Float64(Float64(-0.284496736 + Float64(t_0 / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0))) / Float64(fma(0.3275911, x_m, 1.0) * exp((x_m ^ 2.0))))
	tmp = 0.0
	if (abs(x_m) <= 1e-8)
		tmp = Float64(Float64(2.999999997e-9 + Float64(x_m * 3.385159067440336)) / fma(Float64(1.0 + t_2), t_2, 1.0));
	else
		tmp = log(exp(Float64(1.0 - Float64(Float64(exp(Float64(-(x_m ^ 2.0))) * Float64(0.254829592 + Float64(Float64(-0.284496736 + Float64(t_0 / t_1)) / t_1))) / Float64(1.0 + Float64(x_m * 0.3275911))))));
	end
	return tmp
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
code[x$95$m_] := Block[{t$95$0 = N[(1.421413741 + N[(N[(-1.453152027 + N[(1.061405429 / N[(0.3275911 * x$95$m + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(0.3275911 * x$95$m + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(0.3275911 * N[Abs[x$95$m], $MachinePrecision] + 1.0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(0.254829592 + N[(N[(-0.284496736 + N[(t$95$0 / N[(0.3275911 * x$95$m + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(0.3275911 * x$95$m + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(0.3275911 * x$95$m + 1.0), $MachinePrecision] * N[Exp[N[Power[x$95$m, 2.0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Abs[x$95$m], $MachinePrecision], 1e-8], N[(N[(2.999999997e-9 + N[(x$95$m * 3.385159067440336), $MachinePrecision]), $MachinePrecision] / N[(N[(1.0 + t$95$2), $MachinePrecision] * t$95$2 + 1.0), $MachinePrecision]), $MachinePrecision], N[Log[N[Exp[N[(1.0 - N[(N[(N[Exp[(-N[Power[x$95$m, 2.0], $MachinePrecision])], $MachinePrecision] * N[(0.254829592 + N[(N[(-0.284496736 + N[(t$95$0 / t$95$1), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[(x$95$m * 0.3275911), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]]]]]

Derivation

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

Alternative 5: 79.6% accurate, 0.8× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ 1 + \frac{\frac{\left(1 - e^{\mathsf{log1p}\left(\frac{-0.284496736 + \frac{1.421413741 + \frac{-1.453152027 + \frac{1.061405429}{\mathsf{fma}\left(0.3275911, x_m, 1\right)}}{\mathsf{fma}\left(0.3275911, x_m, 1\right)}}{\mathsf{fma}\left(0.3275911, x_m, 1\right)}}{\mathsf{fma}\left(0.3275911, x_m, 1\right)}\right)}\right) - 0.254829592}{{\left(e^{x_m}\right)}^{x_m}}}{\mathsf{fma}\left(0.3275911, \left|x_m\right|, 1\right)} \end{array} \]

FPCore

x_m = (fabs.f64 x)
(FPCore (x_m)
 :precision binary64
 (+
  1.0
  (/
   (/
    (-
     (-
      1.0
      (exp
       (log1p
        (/
         (+
          -0.284496736
          (/
           (+
            1.421413741
            (/
             (+ -1.453152027 (/ 1.061405429 (fma 0.3275911 x_m 1.0)))
             (fma 0.3275911 x_m 1.0)))
           (fma 0.3275911 x_m 1.0)))
         (fma 0.3275911 x_m 1.0)))))
     0.254829592)
    (pow (exp x_m) x_m))
   (fma 0.3275911 (fabs x_m) 1.0))))

C

x_m = fabs(x);
double code(double x_m) {
	return 1.0 + ((((1.0 - exp(log1p(((-0.284496736 + ((1.421413741 + ((-1.453152027 + (1.061405429 / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0))))) - 0.254829592) / pow(exp(x_m), x_m)) / fma(0.3275911, fabs(x_m), 1.0));
}

Julia

x_m = abs(x)
function code(x_m)
	return Float64(1.0 + Float64(Float64(Float64(Float64(1.0 - exp(log1p(Float64(Float64(-0.284496736 + Float64(Float64(1.421413741 + Float64(Float64(-1.453152027 + Float64(1.061405429 / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0))) / fma(0.3275911, x_m, 1.0))))) - 0.254829592) / (exp(x_m) ^ x_m)) / fma(0.3275911, abs(x_m), 1.0)))
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
code[x$95$m_] := N[(1.0 + N[(N[(N[(N[(1.0 - N[Exp[N[Log[1 + N[(N[(-0.284496736 + N[(N[(1.421413741 + N[(N[(-1.453152027 + N[(1.061405429 / N[(0.3275911 * x$95$m + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(0.3275911 * x$95$m + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(0.3275911 * x$95$m + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(0.3275911 * x$95$m + 1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - 0.254829592), $MachinePrecision] / N[Power[N[Exp[x$95$m], $MachinePrecision], x$95$m], $MachinePrecision]), $MachinePrecision] / N[(0.3275911 * N[Abs[x$95$m], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 6: 79.6% accurate, 1.5× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ \begin{array}{l} t_0 := 1 + \left|x_m\right| \cdot 0.3275911\\ t_1 := \frac{1}{t_0}\\ 1 + t_1 \cdot \left(e^{x_m \cdot \left(-x_m\right)} \cdot \left(t_1 \cdot \left(t_1 \cdot \left(\left(-1.453152027 + \frac{1.061405429}{1 + x_m \cdot 0.3275911}\right) \cdot \frac{-1}{t_0} - 1.421413741\right) - -0.284496736\right) - 0.254829592\right)\right) \end{array} \end{array} \]

FPCore

x_m = (fabs.f64 x)
(FPCore (x_m)
 :precision binary64
 (let* ((t_0 (+ 1.0 (* (fabs x_m) 0.3275911))) (t_1 (/ 1.0 t_0)))
   (+
    1.0
    (*
     t_1
     (*
      (exp (* x_m (- x_m)))
      (-
       (*
        t_1
        (-
         (*
          t_1
          (-
           (*
            (+ -1.453152027 (/ 1.061405429 (+ 1.0 (* x_m 0.3275911))))
            (/ -1.0 t_0))
           1.421413741))
         -0.284496736))
       0.254829592))))))

C

x_m = fabs(x);
double code(double x_m) {
	double t_0 = 1.0 + (fabs(x_m) * 0.3275911);
	double t_1 = 1.0 / t_0;
	return 1.0 + (t_1 * (exp((x_m * -x_m)) * ((t_1 * ((t_1 * (((-1.453152027 + (1.061405429 / (1.0 + (x_m * 0.3275911)))) * (-1.0 / t_0)) - 1.421413741)) - -0.284496736)) - 0.254829592)));
}

Fortran

x_m = abs(x)
real(8) function code(x_m)
    real(8), intent (in) :: x_m
    real(8) :: t_0
    real(8) :: t_1
    t_0 = 1.0d0 + (abs(x_m) * 0.3275911d0)
    t_1 = 1.0d0 / t_0
    code = 1.0d0 + (t_1 * (exp((x_m * -x_m)) * ((t_1 * ((t_1 * ((((-1.453152027d0) + (1.061405429d0 / (1.0d0 + (x_m * 0.3275911d0)))) * ((-1.0d0) / t_0)) - 1.421413741d0)) - (-0.284496736d0))) - 0.254829592d0)))
end function

Java

x_m = Math.abs(x);
public static double code(double x_m) {
	double t_0 = 1.0 + (Math.abs(x_m) * 0.3275911);
	double t_1 = 1.0 / t_0;
	return 1.0 + (t_1 * (Math.exp((x_m * -x_m)) * ((t_1 * ((t_1 * (((-1.453152027 + (1.061405429 / (1.0 + (x_m * 0.3275911)))) * (-1.0 / t_0)) - 1.421413741)) - -0.284496736)) - 0.254829592)));
}

Python

x_m = math.fabs(x)
def code(x_m):
	t_0 = 1.0 + (math.fabs(x_m) * 0.3275911)
	t_1 = 1.0 / t_0
	return 1.0 + (t_1 * (math.exp((x_m * -x_m)) * ((t_1 * ((t_1 * (((-1.453152027 + (1.061405429 / (1.0 + (x_m * 0.3275911)))) * (-1.0 / t_0)) - 1.421413741)) - -0.284496736)) - 0.254829592)))

Julia

x_m = abs(x)
function code(x_m)
	t_0 = Float64(1.0 + Float64(abs(x_m) * 0.3275911))
	t_1 = Float64(1.0 / t_0)
	return Float64(1.0 + Float64(t_1 * Float64(exp(Float64(x_m * Float64(-x_m))) * Float64(Float64(t_1 * Float64(Float64(t_1 * Float64(Float64(Float64(-1.453152027 + Float64(1.061405429 / Float64(1.0 + Float64(x_m * 0.3275911)))) * Float64(-1.0 / t_0)) - 1.421413741)) - -0.284496736)) - 0.254829592))))
end

MATLAB

x_m = abs(x);
function tmp = code(x_m)
	t_0 = 1.0 + (abs(x_m) * 0.3275911);
	t_1 = 1.0 / t_0;
	tmp = 1.0 + (t_1 * (exp((x_m * -x_m)) * ((t_1 * ((t_1 * (((-1.453152027 + (1.061405429 / (1.0 + (x_m * 0.3275911)))) * (-1.0 / t_0)) - 1.421413741)) - -0.284496736)) - 0.254829592)));
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
code[x$95$m_] := Block[{t$95$0 = N[(1.0 + N[(N[Abs[x$95$m], $MachinePrecision] * 0.3275911), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(1.0 / t$95$0), $MachinePrecision]}, N[(1.0 + N[(t$95$1 * N[(N[Exp[N[(x$95$m * (-x$95$m)), $MachinePrecision]], $MachinePrecision] * N[(N[(t$95$1 * N[(N[(t$95$1 * N[(N[(N[(-1.453152027 + N[(1.061405429 / N[(1.0 + N[(x$95$m * 0.3275911), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(-1.0 / t$95$0), $MachinePrecision]), $MachinePrecision] - 1.421413741), $MachinePrecision]), $MachinePrecision] - -0.284496736), $MachinePrecision]), $MachinePrecision] - 0.254829592), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 7: 79.0% accurate, 1.6× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ 1 - \frac{\frac{0.254829592 + \left(\frac{-0.284496736}{\mathsf{fma}\left(0.3275911, x_m, 1\right)} + \left(1.029667143 + x_m \cdot -0.8939938570904588\right)\right)}{{\left(e^{x_m}\right)}^{x_m}}}{\mathsf{fma}\left(0.3275911, \left|x_m\right|, 1\right)} \end{array} \]

FPCore

x_m = (fabs.f64 x)
(FPCore (x_m)
 :precision binary64
 (-
  1.0
  (/
   (/
    (+
     0.254829592
     (+
      (/ -0.284496736 (fma 0.3275911 x_m 1.0))
      (+ 1.029667143 (* x_m -0.8939938570904588))))
    (pow (exp x_m) x_m))
   (fma 0.3275911 (fabs x_m) 1.0))))

C

x_m = fabs(x);
double code(double x_m) {
	return 1.0 - (((0.254829592 + ((-0.284496736 / fma(0.3275911, x_m, 1.0)) + (1.029667143 + (x_m * -0.8939938570904588)))) / pow(exp(x_m), x_m)) / fma(0.3275911, fabs(x_m), 1.0));
}

Julia

x_m = abs(x)
function code(x_m)
	return Float64(1.0 - Float64(Float64(Float64(0.254829592 + Float64(Float64(-0.284496736 / fma(0.3275911, x_m, 1.0)) + Float64(1.029667143 + Float64(x_m * -0.8939938570904588)))) / (exp(x_m) ^ x_m)) / fma(0.3275911, abs(x_m), 1.0)))
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
code[x$95$m_] := N[(1.0 - N[(N[(N[(0.254829592 + N[(N[(-0.284496736 / N[(0.3275911 * x$95$m + 1.0), $MachinePrecision]), $MachinePrecision] + N[(1.029667143 + N[(x$95$m * -0.8939938570904588), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Power[N[Exp[x$95$m], $MachinePrecision], x$95$m], $MachinePrecision]), $MachinePrecision] / N[(0.3275911 * N[Abs[x$95$m], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 8: 79.1% accurate, 2.1× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ 1 - \frac{\frac{0.254829592 + \left(0.745170407 + x_m \cdot -0.8007952583978091\right)}{{\left(e^{x_m}\right)}^{x_m}}}{\mathsf{fma}\left(0.3275911, \left|x_m\right|, 1\right)} \end{array} \]

FPCore

x_m = (fabs.f64 x)
(FPCore (x_m)
 :precision binary64
 (-
  1.0
  (/
   (/
    (+ 0.254829592 (+ 0.745170407 (* x_m -0.8007952583978091)))
    (pow (exp x_m) x_m))
   (fma 0.3275911 (fabs x_m) 1.0))))

C

x_m = fabs(x);
double code(double x_m) {
	return 1.0 - (((0.254829592 + (0.745170407 + (x_m * -0.8007952583978091))) / pow(exp(x_m), x_m)) / fma(0.3275911, fabs(x_m), 1.0));
}

Julia

x_m = abs(x)
function code(x_m)
	return Float64(1.0 - Float64(Float64(Float64(0.254829592 + Float64(0.745170407 + Float64(x_m * -0.8007952583978091))) / (exp(x_m) ^ x_m)) / fma(0.3275911, abs(x_m), 1.0)))
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
code[x$95$m_] := N[(1.0 - N[(N[(N[(0.254829592 + N[(0.745170407 + N[(x$95$m * -0.8007952583978091), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Power[N[Exp[x$95$m], $MachinePrecision], x$95$m], $MachinePrecision]), $MachinePrecision] / N[(0.3275911 * N[Abs[x$95$m], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 9: 77.4% accurate, 2.7× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ {\left({\left(1 + 0.999999999 \cdot \frac{-1}{1 + \left|x_m\right| \cdot 0.3275911}\right)}^{3}\right)}^{0.3333333333333333} \end{array} \]

FPCore

x_m = (fabs.f64 x)
(FPCore (x_m)
 :precision binary64
 (pow
  (pow (+ 1.0 (* 0.999999999 (/ -1.0 (+ 1.0 (* (fabs x_m) 0.3275911))))) 3.0)
  0.3333333333333333))

C

x_m = fabs(x);
double code(double x_m) {
	return pow(pow((1.0 + (0.999999999 * (-1.0 / (1.0 + (fabs(x_m) * 0.3275911))))), 3.0), 0.3333333333333333);
}

Fortran

x_m = abs(x)
real(8) function code(x_m)
    real(8), intent (in) :: x_m
    code = ((1.0d0 + (0.999999999d0 * ((-1.0d0) / (1.0d0 + (abs(x_m) * 0.3275911d0))))) ** 3.0d0) ** 0.3333333333333333d0
end function

Java

x_m = Math.abs(x);
public static double code(double x_m) {
	return Math.pow(Math.pow((1.0 + (0.999999999 * (-1.0 / (1.0 + (Math.abs(x_m) * 0.3275911))))), 3.0), 0.3333333333333333);
}

Python

x_m = math.fabs(x)
def code(x_m):
	return math.pow(math.pow((1.0 + (0.999999999 * (-1.0 / (1.0 + (math.fabs(x_m) * 0.3275911))))), 3.0), 0.3333333333333333)

Julia

x_m = abs(x)
function code(x_m)
	return (Float64(1.0 + Float64(0.999999999 * Float64(-1.0 / Float64(1.0 + Float64(abs(x_m) * 0.3275911))))) ^ 3.0) ^ 0.3333333333333333
end

MATLAB

x_m = abs(x);
function tmp = code(x_m)
	tmp = ((1.0 + (0.999999999 * (-1.0 / (1.0 + (abs(x_m) * 0.3275911))))) ^ 3.0) ^ 0.3333333333333333;
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
code[x$95$m_] := N[Power[N[Power[N[(1.0 + N[(0.999999999 * N[(-1.0 / N[(1.0 + N[(N[Abs[x$95$m], $MachinePrecision] * 0.3275911), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision], 0.3333333333333333], $MachinePrecision]

Derivation

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

Alternative 10: 77.4% accurate, 7.9× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ 1 + \frac{-0.999999999}{1 + \left|x_m\right| \cdot 0.3275911} \end{array} \]

FPCore

x_m = (fabs.f64 x)
(FPCore (x_m)
 :precision binary64
 (+ 1.0 (/ -0.999999999 (+ 1.0 (* (fabs x_m) 0.3275911)))))

C

x_m = fabs(x);
double code(double x_m) {
	return 1.0 + (-0.999999999 / (1.0 + (fabs(x_m) * 0.3275911)));
}

Fortran

x_m = abs(x)
real(8) function code(x_m)
    real(8), intent (in) :: x_m
    code = 1.0d0 + ((-0.999999999d0) / (1.0d0 + (abs(x_m) * 0.3275911d0)))
end function

Java

x_m = Math.abs(x);
public static double code(double x_m) {
	return 1.0 + (-0.999999999 / (1.0 + (Math.abs(x_m) * 0.3275911)));
}

Python

x_m = math.fabs(x)
def code(x_m):
	return 1.0 + (-0.999999999 / (1.0 + (math.fabs(x_m) * 0.3275911)))

Julia

x_m = abs(x)
function code(x_m)
	return Float64(1.0 + Float64(-0.999999999 / Float64(1.0 + Float64(abs(x_m) * 0.3275911))))
end

MATLAB

x_m = abs(x);
function tmp = code(x_m)
	tmp = 1.0 + (-0.999999999 / (1.0 + (abs(x_m) * 0.3275911)));
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
code[x$95$m_] := N[(1.0 + N[(-0.999999999 / N[(1.0 + N[(N[Abs[x$95$m], $MachinePrecision] * 0.3275911), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 11: 12.3% accurate, 95.1× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ 0.8007952583978091 \cdot \frac{x_m}{1 + x_m \cdot 0.3275911} \end{array} \]

FPCore

x_m = (fabs.f64 x)
(FPCore (x_m)
 :precision binary64
 (* 0.8007952583978091 (/ x_m (+ 1.0 (* x_m 0.3275911)))))

C

x_m = fabs(x);
double code(double x_m) {
	return 0.8007952583978091 * (x_m / (1.0 + (x_m * 0.3275911)));
}

Fortran

x_m = abs(x)
real(8) function code(x_m)
    real(8), intent (in) :: x_m
    code = 0.8007952583978091d0 * (x_m / (1.0d0 + (x_m * 0.3275911d0)))
end function

Java

x_m = Math.abs(x);
public static double code(double x_m) {
	return 0.8007952583978091 * (x_m / (1.0 + (x_m * 0.3275911)));
}

Python

x_m = math.fabs(x)
def code(x_m):
	return 0.8007952583978091 * (x_m / (1.0 + (x_m * 0.3275911)))

Julia

x_m = abs(x)
function code(x_m)
	return Float64(0.8007952583978091 * Float64(x_m / Float64(1.0 + Float64(x_m * 0.3275911))))
end

MATLAB

x_m = abs(x);
function tmp = code(x_m)
	tmp = 0.8007952583978091 * (x_m / (1.0 + (x_m * 0.3275911)));
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
code[x$95$m_] := N[(0.8007952583978091 * N[(x$95$m / N[(1.0 + N[(x$95$m * 0.3275911), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Reproduce

herbie shell --seed 2024008 
(FPCore (x)
  :name "Jmat.Real.erf"
  :precision binary64
  (- 1.0 (* (* (/ 1.0 (+ 1.0 (* 0.3275911 (fabs x)))) (+ 0.254829592 (* (/ 1.0 (+ 1.0 (* 0.3275911 (fabs x)))) (+ -0.284496736 (* (/ 1.0 (+ 1.0 (* 0.3275911 (fabs x)))) (+ 1.421413741 (* (/ 1.0 (+ 1.0 (* 0.3275911 (fabs x)))) (+ -1.453152027 (* (/ 1.0 (+ 1.0 (* 0.3275911 (fabs x)))) 1.061405429))))))))) (exp (- (* (fabs x) (fabs x)))))))