fma_test2

Percentage Accurate: 33.8% → 99.6%

Time: 6.1s

Alternatives: 4

Speedup: 1.7×

Specification

\[1.9 \leq t \land t \leq 2.1\]

Math

\[\begin{array}{l} \\ 1.7 \cdot 10^{+308} \cdot t - 1.7 \cdot 10^{+308} \end{array} \]

FPCore

(FPCore (t) :precision binary64 (- (* 1.7e+308 t) 1.7e+308))

C

double code(double t) {
	return (1.7e+308 * t) - 1.7e+308;
}

Fortran

real(8) function code(t)
    real(8), intent (in) :: t
    code = (1.7d+308 * t) - 1.7d+308
end function

Java

public static double code(double t) {
	return (1.7e+308 * t) - 1.7e+308;
}

Python

def code(t):
	return (1.7e+308 * t) - 1.7e+308

Julia

function code(t)
	return Float64(Float64(1.7e+308 * t) - 1.7e+308)
end

MATLAB

function tmp = code(t)
	tmp = (1.7e+308 * t) - 1.7e+308;
end

Wolfram

code[t_] := N[(N[(1.7e+308 * t), $MachinePrecision] - 1.7e+308), $MachinePrecision]

Initial Program: 33.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ 1.7 \cdot 10^{+308} \cdot t - 1.7 \cdot 10^{+308} \end{array} \]

FPCore

(FPCore (t) :precision binary64 (- (* 1.7e+308 t) 1.7e+308))

C

double code(double t) {
	return (1.7e+308 * t) - 1.7e+308;
}

Fortran

real(8) function code(t)
    real(8), intent (in) :: t
    code = (1.7d+308 * t) - 1.7d+308
end function

Java

public static double code(double t) {
	return (1.7e+308 * t) - 1.7e+308;
}

Python

def code(t):
	return (1.7e+308 * t) - 1.7e+308

Julia

function code(t)
	return Float64(Float64(1.7e+308 * t) - 1.7e+308)
end

MATLAB

function tmp = code(t)
	tmp = (1.7e+308 * t) - 1.7e+308;
end

Wolfram

code[t_] := N[(N[(1.7e+308 * t), $MachinePrecision] - 1.7e+308), $MachinePrecision]

Alternative 1: 99.6% accurate, 0.0× speedup

Math

\[\begin{array}{l} \\ \mathsf{fma}\left(1.7 \cdot 10^{+308}, t, -1.7 \cdot 10^{+308}\right) \end{array} \]

FPCore

(FPCore (t) :precision binary64 (fma 1.7e+308 t -1.7e+308))

C

double code(double t) {
	return fma(1.7e+308, t, -1.7e+308);
}

Julia

function code(t)
	return fma(1.7e+308, t, -1.7e+308)
end

Wolfram

code[t_] := N[(1.7e+308 * t + -1.7e+308), $MachinePrecision]

Derivation

1. Initial program 32.4%

   \[1.7 \cdot 10^{+308} \cdot t - 1.7 \cdot 10^{+308} \]
2. Step-by-step derivation

   1. fma-neg 99.6%

      \[\leadsto \color{blue}{\mathsf{fma}\left(1.7 \cdot 10^{+308}, t, -1.7 \cdot 10^{+308}\right)} \]

   2. metadata-eval 99.6%

      \[\leadsto \mathsf{fma}\left(1.7 \cdot 10^{+308}, t, \color{blue}{-1.7 \cdot 10^{+308}}\right) \]

3. Simplified 99.6%

   \[\leadsto \color{blue}{\mathsf{fma}\left(1.7 \cdot 10^{+308}, t, -1.7 \cdot 10^{+308}\right)} \]

4. Final simplification 99.6%

   \[\leadsto \mathsf{fma}\left(1.7 \cdot 10^{+308}, t, -1.7 \cdot 10^{+308}\right) \]

Alternative 2: 99.1% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \frac{1.7 \cdot 10^{+308}}{\left(t + 1\right) + t \cdot t} \cdot \left(t \cdot \left(t \cdot t\right) + -1\right) \end{array} \]

FPCore

(FPCore (t)
 :precision binary64
 (* (/ 1.7e+308 (+ (+ t 1.0) (* t t))) (+ (* t (* t t)) -1.0)))

C

double code(double t) {
	return (1.7e+308 / ((t + 1.0) + (t * t))) * ((t * (t * t)) + -1.0);
}

Fortran

real(8) function code(t)
    real(8), intent (in) :: t
    code = (1.7d+308 / ((t + 1.0d0) + (t * t))) * ((t * (t * t)) + (-1.0d0))
end function

Java

public static double code(double t) {
	return (1.7e+308 / ((t + 1.0) + (t * t))) * ((t * (t * t)) + -1.0);
}

Python

def code(t):
	return (1.7e+308 / ((t + 1.0) + (t * t))) * ((t * (t * t)) + -1.0)

Julia

function code(t)
	return Float64(Float64(1.7e+308 / Float64(Float64(t + 1.0) + Float64(t * t))) * Float64(Float64(t * Float64(t * t)) + -1.0))
end

MATLAB

function tmp = code(t)
	tmp = (1.7e+308 / ((t + 1.0) + (t * t))) * ((t * (t * t)) + -1.0);
end

Wolfram

code[t_] := N[(N[(1.7e+308 / N[(N[(t + 1.0), $MachinePrecision] + N[(t * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(t * N[(t * t), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 32.4%

   \[1.7 \cdot 10^{+308} \cdot t - 1.7 \cdot 10^{+308} \]

3. Applied egg-rr 0.0%

   \[\leadsto \color{blue}{\left(+\infty \cdot {t}^{3} + -\infty\right) \cdot \frac{1}{t \cdot \left(t \cdot +\infty\right) + \left(+\infty + t \cdot +\infty\right)}} \]

5. Simplified 99.1%

   \[\leadsto \color{blue}{\frac{1.7 \cdot 10^{+308}}{t + \mathsf{fma}\left(t, t, 1\right)} \cdot \left({t}^{3} + -1\right)} \]

6. Taylor expanded in t around 0 99.2%

   \[\leadsto \frac{1.7 \cdot 10^{+308}}{\color{blue}{1 + \left(t + {t}^{2}\right)}} \cdot \left({t}^{3} + -1\right) \]
7. Step-by-step derivation

   1. associate-+r+ 99.1%

      \[\leadsto \frac{1.7 \cdot 10^{+308}}{\color{blue}{\left(1 + t\right) + {t}^{2}}} \cdot \left({t}^{3} + -1\right) \]

   2. +-commutative 99.1%

      \[\leadsto \frac{1.7 \cdot 10^{+308}}{\color{blue}{\left(t + 1\right)} + {t}^{2}} \cdot \left({t}^{3} + -1\right) \]

   3. unpow2 99.1%

      \[\leadsto \frac{1.7 \cdot 10^{+308}}{\left(t + 1\right) + \color{blue}{t \cdot t}} \cdot \left({t}^{3} + -1\right) \]

8. Simplified 99.1%

   \[\leadsto \frac{1.7 \cdot 10^{+308}}{\color{blue}{\left(t + 1\right) + t \cdot t}} \cdot \left({t}^{3} + -1\right) \]
9. Step-by-step derivation

   1. unpow3 99.2%

      \[\leadsto \frac{1.7 \cdot 10^{+308}}{\left(t + 1\right) + t \cdot t} \cdot \left(\color{blue}{\left(t \cdot t\right) \cdot t} + -1\right) \]

10. Applied egg-rr 99.2%

    \[\leadsto \frac{1.7 \cdot 10^{+308}}{\left(t + 1\right) + t \cdot t} \cdot \left(\color{blue}{\left(t \cdot t\right) \cdot t} + -1\right) \]

11. Final simplification 99.2%

    \[\leadsto \frac{1.7 \cdot 10^{+308}}{\left(t + 1\right) + t \cdot t} \cdot \left(t \cdot \left(t \cdot t\right) + -1\right) \]

Alternative 3: 33.8% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ 1.7 \cdot 10^{+308} \cdot t \end{array} \]

FPCore

(FPCore (t) :precision binary64 (* 1.7e+308 t))

C

double code(double t) {
	return 1.7e+308 * t;
}

Fortran

real(8) function code(t)
    real(8), intent (in) :: t
    code = 1.7d+308 * t
end function

Java

public static double code(double t) {
	return 1.7e+308 * t;
}

Python

def code(t):
	return 1.7e+308 * t

Julia

function code(t)
	return Float64(1.7e+308 * t)
end

MATLAB

function tmp = code(t)
	tmp = 1.7e+308 * t;
end

Wolfram

code[t_] := N[(1.7e+308 * t), $MachinePrecision]

Derivation

1. Initial program 32.4%

   \[1.7 \cdot 10^{+308} \cdot t - 1.7 \cdot 10^{+308} \]

2. Taylor expanded in t around inf 32.4%

   \[\leadsto \color{blue}{1.7 \cdot 10^{+308} \cdot t} \]

3. Final simplification 32.4%

   \[\leadsto 1.7 \cdot 10^{+308} \cdot t \]

Alternative 4: 0.0% accurate, 5.0× speedup

Math

\[\begin{array}{l} \\ -1.7 \cdot 10^{+308} \end{array} \]

FPCore

(FPCore (t) :precision binary64 -1.7e+308)

C

double code(double t) {
	return -1.7e+308;
}

Fortran

real(8) function code(t)
    real(8), intent (in) :: t
    code = -1.7d+308
end function

Java

public static double code(double t) {
	return -1.7e+308;
}

Python

def code(t):
	return -1.7e+308

Julia

function code(t)
	return -1.7e+308
end

MATLAB

function tmp = code(t)
	tmp = -1.7e+308;
end

Wolfram

code[t_] := -1.7e+308

Derivation

1. Initial program 32.4%

   \[1.7 \cdot 10^{+308} \cdot t - 1.7 \cdot 10^{+308} \]

2. Taylor expanded in t around 0 0.0%

   \[\leadsto \color{blue}{-1.7 \cdot 10^{+308}} \]

3. Final simplification 0.0%

   \[\leadsto -1.7 \cdot 10^{+308} \]

Developer target: 99.6% accurate, 0.0× speedup

Math

\[\begin{array}{l} \\ \mathsf{fma}\left(1.7 \cdot 10^{+308}, t, -1.7 \cdot 10^{+308}\right) \end{array} \]

FPCore

(FPCore (t) :precision binary64 (fma 1.7e+308 t (- 1.7e+308)))

C

double code(double t) {
	return fma(1.7e+308, t, -1.7e+308);
}

Julia

function code(t)
	return fma(1.7e+308, t, Float64(-1.7e+308))
end

Wolfram

code[t_] := N[(1.7e+308 * t + (-1.7e+308)), $MachinePrecision]

Reproduce

herbie shell --seed 2023230 
(FPCore (t)
  :name "fma_test2"
  :precision binary64
  :pre (and (<= 1.9 t) (<= t 2.1))

  :herbie-target
  (fma 1.7e+308 t (- 1.7e+308))

  (- (* 1.7e+308 t) 1.7e+308))