ENA, Section 1.4, Exercise 1

Percentage Accurate: 94.5% → 94.5%

Time: 15.4s

Alternatives: 13

Speedup: 1.0×

Specification

\[1.99 \leq x \land x \leq 2.01\]

Math

\[\begin{array}{l} \\ \cos x \cdot e^{10 \cdot \left(x \cdot x\right)} \end{array} \]

FPCore

(FPCore (x) :precision binary64 (* (cos x) (exp (* 10.0 (* x x)))))

C

double code(double x) {
	return cos(x) * exp((10.0 * (x * x)));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = cos(x) * exp((10.0d0 * (x * x)))
end function

Java

public static double code(double x) {
	return Math.cos(x) * Math.exp((10.0 * (x * x)));
}

Python

def code(x):
	return math.cos(x) * math.exp((10.0 * (x * x)))

Julia

function code(x)
	return Float64(cos(x) * exp(Float64(10.0 * Float64(x * x))))
end

MATLAB

function tmp = code(x)
	tmp = cos(x) * exp((10.0 * (x * x)));
end

Wolfram

code[x_] := N[(N[Cos[x], $MachinePrecision] * N[Exp[N[(10.0 * N[(x * x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Initial Program: 94.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \cos x \cdot e^{10 \cdot \left(x \cdot x\right)} \end{array} \]

FPCore

(FPCore (x) :precision binary64 (* (cos x) (exp (* 10.0 (* x x)))))

C

double code(double x) {
	return cos(x) * exp((10.0 * (x * x)));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = cos(x) * exp((10.0d0 * (x * x)))
end function

Java

public static double code(double x) {
	return Math.cos(x) * Math.exp((10.0 * (x * x)));
}

Python

def code(x):
	return math.cos(x) * math.exp((10.0 * (x * x)))

Julia

function code(x)
	return Float64(cos(x) * exp(Float64(10.0 * Float64(x * x))))
end

MATLAB

function tmp = code(x)
	tmp = cos(x) * exp((10.0 * (x * x)));
end

Wolfram

code[x_] := N[(N[Cos[x], $MachinePrecision] * N[Exp[N[(10.0 * N[(x * x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Alternative 1: 94.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \cos x \cdot e^{10 \cdot \left(x \cdot x\right)} \end{array} \]

FPCore

(FPCore (x) :precision binary64 (* (cos x) (exp (* 10.0 (* x x)))))

C

double code(double x) {
	return cos(x) * exp((10.0 * (x * x)));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = cos(x) * exp((10.0d0 * (x * x)))
end function

Java

public static double code(double x) {
	return Math.cos(x) * Math.exp((10.0 * (x * x)));
}

Python

def code(x):
	return math.cos(x) * math.exp((10.0 * (x * x)))

Julia

function code(x)
	return Float64(cos(x) * exp(Float64(10.0 * Float64(x * x))))
end

MATLAB

function tmp = code(x)
	tmp = cos(x) * exp((10.0 * (x * x)));
end

Wolfram

code[x_] := N[(N[Cos[x], $MachinePrecision] * N[Exp[N[(10.0 * N[(x * x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 94.5%

   \[\cos x \cdot e^{10 \cdot \left(x \cdot x\right)} \]
2. Add Preprocessing
3. Add Preprocessing

Alternative 2: 28.9% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := x \cdot \left(x \cdot x\right)\\ \left(1 - \left(0.5 + \left(x \cdot x\right) \cdot \frac{-7.233796296296296 \cdot 10^{-5} - t\_0 \cdot \left(t\_0 \cdot 2.6791838134430728 \cdot 10^{-9}\right)}{0.001736111111111111 + \left(\left(\left(x \cdot x\right) \cdot \left(x \cdot x\right)\right) \cdot 1.9290123456790124 \cdot 10^{-6} + -0.041666666666666664 \cdot \left(\left(x \cdot x\right) \cdot -0.001388888888888889\right)\right)}\right) \cdot \left(x \cdot x\right)\right) \cdot e^{10 \cdot \left(x \cdot x\right)} \end{array} \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (let* ((t_0 (* x (* x x))))
   (*
    (-
     1.0
     (*
      (+
       0.5
       (*
        (* x x)
        (/
         (- -7.233796296296296e-5 (* t_0 (* t_0 2.6791838134430728e-9)))
         (+
          0.001736111111111111
          (+
           (* (* (* x x) (* x x)) 1.9290123456790124e-6)
           (* -0.041666666666666664 (* (* x x) -0.001388888888888889)))))))
      (* x x)))
    (exp (* 10.0 (* x x))))))

C

double code(double x) {
	double t_0 = x * (x * x);
	return (1.0 - ((0.5 + ((x * x) * ((-7.233796296296296e-5 - (t_0 * (t_0 * 2.6791838134430728e-9))) / (0.001736111111111111 + ((((x * x) * (x * x)) * 1.9290123456790124e-6) + (-0.041666666666666664 * ((x * x) * -0.001388888888888889))))))) * (x * x))) * exp((10.0 * (x * x)));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    real(8) :: t_0
    t_0 = x * (x * x)
    code = (1.0d0 - ((0.5d0 + ((x * x) * (((-7.233796296296296d-5) - (t_0 * (t_0 * 2.6791838134430728d-9))) / (0.001736111111111111d0 + ((((x * x) * (x * x)) * 1.9290123456790124d-6) + ((-0.041666666666666664d0) * ((x * x) * (-0.001388888888888889d0)))))))) * (x * x))) * exp((10.0d0 * (x * x)))
end function

Java

public static double code(double x) {
	double t_0 = x * (x * x);
	return (1.0 - ((0.5 + ((x * x) * ((-7.233796296296296e-5 - (t_0 * (t_0 * 2.6791838134430728e-9))) / (0.001736111111111111 + ((((x * x) * (x * x)) * 1.9290123456790124e-6) + (-0.041666666666666664 * ((x * x) * -0.001388888888888889))))))) * (x * x))) * Math.exp((10.0 * (x * x)));
}

Python

def code(x):
	t_0 = x * (x * x)
	return (1.0 - ((0.5 + ((x * x) * ((-7.233796296296296e-5 - (t_0 * (t_0 * 2.6791838134430728e-9))) / (0.001736111111111111 + ((((x * x) * (x * x)) * 1.9290123456790124e-6) + (-0.041666666666666664 * ((x * x) * -0.001388888888888889))))))) * (x * x))) * math.exp((10.0 * (x * x)))

Julia

function code(x)
	t_0 = Float64(x * Float64(x * x))
	return Float64(Float64(1.0 - Float64(Float64(0.5 + Float64(Float64(x * x) * Float64(Float64(-7.233796296296296e-5 - Float64(t_0 * Float64(t_0 * 2.6791838134430728e-9))) / Float64(0.001736111111111111 + Float64(Float64(Float64(Float64(x * x) * Float64(x * x)) * 1.9290123456790124e-6) + Float64(-0.041666666666666664 * Float64(Float64(x * x) * -0.001388888888888889))))))) * Float64(x * x))) * exp(Float64(10.0 * Float64(x * x))))
end

MATLAB

function tmp = code(x)
	t_0 = x * (x * x);
	tmp = (1.0 - ((0.5 + ((x * x) * ((-7.233796296296296e-5 - (t_0 * (t_0 * 2.6791838134430728e-9))) / (0.001736111111111111 + ((((x * x) * (x * x)) * 1.9290123456790124e-6) + (-0.041666666666666664 * ((x * x) * -0.001388888888888889))))))) * (x * x))) * exp((10.0 * (x * x)));
end

Wolfram

code[x_] := Block[{t$95$0 = N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]}, N[(N[(1.0 - N[(N[(0.5 + N[(N[(x * x), $MachinePrecision] * N[(N[(-7.233796296296296e-5 - N[(t$95$0 * N[(t$95$0 * 2.6791838134430728e-9), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(0.001736111111111111 + N[(N[(N[(N[(x * x), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision] * 1.9290123456790124e-6), $MachinePrecision] + N[(-0.041666666666666664 * N[(N[(x * x), $MachinePrecision] * -0.001388888888888889), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Exp[N[(10.0 * N[(x * x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]

Derivation

1. Initial program 94.5%

   \[\cos x \cdot e^{10 \cdot \left(x \cdot x\right)} \]
2. Add Preprocessing

3. Taylor expanded in x around 0 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]

7. Applied egg-rr 0

   \[\leadsto expr\]

9. Applied egg-rr 0

   \[\leadsto expr\]

11. Applied egg-rr 0

    \[\leadsto expr\]
12. Add Preprocessing

Alternative 3: 28.2% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \left(1 - \left(x \cdot x\right) \cdot \left(0.5 + \frac{x \cdot \left(x \cdot 0.001736111111111111\right)}{-0.041666666666666664 + \left(x \cdot x\right) \cdot -0.001388888888888889}\right)\right) \cdot e^{x \cdot \left(10 \cdot x\right)} \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (*
  (-
   1.0
   (*
    (* x x)
    (+
     0.5
     (/
      (* x (* x 0.001736111111111111))
      (+ -0.041666666666666664 (* (* x x) -0.001388888888888889))))))
  (exp (* x (* 10.0 x)))))

C

double code(double x) {
	return (1.0 - ((x * x) * (0.5 + ((x * (x * 0.001736111111111111)) / (-0.041666666666666664 + ((x * x) * -0.001388888888888889)))))) * exp((x * (10.0 * x)));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = (1.0d0 - ((x * x) * (0.5d0 + ((x * (x * 0.001736111111111111d0)) / ((-0.041666666666666664d0) + ((x * x) * (-0.001388888888888889d0))))))) * exp((x * (10.0d0 * x)))
end function

Java

public static double code(double x) {
	return (1.0 - ((x * x) * (0.5 + ((x * (x * 0.001736111111111111)) / (-0.041666666666666664 + ((x * x) * -0.001388888888888889)))))) * Math.exp((x * (10.0 * x)));
}

Python

def code(x):
	return (1.0 - ((x * x) * (0.5 + ((x * (x * 0.001736111111111111)) / (-0.041666666666666664 + ((x * x) * -0.001388888888888889)))))) * math.exp((x * (10.0 * x)))

Julia

function code(x)
	return Float64(Float64(1.0 - Float64(Float64(x * x) * Float64(0.5 + Float64(Float64(x * Float64(x * 0.001736111111111111)) / Float64(-0.041666666666666664 + Float64(Float64(x * x) * -0.001388888888888889)))))) * exp(Float64(x * Float64(10.0 * x))))
end

MATLAB

function tmp = code(x)
	tmp = (1.0 - ((x * x) * (0.5 + ((x * (x * 0.001736111111111111)) / (-0.041666666666666664 + ((x * x) * -0.001388888888888889)))))) * exp((x * (10.0 * x)));
end

Wolfram

code[x_] := N[(N[(1.0 - N[(N[(x * x), $MachinePrecision] * N[(0.5 + N[(N[(x * N[(x * 0.001736111111111111), $MachinePrecision]), $MachinePrecision] / N[(-0.041666666666666664 + N[(N[(x * x), $MachinePrecision] * -0.001388888888888889), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Exp[N[(x * N[(10.0 * x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 94.5%

   \[\cos x \cdot e^{10 \cdot \left(x \cdot x\right)} \]
2. Add Preprocessing

3. Taylor expanded in x around 0 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]

7. Applied egg-rr 0

   \[\leadsto expr\]

8. Taylor expanded in x around 0 0

   \[\leadsto expr\]

10. Simplified 0

    \[\leadsto expr\]

12. Applied egg-rr 0

    \[\leadsto expr\]
13. Add Preprocessing

Alternative 4: 27.5% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \left(1 - x \cdot \left(x \cdot \left(0.5 + \left(x \cdot x\right) \cdot \left(-0.041666666666666664 - x \cdot \left(x \cdot -0.001388888888888889\right)\right)\right)\right)\right) \cdot e^{10 \cdot \left(x \cdot x\right)} \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (*
  (-
   1.0
   (*
    x
    (*
     x
     (+
      0.5
      (*
       (* x x)
       (- -0.041666666666666664 (* x (* x -0.001388888888888889))))))))
  (exp (* 10.0 (* x x)))))

C

double code(double x) {
	return (1.0 - (x * (x * (0.5 + ((x * x) * (-0.041666666666666664 - (x * (x * -0.001388888888888889)))))))) * exp((10.0 * (x * x)));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = (1.0d0 - (x * (x * (0.5d0 + ((x * x) * ((-0.041666666666666664d0) - (x * (x * (-0.001388888888888889d0))))))))) * exp((10.0d0 * (x * x)))
end function

Java

public static double code(double x) {
	return (1.0 - (x * (x * (0.5 + ((x * x) * (-0.041666666666666664 - (x * (x * -0.001388888888888889)))))))) * Math.exp((10.0 * (x * x)));
}

Python

def code(x):
	return (1.0 - (x * (x * (0.5 + ((x * x) * (-0.041666666666666664 - (x * (x * -0.001388888888888889)))))))) * math.exp((10.0 * (x * x)))

Julia

function code(x)
	return Float64(Float64(1.0 - Float64(x * Float64(x * Float64(0.5 + Float64(Float64(x * x) * Float64(-0.041666666666666664 - Float64(x * Float64(x * -0.001388888888888889)))))))) * exp(Float64(10.0 * Float64(x * x))))
end

MATLAB

function tmp = code(x)
	tmp = (1.0 - (x * (x * (0.5 + ((x * x) * (-0.041666666666666664 - (x * (x * -0.001388888888888889)))))))) * exp((10.0 * (x * x)));
end

Wolfram

code[x_] := N[(N[(1.0 - N[(x * N[(x * N[(0.5 + N[(N[(x * x), $MachinePrecision] * N[(-0.041666666666666664 - N[(x * N[(x * -0.001388888888888889), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Exp[N[(10.0 * N[(x * x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 94.5%

   \[\cos x \cdot e^{10 \cdot \left(x \cdot x\right)} \]
2. Add Preprocessing

3. Taylor expanded in x around 0 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]

7. Applied egg-rr 0

   \[\leadsto expr\]
8. Add Preprocessing

Alternative 5: 21.3% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \left(1 + x \cdot \left(x \cdot \left(-0.5 + \left(x \cdot x\right) \cdot 0.041666666666666664\right)\right)\right) \cdot e^{x \cdot \left(x \cdot 10\right)} \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (*
  (+ 1.0 (* x (* x (+ -0.5 (* (* x x) 0.041666666666666664)))))
  (exp (* x (* x 10.0)))))

C

double code(double x) {
	return (1.0 + (x * (x * (-0.5 + ((x * x) * 0.041666666666666664))))) * exp((x * (x * 10.0)));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = (1.0d0 + (x * (x * ((-0.5d0) + ((x * x) * 0.041666666666666664d0))))) * exp((x * (x * 10.0d0)))
end function

Java

public static double code(double x) {
	return (1.0 + (x * (x * (-0.5 + ((x * x) * 0.041666666666666664))))) * Math.exp((x * (x * 10.0)));
}

Python

def code(x):
	return (1.0 + (x * (x * (-0.5 + ((x * x) * 0.041666666666666664))))) * math.exp((x * (x * 10.0)))

Julia

function code(x)
	return Float64(Float64(1.0 + Float64(x * Float64(x * Float64(-0.5 + Float64(Float64(x * x) * 0.041666666666666664))))) * exp(Float64(x * Float64(x * 10.0))))
end

MATLAB

function tmp = code(x)
	tmp = (1.0 + (x * (x * (-0.5 + ((x * x) * 0.041666666666666664))))) * exp((x * (x * 10.0)));
end

Wolfram

code[x_] := N[(N[(1.0 + N[(x * N[(x * N[(-0.5 + N[(N[(x * x), $MachinePrecision] * 0.041666666666666664), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Exp[N[(x * N[(x * 10.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 94.5%

   \[\cos x \cdot e^{10 \cdot \left(x \cdot x\right)} \]

3. Simplified 0

   \[\leadsto expr\]
4. Add Preprocessing

5. Taylor expanded in x around 0 0

   \[\leadsto expr\]

7. Simplified 0

   \[\leadsto expr\]

8. Taylor expanded in x around 0 0

   \[\leadsto expr\]

10. Simplified 0

    \[\leadsto expr\]
11. Add Preprocessing

Alternative 6: 18.2% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \left(1 - \left(x \cdot x\right) \cdot 0.5\right) \cdot e^{10 \cdot \left(x \cdot x\right)} \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (* (- 1.0 (* (* x x) 0.5)) (exp (* 10.0 (* x x)))))

C

double code(double x) {
	return (1.0 - ((x * x) * 0.5)) * exp((10.0 * (x * x)));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = (1.0d0 - ((x * x) * 0.5d0)) * exp((10.0d0 * (x * x)))
end function

Java

public static double code(double x) {
	return (1.0 - ((x * x) * 0.5)) * Math.exp((10.0 * (x * x)));
}

Python

def code(x):
	return (1.0 - ((x * x) * 0.5)) * math.exp((10.0 * (x * x)))

Julia

function code(x)
	return Float64(Float64(1.0 - Float64(Float64(x * x) * 0.5)) * exp(Float64(10.0 * Float64(x * x))))
end

MATLAB

function tmp = code(x)
	tmp = (1.0 - ((x * x) * 0.5)) * exp((10.0 * (x * x)));
end

Wolfram

code[x_] := N[(N[(1.0 - N[(N[(x * x), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision] * N[Exp[N[(10.0 * N[(x * x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 94.5%

   \[\cos x \cdot e^{10 \cdot \left(x \cdot x\right)} \]
2. Add Preprocessing

3. Taylor expanded in x around 0 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]
6. Add Preprocessing

Alternative 7: 16.9% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ x \cdot \left(x \cdot \left(e^{x \cdot \left(10 \cdot x\right)} \cdot -0.5\right)\right) \end{array} \]

FPCore

(FPCore (x) :precision binary64 (* x (* x (* (exp (* x (* 10.0 x))) -0.5))))

C

double code(double x) {
	return x * (x * (exp((x * (10.0 * x))) * -0.5));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = x * (x * (exp((x * (10.0d0 * x))) * (-0.5d0)))
end function

Java

public static double code(double x) {
	return x * (x * (Math.exp((x * (10.0 * x))) * -0.5));
}

Python

def code(x):
	return x * (x * (math.exp((x * (10.0 * x))) * -0.5))

Julia

function code(x)
	return Float64(x * Float64(x * Float64(exp(Float64(x * Float64(10.0 * x))) * -0.5)))
end

MATLAB

function tmp = code(x)
	tmp = x * (x * (exp((x * (10.0 * x))) * -0.5));
end

Wolfram

code[x_] := N[(x * N[(x * N[(N[Exp[N[(x * N[(10.0 * x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 94.5%

   \[\cos x \cdot e^{10 \cdot \left(x \cdot x\right)} \]

3. Simplified 0

   \[\leadsto expr\]
4. Add Preprocessing

5. Taylor expanded in x around 0 0

   \[\leadsto expr\]

7. Simplified 0

   \[\leadsto expr\]

9. Applied egg-rr 0

   \[\leadsto expr\]

10. Taylor expanded in x around inf 0

    \[\leadsto expr\]

12. Simplified 0

    \[\leadsto expr\]
13. Add Preprocessing

Alternative 8: 10.3% accurate, 7.7× speedup

Math

\[\begin{array}{l} \\ \left(1 - \left(x \cdot x\right) \cdot 0.5\right) \cdot \left(1 + \left(x \cdot x\right) \cdot \left(10 + \left(x \cdot x\right) \cdot \left(50 + x \cdot \left(x \cdot 166.66666666666666\right)\right)\right)\right) \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (*
  (- 1.0 (* (* x x) 0.5))
  (+
   1.0
   (* (* x x) (+ 10.0 (* (* x x) (+ 50.0 (* x (* x 166.66666666666666)))))))))

C

double code(double x) {
	return (1.0 - ((x * x) * 0.5)) * (1.0 + ((x * x) * (10.0 + ((x * x) * (50.0 + (x * (x * 166.66666666666666)))))));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = (1.0d0 - ((x * x) * 0.5d0)) * (1.0d0 + ((x * x) * (10.0d0 + ((x * x) * (50.0d0 + (x * (x * 166.66666666666666d0)))))))
end function

Java

public static double code(double x) {
	return (1.0 - ((x * x) * 0.5)) * (1.0 + ((x * x) * (10.0 + ((x * x) * (50.0 + (x * (x * 166.66666666666666)))))));
}

Python

def code(x):
	return (1.0 - ((x * x) * 0.5)) * (1.0 + ((x * x) * (10.0 + ((x * x) * (50.0 + (x * (x * 166.66666666666666)))))))

Julia

function code(x)
	return Float64(Float64(1.0 - Float64(Float64(x * x) * 0.5)) * Float64(1.0 + Float64(Float64(x * x) * Float64(10.0 + Float64(Float64(x * x) * Float64(50.0 + Float64(x * Float64(x * 166.66666666666666))))))))
end

MATLAB

function tmp = code(x)
	tmp = (1.0 - ((x * x) * 0.5)) * (1.0 + ((x * x) * (10.0 + ((x * x) * (50.0 + (x * (x * 166.66666666666666)))))));
end

Wolfram

code[x_] := N[(N[(1.0 - N[(N[(x * x), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision] * N[(1.0 + N[(N[(x * x), $MachinePrecision] * N[(10.0 + N[(N[(x * x), $MachinePrecision] * N[(50.0 + N[(x * N[(x * 166.66666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 94.5%

   \[\cos x \cdot e^{10 \cdot \left(x \cdot x\right)} \]

3. Simplified 0

   \[\leadsto expr\]
4. Add Preprocessing

5. Taylor expanded in x around 0 0

   \[\leadsto expr\]

7. Simplified 0

   \[\leadsto expr\]

8. Taylor expanded in x around 0 0

   \[\leadsto expr\]

10. Simplified 0

    \[\leadsto expr\]
11. Add Preprocessing

Alternative 9: 10.1% accurate, 9.9× speedup

Math

\[\begin{array}{l} \\ \left(1 - \left(x \cdot x\right) \cdot 0.5\right) \cdot \left(1 + \left(x \cdot x\right) \cdot \left(10 + \left(x \cdot x\right) \cdot 50\right)\right) \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (* (- 1.0 (* (* x x) 0.5)) (+ 1.0 (* (* x x) (+ 10.0 (* (* x x) 50.0))))))

C

double code(double x) {
	return (1.0 - ((x * x) * 0.5)) * (1.0 + ((x * x) * (10.0 + ((x * x) * 50.0))));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = (1.0d0 - ((x * x) * 0.5d0)) * (1.0d0 + ((x * x) * (10.0d0 + ((x * x) * 50.0d0))))
end function

Java

public static double code(double x) {
	return (1.0 - ((x * x) * 0.5)) * (1.0 + ((x * x) * (10.0 + ((x * x) * 50.0))));
}

Python

def code(x):
	return (1.0 - ((x * x) * 0.5)) * (1.0 + ((x * x) * (10.0 + ((x * x) * 50.0))))

Julia

function code(x)
	return Float64(Float64(1.0 - Float64(Float64(x * x) * 0.5)) * Float64(1.0 + Float64(Float64(x * x) * Float64(10.0 + Float64(Float64(x * x) * 50.0)))))
end

MATLAB

function tmp = code(x)
	tmp = (1.0 - ((x * x) * 0.5)) * (1.0 + ((x * x) * (10.0 + ((x * x) * 50.0))));
end

Wolfram

code[x_] := N[(N[(1.0 - N[(N[(x * x), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision] * N[(1.0 + N[(N[(x * x), $MachinePrecision] * N[(10.0 + N[(N[(x * x), $MachinePrecision] * 50.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 94.5%

   \[\cos x \cdot e^{10 \cdot \left(x \cdot x\right)} \]

3. Simplified 0

   \[\leadsto expr\]
4. Add Preprocessing

5. Taylor expanded in x around 0 0

   \[\leadsto expr\]

7. Simplified 0

   \[\leadsto expr\]

8. Taylor expanded in x around 0 0

   \[\leadsto expr\]

10. Simplified 0

    \[\leadsto expr\]
11. Add Preprocessing

Alternative 10: 9.9% accurate, 13.8× speedup

Math

\[\begin{array}{l} \\ \left(1 - \left(x \cdot x\right) \cdot 0.5\right) \cdot \left(1 + 10 \cdot \left(x \cdot x\right)\right) \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (* (- 1.0 (* (* x x) 0.5)) (+ 1.0 (* 10.0 (* x x)))))

C

double code(double x) {
	return (1.0 - ((x * x) * 0.5)) * (1.0 + (10.0 * (x * x)));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = (1.0d0 - ((x * x) * 0.5d0)) * (1.0d0 + (10.0d0 * (x * x)))
end function

Java

public static double code(double x) {
	return (1.0 - ((x * x) * 0.5)) * (1.0 + (10.0 * (x * x)));
}

Python

def code(x):
	return (1.0 - ((x * x) * 0.5)) * (1.0 + (10.0 * (x * x)))

Julia

function code(x)
	return Float64(Float64(1.0 - Float64(Float64(x * x) * 0.5)) * Float64(1.0 + Float64(10.0 * Float64(x * x))))
end

MATLAB

function tmp = code(x)
	tmp = (1.0 - ((x * x) * 0.5)) * (1.0 + (10.0 * (x * x)));
end

Wolfram

code[x_] := N[(N[(1.0 - N[(N[(x * x), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision] * N[(1.0 + N[(10.0 * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 94.5%

   \[\cos x \cdot e^{10 \cdot \left(x \cdot x\right)} \]

3. Simplified 0

   \[\leadsto expr\]
4. Add Preprocessing

5. Taylor expanded in x around 0 0

   \[\leadsto expr\]

7. Simplified 0

   \[\leadsto expr\]

8. Taylor expanded in x around 0 0

   \[\leadsto expr\]

10. Simplified 0

    \[\leadsto expr\]
11. Add Preprocessing

Alternative 11: 9.9% accurate, 15.9× speedup

Math

\[\begin{array}{l} \\ 1 + \left(x \cdot x\right) \cdot \left(9.5 + \left(x \cdot x\right) \cdot -4.958333333333333\right) \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (+ 1.0 (* (* x x) (+ 9.5 (* (* x x) -4.958333333333333)))))

C

double code(double x) {
	return 1.0 + ((x * x) * (9.5 + ((x * x) * -4.958333333333333)));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = 1.0d0 + ((x * x) * (9.5d0 + ((x * x) * (-4.958333333333333d0))))
end function

Java

public static double code(double x) {
	return 1.0 + ((x * x) * (9.5 + ((x * x) * -4.958333333333333)));
}

Python

def code(x):
	return 1.0 + ((x * x) * (9.5 + ((x * x) * -4.958333333333333)))

Julia

function code(x)
	return Float64(1.0 + Float64(Float64(x * x) * Float64(9.5 + Float64(Float64(x * x) * -4.958333333333333))))
end

MATLAB

function tmp = code(x)
	tmp = 1.0 + ((x * x) * (9.5 + ((x * x) * -4.958333333333333)));
end

Wolfram

code[x_] := N[(1.0 + N[(N[(x * x), $MachinePrecision] * N[(9.5 + N[(N[(x * x), $MachinePrecision] * -4.958333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 94.5%

   \[\cos x \cdot e^{10 \cdot \left(x \cdot x\right)} \]
2. Add Preprocessing

3. Taylor expanded in x around 0 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]

6. Taylor expanded in x around 0 0

   \[\leadsto expr\]

8. Simplified 0

   \[\leadsto expr\]
9. Add Preprocessing

Alternative 12: 9.7% accurate, 41.4× speedup

Math

\[\begin{array}{l} \\ \left(x \cdot x\right) \cdot -0.5 \end{array} \]

FPCore

(FPCore (x) :precision binary64 (* (* x x) -0.5))

C

double code(double x) {
	return (x * x) * -0.5;
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = (x * x) * (-0.5d0)
end function

Java

public static double code(double x) {
	return (x * x) * -0.5;
}

Python

def code(x):
	return (x * x) * -0.5

Julia

function code(x)
	return Float64(Float64(x * x) * -0.5)
end

MATLAB

function tmp = code(x)
	tmp = (x * x) * -0.5;
end

Wolfram

code[x_] := N[(N[(x * x), $MachinePrecision] * -0.5), $MachinePrecision]

Derivation

1. Initial program 94.5%

   \[\cos x \cdot e^{10 \cdot \left(x \cdot x\right)} \]

3. Simplified 0

   \[\leadsto expr\]
4. Add Preprocessing

5. Taylor expanded in x around 0 0

   \[\leadsto expr\]

7. Simplified 0

   \[\leadsto expr\]

8. Taylor expanded in x around 0 0

   \[\leadsto expr\]

10. Simplified 0

    \[\leadsto expr\]

11. Taylor expanded in x around inf 0

    \[\leadsto expr\]

13. Simplified 0

    \[\leadsto expr\]
14. Add Preprocessing

Alternative 13: 1.5% accurate, 207.0× speedup

Math

\[\begin{array}{l} \\ 1 \end{array} \]

FPCore

(FPCore (x) :precision binary64 1.0)

C

double code(double x) {
	return 1.0;
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = 1.0d0
end function

Java

public static double code(double x) {
	return 1.0;
}

Python

def code(x):
	return 1.0

Julia

function code(x)
	return 1.0
end

MATLAB

function tmp = code(x)
	tmp = 1.0;
end

Wolfram

code[x_] := 1.0

Derivation

1. Initial program 94.5%

   \[\cos x \cdot e^{10 \cdot \left(x \cdot x\right)} \]
2. Add Preprocessing

3. Taylor expanded in x around 0 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]
6. Add Preprocessing

Reproduce

herbie shell --seed 2024110 
(FPCore (x)
  :name "ENA, Section 1.4, Exercise 1"
  :precision binary64
  :pre (and (<= 1.99 x) (<= x 2.01))
  (* (cos x) (exp (* 10.0 (* x x)))))