Hyperbolic arc-(co)tangent

Percentage Accurate: 8.5% → 100.0%

Time: 19.3s

Alternatives: 8

Speedup: 111.0×

Specification

Math

\[\begin{array}{l} \\ \frac{1}{2} \cdot \log \left(\frac{1 + x}{1 - x}\right) \end{array} \]

FPCore

(FPCore (x) :precision binary64 (* (/ 1.0 2.0) (log (/ (+ 1.0 x) (- 1.0 x)))))

C

double code(double x) {
	return (1.0 / 2.0) * log(((1.0 + x) / (1.0 - x)));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = (1.0d0 / 2.0d0) * log(((1.0d0 + x) / (1.0d0 - x)))
end function

Java

public static double code(double x) {
	return (1.0 / 2.0) * Math.log(((1.0 + x) / (1.0 - x)));
}

Python

def code(x):
	return (1.0 / 2.0) * math.log(((1.0 + x) / (1.0 - x)))

Julia

function code(x)
	return Float64(Float64(1.0 / 2.0) * log(Float64(Float64(1.0 + x) / Float64(1.0 - x))))
end

MATLAB

function tmp = code(x)
	tmp = (1.0 / 2.0) * log(((1.0 + x) / (1.0 - x)));
end

Wolfram

code[x_] := N[(N[(1.0 / 2.0), $MachinePrecision] * N[Log[N[(N[(1.0 + x), $MachinePrecision] / N[(1.0 - x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Initial Program: 8.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{1}{2} \cdot \log \left(\frac{1 + x}{1 - x}\right) \end{array} \]

FPCore

(FPCore (x) :precision binary64 (* (/ 1.0 2.0) (log (/ (+ 1.0 x) (- 1.0 x)))))

C

double code(double x) {
	return (1.0 / 2.0) * log(((1.0 + x) / (1.0 - x)));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = (1.0d0 / 2.0d0) * log(((1.0d0 + x) / (1.0d0 - x)))
end function

Java

public static double code(double x) {
	return (1.0 / 2.0) * Math.log(((1.0 + x) / (1.0 - x)));
}

Python

def code(x):
	return (1.0 / 2.0) * math.log(((1.0 + x) / (1.0 - x)))

Julia

function code(x)
	return Float64(Float64(1.0 / 2.0) * log(Float64(Float64(1.0 + x) / Float64(1.0 - x))))
end

MATLAB

function tmp = code(x)
	tmp = (1.0 / 2.0) * log(((1.0 + x) / (1.0 - x)));
end

Wolfram

code[x_] := N[(N[(1.0 / 2.0), $MachinePrecision] * N[Log[N[(N[(1.0 + x), $MachinePrecision] / N[(1.0 - x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Alternative 1: 100.0% accurate, 0.5× speedup

Math

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

FPCore

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

C

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

Java

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

Python

def code(x):
	return 0.5 * ((2.0 * math.log1p(x)) - math.log1p(-(x * x)))

Julia

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

Wolfram

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

Derivation

1. Initial program 7.6%

   \[\frac{1}{2} \cdot \log \left(\frac{1 + x}{1 - x}\right) \]

3. Simplified 0

   \[\leadsto expr\]
4. Add Preprocessing

6. Applied egg-rr 0

   \[\leadsto expr\]
7. Add Preprocessing

Alternative 2: 99.8% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := x \cdot \left(x \cdot \left(x \cdot x\right)\right)\\ t_1 := 0.1111111111111111 + x \cdot \left(x \cdot 0.13333333333333333\right)\\ \frac{\frac{1 - \left(t\_0 \cdot t\_0\right) \cdot \left(t\_1 \cdot t\_1\right)}{1 + x \cdot \left(x \cdot \left(\left(x \cdot x\right) \cdot t\_1\right)\right)} \cdot x}{1 - x \cdot \left(x \cdot \left(0.3333333333333333 + \left(x \cdot x\right) \cdot \left(0.2 + x \cdot \left(x \cdot 0.14285714285714285\right)\right)\right)\right)} \end{array} \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (let* ((t_0 (* x (* x (* x x))))
        (t_1 (+ 0.1111111111111111 (* x (* x 0.13333333333333333)))))
   (/
    (*
     (/
      (- 1.0 (* (* t_0 t_0) (* t_1 t_1)))
      (+ 1.0 (* x (* x (* (* x x) t_1)))))
     x)
    (-
     1.0
     (*
      x
      (*
       x
       (+
        0.3333333333333333
        (* (* x x) (+ 0.2 (* x (* x 0.14285714285714285)))))))))))

C

double code(double x) {
	double t_0 = x * (x * (x * x));
	double t_1 = 0.1111111111111111 + (x * (x * 0.13333333333333333));
	return (((1.0 - ((t_0 * t_0) * (t_1 * t_1))) / (1.0 + (x * (x * ((x * x) * t_1))))) * x) / (1.0 - (x * (x * (0.3333333333333333 + ((x * x) * (0.2 + (x * (x * 0.14285714285714285))))))));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    real(8) :: t_0
    real(8) :: t_1
    t_0 = x * (x * (x * x))
    t_1 = 0.1111111111111111d0 + (x * (x * 0.13333333333333333d0))
    code = (((1.0d0 - ((t_0 * t_0) * (t_1 * t_1))) / (1.0d0 + (x * (x * ((x * x) * t_1))))) * x) / (1.0d0 - (x * (x * (0.3333333333333333d0 + ((x * x) * (0.2d0 + (x * (x * 0.14285714285714285d0))))))))
end function

Java

public static double code(double x) {
	double t_0 = x * (x * (x * x));
	double t_1 = 0.1111111111111111 + (x * (x * 0.13333333333333333));
	return (((1.0 - ((t_0 * t_0) * (t_1 * t_1))) / (1.0 + (x * (x * ((x * x) * t_1))))) * x) / (1.0 - (x * (x * (0.3333333333333333 + ((x * x) * (0.2 + (x * (x * 0.14285714285714285))))))));
}

Python

def code(x):
	t_0 = x * (x * (x * x))
	t_1 = 0.1111111111111111 + (x * (x * 0.13333333333333333))
	return (((1.0 - ((t_0 * t_0) * (t_1 * t_1))) / (1.0 + (x * (x * ((x * x) * t_1))))) * x) / (1.0 - (x * (x * (0.3333333333333333 + ((x * x) * (0.2 + (x * (x * 0.14285714285714285))))))))

Julia

function code(x)
	t_0 = Float64(x * Float64(x * Float64(x * x)))
	t_1 = Float64(0.1111111111111111 + Float64(x * Float64(x * 0.13333333333333333)))
	return Float64(Float64(Float64(Float64(1.0 - Float64(Float64(t_0 * t_0) * Float64(t_1 * t_1))) / Float64(1.0 + Float64(x * Float64(x * Float64(Float64(x * x) * t_1))))) * x) / Float64(1.0 - Float64(x * Float64(x * Float64(0.3333333333333333 + Float64(Float64(x * x) * Float64(0.2 + Float64(x * Float64(x * 0.14285714285714285)))))))))
end

MATLAB

function tmp = code(x)
	t_0 = x * (x * (x * x));
	t_1 = 0.1111111111111111 + (x * (x * 0.13333333333333333));
	tmp = (((1.0 - ((t_0 * t_0) * (t_1 * t_1))) / (1.0 + (x * (x * ((x * x) * t_1))))) * x) / (1.0 - (x * (x * (0.3333333333333333 + ((x * x) * (0.2 + (x * (x * 0.14285714285714285))))))));
end

Wolfram

code[x_] := Block[{t$95$0 = N[(x * N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(0.1111111111111111 + N[(x * N[(x * 0.13333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(N[(1.0 - N[(N[(t$95$0 * t$95$0), $MachinePrecision] * N[(t$95$1 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[(x * N[(x * N[(N[(x * x), $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision] / N[(1.0 - N[(x * N[(x * N[(0.3333333333333333 + N[(N[(x * x), $MachinePrecision] * N[(0.2 + N[(x * N[(x * 0.14285714285714285), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Initial program 7.6%

   \[\frac{1}{2} \cdot \log \left(\frac{1 + x}{1 - 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 0 0

    \[\leadsto expr\]

12. Simplified 0

    \[\leadsto expr\]

14. Applied egg-rr 0

    \[\leadsto expr\]
15. Add Preprocessing

Alternative 3: 99.8% accurate, 2.8× speedup

Math

\[\begin{array}{l} \\ \frac{x}{1 - x \cdot \left(x \cdot \left(0.3333333333333333 + x \cdot \left(x \cdot \left(0.2 + x \cdot \left(x \cdot 0.14285714285714285\right)\right)\right)\right)\right)} \cdot \left(1 - x \cdot \left(x \cdot \left(\left(x \cdot x\right) \cdot \left(0.1111111111111111 + x \cdot \left(x \cdot 0.13333333333333333\right)\right)\right)\right)\right) \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (*
  (/
   x
   (-
    1.0
    (*
     x
     (*
      x
      (+
       0.3333333333333333
       (* x (* x (+ 0.2 (* x (* x 0.14285714285714285))))))))))
  (-
   1.0
   (*
    x
    (*
     x
     (* (* x x) (+ 0.1111111111111111 (* x (* x 0.13333333333333333)))))))))

C

double code(double x) {
	return (x / (1.0 - (x * (x * (0.3333333333333333 + (x * (x * (0.2 + (x * (x * 0.14285714285714285)))))))))) * (1.0 - (x * (x * ((x * x) * (0.1111111111111111 + (x * (x * 0.13333333333333333)))))));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = (x / (1.0d0 - (x * (x * (0.3333333333333333d0 + (x * (x * (0.2d0 + (x * (x * 0.14285714285714285d0)))))))))) * (1.0d0 - (x * (x * ((x * x) * (0.1111111111111111d0 + (x * (x * 0.13333333333333333d0)))))))
end function

Java

public static double code(double x) {
	return (x / (1.0 - (x * (x * (0.3333333333333333 + (x * (x * (0.2 + (x * (x * 0.14285714285714285)))))))))) * (1.0 - (x * (x * ((x * x) * (0.1111111111111111 + (x * (x * 0.13333333333333333)))))));
}

Python

def code(x):
	return (x / (1.0 - (x * (x * (0.3333333333333333 + (x * (x * (0.2 + (x * (x * 0.14285714285714285)))))))))) * (1.0 - (x * (x * ((x * x) * (0.1111111111111111 + (x * (x * 0.13333333333333333)))))))

Julia

function code(x)
	return Float64(Float64(x / Float64(1.0 - Float64(x * Float64(x * Float64(0.3333333333333333 + Float64(x * Float64(x * Float64(0.2 + Float64(x * Float64(x * 0.14285714285714285)))))))))) * Float64(1.0 - Float64(x * Float64(x * Float64(Float64(x * x) * Float64(0.1111111111111111 + Float64(x * Float64(x * 0.13333333333333333))))))))
end

MATLAB

function tmp = code(x)
	tmp = (x / (1.0 - (x * (x * (0.3333333333333333 + (x * (x * (0.2 + (x * (x * 0.14285714285714285)))))))))) * (1.0 - (x * (x * ((x * x) * (0.1111111111111111 + (x * (x * 0.13333333333333333)))))));
end

Wolfram

code[x_] := N[(N[(x / N[(1.0 - N[(x * N[(x * N[(0.3333333333333333 + N[(x * N[(x * N[(0.2 + N[(x * N[(x * 0.14285714285714285), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(1.0 - N[(x * N[(x * N[(N[(x * x), $MachinePrecision] * N[(0.1111111111111111 + N[(x * N[(x * 0.13333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 7.6%

   \[\frac{1}{2} \cdot \log \left(\frac{1 + x}{1 - 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 0 0

    \[\leadsto expr\]

12. Simplified 0

    \[\leadsto expr\]

14. Applied egg-rr 0

    \[\leadsto expr\]
15. Add Preprocessing

Alternative 4: 99.7% accurate, 5.3× speedup

Math

\[\begin{array}{l} \\ x \cdot \left(1 + x \cdot \left(x \cdot \left(0.3333333333333333 + \left(x \cdot x\right) \cdot \left(0.2 + \left(x \cdot x\right) \cdot 0.14285714285714285\right)\right)\right)\right) \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (*
  x
  (+
   1.0
   (*
    x
    (*
     x
     (+
      0.3333333333333333
      (* (* x x) (+ 0.2 (* (* x x) 0.14285714285714285)))))))))

C

double code(double x) {
	return x * (1.0 + (x * (x * (0.3333333333333333 + ((x * x) * (0.2 + ((x * x) * 0.14285714285714285)))))));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = x * (1.0d0 + (x * (x * (0.3333333333333333d0 + ((x * x) * (0.2d0 + ((x * x) * 0.14285714285714285d0)))))))
end function

Java

public static double code(double x) {
	return x * (1.0 + (x * (x * (0.3333333333333333 + ((x * x) * (0.2 + ((x * x) * 0.14285714285714285)))))));
}

Python

def code(x):
	return x * (1.0 + (x * (x * (0.3333333333333333 + ((x * x) * (0.2 + ((x * x) * 0.14285714285714285)))))))

Julia

function code(x)
	return Float64(x * Float64(1.0 + Float64(x * Float64(x * Float64(0.3333333333333333 + Float64(Float64(x * x) * Float64(0.2 + Float64(Float64(x * x) * 0.14285714285714285))))))))
end

MATLAB

function tmp = code(x)
	tmp = x * (1.0 + (x * (x * (0.3333333333333333 + ((x * x) * (0.2 + ((x * x) * 0.14285714285714285)))))));
end

Wolfram

code[x_] := N[(x * N[(1.0 + N[(x * N[(x * N[(0.3333333333333333 + N[(N[(x * x), $MachinePrecision] * N[(0.2 + N[(N[(x * x), $MachinePrecision] * 0.14285714285714285), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 7.6%

   \[\frac{1}{2} \cdot \log \left(\frac{1 + x}{1 - 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. Add Preprocessing

Alternative 5: 99.6% accurate, 7.4× speedup

Math

\[\begin{array}{l} \\ x \cdot \left(1 + \left(x \cdot x\right) \cdot \left(0.3333333333333333 + \left(x \cdot x\right) \cdot 0.2\right)\right) \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (* x (+ 1.0 (* (* x x) (+ 0.3333333333333333 (* (* x x) 0.2))))))

C

double code(double x) {
	return x * (1.0 + ((x * x) * (0.3333333333333333 + ((x * x) * 0.2))));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = x * (1.0d0 + ((x * x) * (0.3333333333333333d0 + ((x * x) * 0.2d0))))
end function

Java

public static double code(double x) {
	return x * (1.0 + ((x * x) * (0.3333333333333333 + ((x * x) * 0.2))));
}

Python

def code(x):
	return x * (1.0 + ((x * x) * (0.3333333333333333 + ((x * x) * 0.2))))

Julia

function code(x)
	return Float64(x * Float64(1.0 + Float64(Float64(x * x) * Float64(0.3333333333333333 + Float64(Float64(x * x) * 0.2)))))
end

MATLAB

function tmp = code(x)
	tmp = x * (1.0 + ((x * x) * (0.3333333333333333 + ((x * x) * 0.2))));
end

Wolfram

code[x_] := N[(x * N[(1.0 + N[(N[(x * x), $MachinePrecision] * N[(0.3333333333333333 + N[(N[(x * x), $MachinePrecision] * 0.2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 7.6%

   \[\frac{1}{2} \cdot \log \left(\frac{1 + x}{1 - 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. Add Preprocessing

Alternative 6: 99.5% accurate, 12.3× speedup

Math

\[\begin{array}{l} \\ \left(x \cdot x\right) \cdot \left(x \cdot 0.3333333333333333\right) + x \end{array} \]

FPCore

(FPCore (x) :precision binary64 (+ (* (* x x) (* x 0.3333333333333333)) x))

C

double code(double x) {
	return ((x * x) * (x * 0.3333333333333333)) + x;
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = ((x * x) * (x * 0.3333333333333333d0)) + x
end function

Java

public static double code(double x) {
	return ((x * x) * (x * 0.3333333333333333)) + x;
}

Python

def code(x):
	return ((x * x) * (x * 0.3333333333333333)) + x

Julia

function code(x)
	return Float64(Float64(Float64(x * x) * Float64(x * 0.3333333333333333)) + x)
end

MATLAB

function tmp = code(x)
	tmp = ((x * x) * (x * 0.3333333333333333)) + x;
end

Wolfram

code[x_] := N[(N[(N[(x * x), $MachinePrecision] * N[(x * 0.3333333333333333), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision]

Derivation

1. Initial program 7.6%

   \[\frac{1}{2} \cdot \log \left(\frac{1 + x}{1 - 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. Add Preprocessing

Alternative 7: 99.5% accurate, 12.3× speedup

Math

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

FPCore

(FPCore (x) :precision binary64 (* x (+ 1.0 (* x (* x 0.3333333333333333)))))

C

double code(double x) {
	return x * (1.0 + (x * (x * 0.3333333333333333)));
}

Fortran

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

Java

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

Python

def code(x):
	return x * (1.0 + (x * (x * 0.3333333333333333)))

Julia

function code(x)
	return Float64(x * Float64(1.0 + Float64(x * Float64(x * 0.3333333333333333))))
end

MATLAB

function tmp = code(x)
	tmp = x * (1.0 + (x * (x * 0.3333333333333333)));
end

Wolfram

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

Derivation

1. Initial program 7.6%

   \[\frac{1}{2} \cdot \log \left(\frac{1 + x}{1 - 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. Add Preprocessing

Alternative 8: 99.0% accurate, 111.0× speedup

Math

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

FPCore

(FPCore (x) :precision binary64 x)

C

double code(double x) {
	return x;
}

Fortran

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

Java

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

Python

def code(x):
	return x

Julia

function code(x)
	return x
end

MATLAB

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

Wolfram

code[x_] := x

Derivation

1. Initial program 7.6%

   \[\frac{1}{2} \cdot \log \left(\frac{1 + x}{1 - 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. Add Preprocessing

Reproduce

herbie shell --seed 2024110 
(FPCore (x)
  :name "Hyperbolic arc-(co)tangent"
  :precision binary64
  (* (/ 1.0 2.0) (log (/ (+ 1.0 x) (- 1.0 x)))))