Data.Number.Erf:$cinvnormcdf from erf-2.0.0.0, A

Percentage Accurate: 99.4% → 99.4%

Time: 21.2s

Alternatives: 15

Speedup: 1.1×

• 44.4% of points produce a very large (infinite) output. You may want to add a precondition.

Specification

Math

\[\begin{array}{l} \\ \left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (* (* (- (* x 0.5) y) (sqrt (* z 2.0))) (exp (/ (* t t) 2.0))))

C

double code(double x, double y, double z, double t) {
	return (((x * 0.5) - y) * sqrt((z * 2.0))) * exp(((t * t) / 2.0));
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = (((x * 0.5d0) - y) * sqrt((z * 2.0d0))) * exp(((t * t) / 2.0d0))
end function

Java

public static double code(double x, double y, double z, double t) {
	return (((x * 0.5) - y) * Math.sqrt((z * 2.0))) * Math.exp(((t * t) / 2.0));
}

Python

def code(x, y, z, t):
	return (((x * 0.5) - y) * math.sqrt((z * 2.0))) * math.exp(((t * t) / 2.0))

Julia

function code(x, y, z, t)
	return Float64(Float64(Float64(Float64(x * 0.5) - y) * sqrt(Float64(z * 2.0))) * exp(Float64(Float64(t * t) / 2.0)))
end

MATLAB

function tmp = code(x, y, z, t)
	tmp = (((x * 0.5) - y) * sqrt((z * 2.0))) * exp(((t * t) / 2.0));
end

Wolfram

code[x_, y_, z_, t_] := N[(N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Exp[N[(N[(t * t), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Initial Program: 99.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (* (* (- (* x 0.5) y) (sqrt (* z 2.0))) (exp (/ (* t t) 2.0))))

C

double code(double x, double y, double z, double t) {
	return (((x * 0.5) - y) * sqrt((z * 2.0))) * exp(((t * t) / 2.0));
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = (((x * 0.5d0) - y) * sqrt((z * 2.0d0))) * exp(((t * t) / 2.0d0))
end function

Java

public static double code(double x, double y, double z, double t) {
	return (((x * 0.5) - y) * Math.sqrt((z * 2.0))) * Math.exp(((t * t) / 2.0));
}

Python

def code(x, y, z, t):
	return (((x * 0.5) - y) * math.sqrt((z * 2.0))) * math.exp(((t * t) / 2.0))

Julia

function code(x, y, z, t)
	return Float64(Float64(Float64(Float64(x * 0.5) - y) * sqrt(Float64(z * 2.0))) * exp(Float64(Float64(t * t) / 2.0)))
end

MATLAB

function tmp = code(x, y, z, t)
	tmp = (((x * 0.5) - y) * sqrt((z * 2.0))) * exp(((t * t) / 2.0));
end

Wolfram

code[x_, y_, z_, t_] := N[(N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Exp[N[(N[(t * t), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Alternative 1: 99.4% accurate, 0.6× speedup

Math

\[\begin{array}{l} t_m = \left|t\right| \\ \left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot {\left(e^{-t\_m}\right)}^{\left(t\_m \cdot -0.5\right)} \end{array} \]

FPCore

t_m = (fabs.f64 t)
(FPCore (x y z t_m)
 :precision binary64
 (* (* (- (* x 0.5) y) (sqrt (* z 2.0))) (pow (exp (- t_m)) (* t_m -0.5))))

C

t_m = fabs(t);
double code(double x, double y, double z, double t_m) {
	return (((x * 0.5) - y) * sqrt((z * 2.0))) * pow(exp(-t_m), (t_m * -0.5));
}

Fortran

t_m = abs(t)
real(8) function code(x, y, z, t_m)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t_m
    code = (((x * 0.5d0) - y) * sqrt((z * 2.0d0))) * (exp(-t_m) ** (t_m * (-0.5d0)))
end function

Java

t_m = Math.abs(t);
public static double code(double x, double y, double z, double t_m) {
	return (((x * 0.5) - y) * Math.sqrt((z * 2.0))) * Math.pow(Math.exp(-t_m), (t_m * -0.5));
}

Python

t_m = math.fabs(t)
def code(x, y, z, t_m):
	return (((x * 0.5) - y) * math.sqrt((z * 2.0))) * math.pow(math.exp(-t_m), (t_m * -0.5))

Julia

t_m = abs(t)
function code(x, y, z, t_m)
	return Float64(Float64(Float64(Float64(x * 0.5) - y) * sqrt(Float64(z * 2.0))) * (exp(Float64(-t_m)) ^ Float64(t_m * -0.5)))
end

MATLAB

t_m = abs(t);
function tmp = code(x, y, z, t_m)
	tmp = (((x * 0.5) - y) * sqrt((z * 2.0))) * (exp(-t_m) ^ (t_m * -0.5));
end

Wolfram

t_m = N[Abs[t], $MachinePrecision]
code[x_, y_, z_, t$95$m_] := N[(N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Power[N[Exp[(-t$95$m)], $MachinePrecision], N[(t$95$m * -0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.7%

   \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
2. Add Preprocessing
3. Step-by-step derivation

   1. lift-exp.f64 N/A

      \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot \color{blue}{e^{\frac{t \cdot t}{2}}} \]

   2. lift-/.f64 N/A

      \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\color{blue}{\frac{t \cdot t}{2}}} \]

   3. frac-2neg N/A

      \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\color{blue}{\frac{\mathsf{neg}\left(t \cdot t\right)}{\mathsf{neg}\left(2\right)}}} \]

   4. div-inv N/A

      \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\color{blue}{\left(\mathsf{neg}\left(t \cdot t\right)\right) \cdot \frac{1}{\mathsf{neg}\left(2\right)}}} \]

   5. lift-*.f64 N/A

      \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\left(\mathsf{neg}\left(\color{blue}{t \cdot t}\right)\right) \cdot \frac{1}{\mathsf{neg}\left(2\right)}} \]

   6. distribute-lft-neg-in N/A

      \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\color{blue}{\left(\left(\mathsf{neg}\left(t\right)\right) \cdot t\right)} \cdot \frac{1}{\mathsf{neg}\left(2\right)}} \]

   7. associate-*l* N/A

      \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\color{blue}{\left(\mathsf{neg}\left(t\right)\right) \cdot \left(t \cdot \frac{1}{\mathsf{neg}\left(2\right)}\right)}} \]

   8. exp-prod N/A

      \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot \color{blue}{{\left(e^{\mathsf{neg}\left(t\right)}\right)}^{\left(t \cdot \frac{1}{\mathsf{neg}\left(2\right)}\right)}} \]

   9. lower-pow.f64 N/A

      \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot \color{blue}{{\left(e^{\mathsf{neg}\left(t\right)}\right)}^{\left(t \cdot \frac{1}{\mathsf{neg}\left(2\right)}\right)}} \]

   10. lower-exp.f64 N/A

       \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot {\color{blue}{\left(e^{\mathsf{neg}\left(t\right)}\right)}}^{\left(t \cdot \frac{1}{\mathsf{neg}\left(2\right)}\right)} \]

   11. lower-neg.f64 N/A

       \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot {\left(e^{\color{blue}{\mathsf{neg}\left(t\right)}}\right)}^{\left(t \cdot \frac{1}{\mathsf{neg}\left(2\right)}\right)} \]

   12. lower-*.f64 N/A

       \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot {\left(e^{\mathsf{neg}\left(t\right)}\right)}^{\color{blue}{\left(t \cdot \frac{1}{\mathsf{neg}\left(2\right)}\right)}} \]

   13. metadata-eval N/A

       \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot {\left(e^{\mathsf{neg}\left(t\right)}\right)}^{\left(t \cdot \frac{1}{\color{blue}{-2}}\right)} \]

   14. metadata-eval 99.8

       \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot {\left(e^{-t}\right)}^{\left(t \cdot \color{blue}{-0.5}\right)} \]

4. Applied rewrites 99.8%

   \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot \color{blue}{{\left(e^{-t}\right)}^{\left(t \cdot -0.5\right)}} \]
5. Add Preprocessing

Alternative 2: 99.4% accurate, 0.6× speedup

Math

\[\begin{array}{l} t_m = \left|t\right| \\ \left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot {\left(e^{t\_m}\right)}^{\left(0.5 \cdot t\_m\right)} \end{array} \]

FPCore

t_m = (fabs.f64 t)
(FPCore (x y z t_m)
 :precision binary64
 (* (* (- (* x 0.5) y) (sqrt (* z 2.0))) (pow (exp t_m) (* 0.5 t_m))))

C

t_m = fabs(t);
double code(double x, double y, double z, double t_m) {
	return (((x * 0.5) - y) * sqrt((z * 2.0))) * pow(exp(t_m), (0.5 * t_m));
}

Fortran

t_m = abs(t)
real(8) function code(x, y, z, t_m)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t_m
    code = (((x * 0.5d0) - y) * sqrt((z * 2.0d0))) * (exp(t_m) ** (0.5d0 * t_m))
end function

Java

t_m = Math.abs(t);
public static double code(double x, double y, double z, double t_m) {
	return (((x * 0.5) - y) * Math.sqrt((z * 2.0))) * Math.pow(Math.exp(t_m), (0.5 * t_m));
}

Python

t_m = math.fabs(t)
def code(x, y, z, t_m):
	return (((x * 0.5) - y) * math.sqrt((z * 2.0))) * math.pow(math.exp(t_m), (0.5 * t_m))

Julia

t_m = abs(t)
function code(x, y, z, t_m)
	return Float64(Float64(Float64(Float64(x * 0.5) - y) * sqrt(Float64(z * 2.0))) * (exp(t_m) ^ Float64(0.5 * t_m)))
end

MATLAB

t_m = abs(t);
function tmp = code(x, y, z, t_m)
	tmp = (((x * 0.5) - y) * sqrt((z * 2.0))) * (exp(t_m) ^ (0.5 * t_m));
end

Wolfram

t_m = N[Abs[t], $MachinePrecision]
code[x_, y_, z_, t$95$m_] := N[(N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Power[N[Exp[t$95$m], $MachinePrecision], N[(0.5 * t$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.4%

   \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
2. Add Preprocessing
3. Step-by-step derivation

   1. lift-exp.f64 N/A

      \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot \color{blue}{e^{\frac{t \cdot t}{2}}} \]

   2. lift-/.f64 N/A

      \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\color{blue}{\frac{t \cdot t}{2}}} \]

   3. lift-*.f64 N/A

      \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{\color{blue}{t \cdot t}}{2}} \]

   4. associate-/l* N/A

      \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\color{blue}{t \cdot \frac{t}{2}}} \]

   5. exp-prod N/A

      \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot \color{blue}{{\left(e^{t}\right)}^{\left(\frac{t}{2}\right)}} \]

   6. lower-pow.f64 N/A

      \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot \color{blue}{{\left(e^{t}\right)}^{\left(\frac{t}{2}\right)}} \]

   7. lower-exp.f64 N/A

      \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot {\color{blue}{\left(e^{t}\right)}}^{\left(\frac{t}{2}\right)} \]

   8. div-inv N/A

      \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot {\left(e^{t}\right)}^{\color{blue}{\left(t \cdot \frac{1}{2}\right)}} \]

   9. metadata-eval N/A

      \[\leadsto \left(\left(x \cdot \frac{1}{2} - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot {\left(e^{t}\right)}^{\left(t \cdot \color{blue}{\frac{1}{2}}\right)} \]

   10. lower-*.f64 99.4

       \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot {\left(e^{t}\right)}^{\color{blue}{\left(t \cdot 0.5\right)}} \]

4. Applied rewrites 99.4%

   \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot \color{blue}{{\left(e^{t}\right)}^{\left(t \cdot 0.5\right)}} \]

5. Final simplification 99.4%

   \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot {\left(e^{t}\right)}^{\left(0.5 \cdot t\right)} \]
6. Add Preprocessing

Developer Target 1: 99.4% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot {\left(e^{1}\right)}^{\left(\frac{t \cdot t}{2}\right)} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (* (* (- (* x 0.5) y) (sqrt (* z 2.0))) (pow (exp 1.0) (/ (* t t) 2.0))))

C

double code(double x, double y, double z, double t) {
	return (((x * 0.5) - y) * sqrt((z * 2.0))) * pow(exp(1.0), ((t * t) / 2.0));
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = (((x * 0.5d0) - y) * sqrt((z * 2.0d0))) * (exp(1.0d0) ** ((t * t) / 2.0d0))
end function

Java

public static double code(double x, double y, double z, double t) {
	return (((x * 0.5) - y) * Math.sqrt((z * 2.0))) * Math.pow(Math.exp(1.0), ((t * t) / 2.0));
}

Python

def code(x, y, z, t):
	return (((x * 0.5) - y) * math.sqrt((z * 2.0))) * math.pow(math.exp(1.0), ((t * t) / 2.0))

Julia

function code(x, y, z, t)
	return Float64(Float64(Float64(Float64(x * 0.5) - y) * sqrt(Float64(z * 2.0))) * (exp(1.0) ^ Float64(Float64(t * t) / 2.0)))
end

MATLAB

function tmp = code(x, y, z, t)
	tmp = (((x * 0.5) - y) * sqrt((z * 2.0))) * (exp(1.0) ^ ((t * t) / 2.0));
end

Wolfram

code[x_, y_, z_, t_] := N[(N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Power[N[Exp[1.0], $MachinePrecision], N[(N[(t * t), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Reproduce

herbie shell --seed 2024226 
(FPCore (x y z t)
  :name "Data.Number.Erf:$cinvnormcdf from erf-2.0.0.0, A"
  :precision binary64

  :alt
  (! :herbie-platform default (* (* (- (* x 1/2) y) (sqrt (* z 2))) (pow (exp 1) (/ (* t t) 2))))

  (* (* (- (* x 0.5) y) (sqrt (* z 2.0))) (exp (/ (* t t) 2.0))))