exact-inv-cosh-arg

Percentage Accurate: 100.0% → 100.0%

Time: 1.7min

Alternatives: 6

Speedup: 2.3×

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

• could not determine a ground truth

  1. Ce = -382630830.6065868

Specification

Math

\[\begin{array}{l} t_0 := e^{2 \cdot Ce}\\ 0.5 \cdot t\_0 + \frac{0.5}{t\_0} \end{array} \]

FPCore

(FPCore (Ce)
  :precision binary64
  :pre TRUE
  (let* ((t_0 (exp (* 2.0 Ce)))) (+ (* 0.5 t_0) (/ 0.5 t_0))))

C

double code(double Ce) {
	double t_0 = exp((2.0 * Ce));
	return (0.5 * t_0) + (0.5 / t_0);
}

Fortran

real(8) function code(ce)
use fmin_fmax_functions
    real(8), intent (in) :: ce
    real(8) :: t_0
    t_0 = exp((2.0d0 * ce))
    code = (0.5d0 * t_0) + (0.5d0 / t_0)
end function

Java

public static double code(double Ce) {
	double t_0 = Math.exp((2.0 * Ce));
	return (0.5 * t_0) + (0.5 / t_0);
}

Python

def code(Ce):
	t_0 = math.exp((2.0 * Ce))
	return (0.5 * t_0) + (0.5 / t_0)

Julia

function code(Ce)
	t_0 = exp(Float64(2.0 * Ce))
	return Float64(Float64(0.5 * t_0) + Float64(0.5 / t_0))
end

MATLAB

function tmp = code(Ce)
	t_0 = exp((2.0 * Ce));
	tmp = (0.5 * t_0) + (0.5 / t_0);
end

Wolfram

code[Ce_] := Block[{t$95$0 = N[Exp[N[(2.0 * Ce), $MachinePrecision]], $MachinePrecision]}, N[(N[(0.5 * t$95$0), $MachinePrecision] + N[(0.5 / t$95$0), $MachinePrecision]), $MachinePrecision]]

ReFlow

f(Ce):
	Ce in [-inf, +inf]
code: THEORY
BEGIN
f(Ce: real): real =
	LET t_0 = (exp(((2) * Ce))) IN
	((5e-1) * t_0) + ((5e-1) / t_0)
END code

Initial Program: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} t_0 := e^{2 \cdot Ce}\\ 0.5 \cdot t\_0 + \frac{0.5}{t\_0} \end{array} \]

FPCore

(FPCore (Ce)
  :precision binary64
  :pre TRUE
  (let* ((t_0 (exp (* 2.0 Ce)))) (+ (* 0.5 t_0) (/ 0.5 t_0))))

C

double code(double Ce) {
	double t_0 = exp((2.0 * Ce));
	return (0.5 * t_0) + (0.5 / t_0);
}

Fortran

real(8) function code(ce)
use fmin_fmax_functions
    real(8), intent (in) :: ce
    real(8) :: t_0
    t_0 = exp((2.0d0 * ce))
    code = (0.5d0 * t_0) + (0.5d0 / t_0)
end function

Java

public static double code(double Ce) {
	double t_0 = Math.exp((2.0 * Ce));
	return (0.5 * t_0) + (0.5 / t_0);
}

Python

def code(Ce):
	t_0 = math.exp((2.0 * Ce))
	return (0.5 * t_0) + (0.5 / t_0)

Julia

function code(Ce)
	t_0 = exp(Float64(2.0 * Ce))
	return Float64(Float64(0.5 * t_0) + Float64(0.5 / t_0))
end

MATLAB

function tmp = code(Ce)
	t_0 = exp((2.0 * Ce));
	tmp = (0.5 * t_0) + (0.5 / t_0);
end

Wolfram

code[Ce_] := Block[{t$95$0 = N[Exp[N[(2.0 * Ce), $MachinePrecision]], $MachinePrecision]}, N[(N[(0.5 * t$95$0), $MachinePrecision] + N[(0.5 / t$95$0), $MachinePrecision]), $MachinePrecision]]

ReFlow

f(Ce):
	Ce in [-inf, +inf]
code: THEORY
BEGIN
f(Ce: real): real =
	LET t_0 = (exp(((2) * Ce))) IN
	((5e-1) * t_0) + ((5e-1) / t_0)
END code

Alternative 1: 100.0% accurate, 2.3× speedup

Math

\[\cosh \left(Ce + Ce\right) \]

FPCore

(FPCore (Ce)
  :precision binary64
  :pre TRUE
  (cosh (+ Ce Ce)))

C

double code(double Ce) {
	return cosh((Ce + Ce));
}

Fortran

real(8) function code(ce)
use fmin_fmax_functions
    real(8), intent (in) :: ce
    code = cosh((ce + ce))
end function

Java

public static double code(double Ce) {
	return Math.cosh((Ce + Ce));
}

Python

def code(Ce):
	return math.cosh((Ce + Ce))

Julia

function code(Ce)
	return cosh(Float64(Ce + Ce))
end

MATLAB

function tmp = code(Ce)
	tmp = cosh((Ce + Ce));
end

Wolfram

code[Ce_] := N[Cosh[N[(Ce + Ce), $MachinePrecision]], $MachinePrecision]

ReFlow

f(Ce):
	Ce in [-inf, +inf]
code: THEORY
BEGIN
f(Ce: real): real =
	((1) / (2)) * ((exp((Ce + Ce))) + ((1) / (exp((Ce + Ce)))))
END code

Derivation

1. Initial program 100.0%

   \[0.5 \cdot e^{2 \cdot Ce} + \frac{0.5}{e^{2 \cdot Ce}} \]

3. Applied rewrites 100.0%

   \[\leadsto \cosh \left(Ce + Ce\right) \]
4. Add Preprocessing

Alternative 2: 82.7% accurate, 2.3× speedup

Math

\[\mathsf{fma}\left(\left|Ce\right| - -1, \left|Ce\right|, 0.5\right) + \frac{0.5}{1} \]

FPCore

(FPCore (Ce)
  :precision binary64
  :pre TRUE
  (+ (fma (- (fabs Ce) -1.0) (fabs Ce) 0.5) (/ 0.5 1.0)))

C

double code(double Ce) {
	return fma((fabs(Ce) - -1.0), fabs(Ce), 0.5) + (0.5 / 1.0);
}

Julia

function code(Ce)
	return Float64(fma(Float64(abs(Ce) - -1.0), abs(Ce), 0.5) + Float64(0.5 / 1.0))
end

Wolfram

code[Ce_] := N[(N[(N[(N[Abs[Ce], $MachinePrecision] - -1.0), $MachinePrecision] * N[Abs[Ce], $MachinePrecision] + 0.5), $MachinePrecision] + N[(0.5 / 1.0), $MachinePrecision]), $MachinePrecision]

ReFlow

f(Ce):
	Ce in [-inf, +inf]
code: THEORY
BEGIN
f(Ce: real): real =
	((((abs(Ce)) - (-1)) * (abs(Ce))) + (5e-1)) + ((5e-1) / (1))
END code

Derivation

1. Initial program 100.0%

   \[0.5 \cdot e^{2 \cdot Ce} + \frac{0.5}{e^{2 \cdot Ce}} \]

2. Taylor expanded in Ce around 0

   \[\leadsto 0.5 \cdot 1 + \frac{0.5}{1} \]

4. Applied rewrites 67.1%

   \[\leadsto 0.5 \cdot 1 + \frac{0.5}{1} \]

5. Taylor expanded in Ce around 0

   \[\leadsto \left(\frac{1}{2} + Ce \cdot \left(1 + Ce\right)\right) + \frac{0.5}{1} \]

7. Applied rewrites 82.7%

   \[\leadsto \left(0.5 + Ce \cdot \left(1 + Ce\right)\right) + \frac{0.5}{1} \]

9. Applied rewrites 82.7%

   \[\leadsto \mathsf{fma}\left(Ce - -1, Ce, 0.5\right) + \frac{0.5}{1} \]
10. Add Preprocessing

Alternative 3: 82.7% accurate, 2.7× speedup

Math

\[0.5 \cdot 1 + \mathsf{fma}\left(Ce - 1, Ce, 0.5\right) \]

FPCore

(FPCore (Ce)
  :precision binary64
  :pre TRUE
  (+ (* 0.5 1.0) (fma (- Ce 1.0) Ce 0.5)))

C

double code(double Ce) {
	return (0.5 * 1.0) + fma((Ce - 1.0), Ce, 0.5);
}

Julia

function code(Ce)
	return Float64(Float64(0.5 * 1.0) + fma(Float64(Ce - 1.0), Ce, 0.5))
end

Wolfram

code[Ce_] := N[(N[(0.5 * 1.0), $MachinePrecision] + N[(N[(Ce - 1.0), $MachinePrecision] * Ce + 0.5), $MachinePrecision]), $MachinePrecision]

ReFlow

f(Ce):
	Ce in [-inf, +inf]
code: THEORY
BEGIN
f(Ce: real): real =
	((5e-1) * (1)) + (((Ce - (1)) * Ce) + (5e-1))
END code

Derivation

1. Initial program 100.0%

   \[0.5 \cdot e^{2 \cdot Ce} + \frac{0.5}{e^{2 \cdot Ce}} \]

2. Taylor expanded in Ce around 0

   \[\leadsto 0.5 \cdot 1 + \frac{0.5}{1} \]

4. Applied rewrites 67.1%

   \[\leadsto 0.5 \cdot 1 + \frac{0.5}{1} \]

5. Taylor expanded in Ce around 0

   \[\leadsto 0.5 \cdot 1 + \left(\frac{1}{2} + Ce \cdot \left(Ce - 1\right)\right) \]

7. Applied rewrites 82.7%

   \[\leadsto 0.5 \cdot 1 + \left(0.5 + Ce \cdot \left(Ce - 1\right)\right) \]

9. Applied rewrites 82.7%

   \[\leadsto 0.5 \cdot 1 + \mathsf{fma}\left(Ce - 1, Ce, 0.5\right) \]
10. Add Preprocessing

Alternative 4: 82.7% accurate, 2.7× speedup

Math

\[0.5 \cdot 1 + \left(\mathsf{fma}\left(Ce, Ce, 0.5\right) - Ce\right) \]

FPCore

(FPCore (Ce)
  :precision binary64
  :pre TRUE
  (+ (* 0.5 1.0) (- (fma Ce Ce 0.5) Ce)))

C

double code(double Ce) {
	return (0.5 * 1.0) + (fma(Ce, Ce, 0.5) - Ce);
}

Julia

function code(Ce)
	return Float64(Float64(0.5 * 1.0) + Float64(fma(Ce, Ce, 0.5) - Ce))
end

Wolfram

code[Ce_] := N[(N[(0.5 * 1.0), $MachinePrecision] + N[(N[(Ce * Ce + 0.5), $MachinePrecision] - Ce), $MachinePrecision]), $MachinePrecision]

ReFlow

f(Ce):
	Ce in [-inf, +inf]
code: THEORY
BEGIN
f(Ce: real): real =
	((5e-1) * (1)) + (((Ce * Ce) + (5e-1)) - Ce)
END code

Derivation

1. Initial program 100.0%

   \[0.5 \cdot e^{2 \cdot Ce} + \frac{0.5}{e^{2 \cdot Ce}} \]

2. Taylor expanded in Ce around 0

   \[\leadsto 0.5 \cdot 1 + \frac{0.5}{1} \]

4. Applied rewrites 67.1%

   \[\leadsto 0.5 \cdot 1 + \frac{0.5}{1} \]

5. Taylor expanded in Ce around 0

   \[\leadsto 0.5 \cdot 1 + \left(\frac{1}{2} + Ce \cdot \left(Ce - 1\right)\right) \]

7. Applied rewrites 82.7%

   \[\leadsto 0.5 \cdot 1 + \left(0.5 + Ce \cdot \left(Ce - 1\right)\right) \]

9. Applied rewrites 82.7%

   \[\leadsto 0.5 \cdot 1 + \left(\mathsf{fma}\left(Ce, Ce, 0.5\right) - Ce\right) \]
10. Add Preprocessing

Alternative 5: 67.1% accurate, 3.5× speedup

Math

\[\left(0.5 + \left|Ce\right|\right) + \frac{0.5}{1} \]

FPCore

(FPCore (Ce)
  :precision binary64
  :pre TRUE
  (+ (+ 0.5 (fabs Ce)) (/ 0.5 1.0)))

C

double code(double Ce) {
	return (0.5 + fabs(Ce)) + (0.5 / 1.0);
}

Fortran

real(8) function code(ce)
use fmin_fmax_functions
    real(8), intent (in) :: ce
    code = (0.5d0 + abs(ce)) + (0.5d0 / 1.0d0)
end function

Java

public static double code(double Ce) {
	return (0.5 + Math.abs(Ce)) + (0.5 / 1.0);
}

Python

def code(Ce):
	return (0.5 + math.fabs(Ce)) + (0.5 / 1.0)

Julia

function code(Ce)
	return Float64(Float64(0.5 + abs(Ce)) + Float64(0.5 / 1.0))
end

MATLAB

function tmp = code(Ce)
	tmp = (0.5 + abs(Ce)) + (0.5 / 1.0);
end

Wolfram

code[Ce_] := N[(N[(0.5 + N[Abs[Ce], $MachinePrecision]), $MachinePrecision] + N[(0.5 / 1.0), $MachinePrecision]), $MachinePrecision]

ReFlow

f(Ce):
	Ce in [-inf, +inf]
code: THEORY
BEGIN
f(Ce: real): real =
	((5e-1) + (abs(Ce))) + ((5e-1) / (1))
END code

Derivation

1. Initial program 100.0%

   \[0.5 \cdot e^{2 \cdot Ce} + \frac{0.5}{e^{2 \cdot Ce}} \]

2. Taylor expanded in Ce around 0

   \[\leadsto 0.5 \cdot 1 + \frac{0.5}{1} \]

4. Applied rewrites 67.1%

   \[\leadsto 0.5 \cdot 1 + \frac{0.5}{1} \]

5. Taylor expanded in Ce around 0

   \[\leadsto \left(\frac{1}{2} + Ce\right) + \frac{0.5}{1} \]

7. Applied rewrites 67.0%

   \[\leadsto \left(0.5 + Ce\right) + \frac{0.5}{1} \]
8. Add Preprocessing

Alternative 6: 67.1% accurate, 5.2× speedup

Math

\[0.5 + \frac{0.5}{1} \]

FPCore

(FPCore (Ce)
  :precision binary64
  :pre TRUE
  (+ 0.5 (/ 0.5 1.0)))

C

double code(double Ce) {
	return 0.5 + (0.5 / 1.0);
}

Fortran

real(8) function code(ce)
use fmin_fmax_functions
    real(8), intent (in) :: ce
    code = 0.5d0 + (0.5d0 / 1.0d0)
end function

Java

public static double code(double Ce) {
	return 0.5 + (0.5 / 1.0);
}

Python

def code(Ce):
	return 0.5 + (0.5 / 1.0)

Julia

function code(Ce)
	return Float64(0.5 + Float64(0.5 / 1.0))
end

MATLAB

function tmp = code(Ce)
	tmp = 0.5 + (0.5 / 1.0);
end

Wolfram

code[Ce_] := N[(0.5 + N[(0.5 / 1.0), $MachinePrecision]), $MachinePrecision]

ReFlow

f(Ce):
	Ce in [-inf, +inf]
code: THEORY
BEGIN
f(Ce: real): real =
	(5e-1) + ((5e-1) / (1))
END code

Derivation

1. Initial program 100.0%

   \[0.5 \cdot e^{2 \cdot Ce} + \frac{0.5}{e^{2 \cdot Ce}} \]

2. Taylor expanded in Ce around 0

   \[\leadsto 0.5 \cdot 1 + \frac{0.5}{1} \]

4. Applied rewrites 67.1%

   \[\leadsto 0.5 \cdot 1 + \frac{0.5}{1} \]

5. Taylor expanded in Ce around 0

   \[\leadsto \frac{1}{2} + \frac{0.5}{1} \]

7. Applied rewrites 67.1%

   \[\leadsto 0.5 + \frac{0.5}{1} \]
8. Add Preprocessing

Reproduce

herbie shell --seed 2026050 +o generate:egglog
(FPCore (Ce)
  :name "exact-inv-cosh-arg"
  :precision binary64
  (+ (* 0.5 (exp (* 2.0 Ce))) (/ 0.5 (exp (* 2.0 Ce)))))