exact-inv-exp2Ce

Percentage Accurate: 100.0% → 100.0%

Time: 1.6min

Alternatives: 7

Speedup: 1.0×

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

Specification

Math

\[e^{2 \cdot Ce} \]

FPCore

(FPCore (Ce)
  :precision binary64
  :pre TRUE
  (exp (* 2.0 Ce)))

C

double code(double Ce) {
	return exp((2.0 * Ce));
}

Fortran

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

Java

public static double code(double Ce) {
	return Math.exp((2.0 * Ce));
}

Python

def code(Ce):
	return math.exp((2.0 * Ce))

Julia

function code(Ce)
	return exp(Float64(2.0 * Ce))
end

MATLAB

function tmp = code(Ce)
	tmp = exp((2.0 * Ce));
end

Wolfram

code[Ce_] := N[Exp[N[(2.0 * Ce), $MachinePrecision]], $MachinePrecision]

ReFlow

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

\[e^{2 \cdot Ce} \]

FPCore

(FPCore (Ce)
  :precision binary64
  :pre TRUE
  (exp (* 2.0 Ce)))

C

double code(double Ce) {
	return exp((2.0 * Ce));
}

Fortran

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

Java

public static double code(double Ce) {
	return Math.exp((2.0 * Ce));
}

Python

def code(Ce):
	return math.exp((2.0 * Ce))

Julia

function code(Ce)
	return exp(Float64(2.0 * Ce))
end

MATLAB

function tmp = code(Ce)
	tmp = exp((2.0 * Ce));
end

Wolfram

code[Ce_] := N[Exp[N[(2.0 * Ce), $MachinePrecision]], $MachinePrecision]

ReFlow

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

Alternative 1: 100.0% accurate, 1.0× speedup

Math

\[e^{Ce + Ce} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

ReFlow

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

Derivation

1. Initial program 100.0%

   \[e^{2 \cdot Ce} \]

3. Applied rewrites 100.0%

   \[\leadsto e^{Ce + Ce} \]
4. Add Preprocessing

Alternative 2: 87.5% accurate, 0.8× speedup

Math

\[\begin{array}{l} \mathbf{if}\;2 \cdot Ce \leq -2000000:\\ \;\;\;\;0\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(Ce, Ce, Ce\right), 2, 1\right)\\ \end{array} \]

FPCore

(FPCore (Ce)
  :precision binary64
  :pre TRUE
  (if (<= (* 2.0 Ce) -2000000.0) 0.0 (fma (fma Ce Ce Ce) 2.0 1.0)))

C

double code(double Ce) {
	double tmp;
	if ((2.0 * Ce) <= -2000000.0) {
		tmp = 0.0;
	} else {
		tmp = fma(fma(Ce, Ce, Ce), 2.0, 1.0);
	}
	return tmp;
}

Julia

function code(Ce)
	tmp = 0.0
	if (Float64(2.0 * Ce) <= -2000000.0)
		tmp = 0.0;
	else
		tmp = fma(fma(Ce, Ce, Ce), 2.0, 1.0);
	end
	return tmp
end

Wolfram

code[Ce_] := If[LessEqual[N[(2.0 * Ce), $MachinePrecision], -2000000.0], 0.0, N[(N[(Ce * Ce + Ce), $MachinePrecision] * 2.0 + 1.0), $MachinePrecision]]

ReFlow

f(Ce):
	Ce in [-inf, +inf]
code: THEORY
BEGIN
f(Ce: real): real =
	LET tmp = IF (((2) * Ce) <= (-2e6)) THEN (0) ELSE ((((Ce * Ce) + Ce) * (2)) + (1)) ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if (*.f64 #s(literal 2 binary64) Ce) < -2e6

   1. Initial program 100.0%

      \[e^{2 \cdot Ce} \]

   2. Taylor expanded in Ce around 0

      \[\leadsto 1 + 2 \cdot Ce \]

   4. Applied rewrites 51.3%

      \[\leadsto 1 + 2 \cdot Ce \]

   6. Applied rewrites 51.3%

      \[\leadsto \mathsf{fma}\left(Ce, 2, 1\right) \]

   7. Taylor expanded in Ce around inf

      \[\leadsto 2 \cdot Ce \]

   9. Applied rewrites 3.8%

      \[\leadsto 2 \cdot Ce \]

   11. Applied rewrites 26.6%

       \[\leadsto 0 \]

   if -2e6 < (*.f64 #s(literal 2 binary64) Ce)

   1. Initial program 100.0%

      \[e^{2 \cdot Ce} \]

   2. Taylor expanded in Ce around 0

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

   4. Applied rewrites 63.6%

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

   6. Applied rewrites 63.6%

      \[\leadsto \mathsf{fma}\left(\mathsf{fma}\left(Ce, Ce, Ce\right), 2, 1\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 3: 87.5% accurate, 0.4× speedup

Math

\[\begin{array}{l} t_0 := e^{2 \cdot Ce}\\ \mathbf{if}\;t\_0 \leq 0.001:\\ \;\;\;\;0\\ \mathbf{elif}\;t\_0 \leq 2:\\ \;\;\;\;\mathsf{fma}\left(Ce, 2, 1\right)\\ \mathbf{else}:\\ \;\;\;\;Ce \cdot Ce\\ \end{array} \]

FPCore

(FPCore (Ce)
  :precision binary64
  :pre TRUE
  (let* ((t_0 (exp (* 2.0 Ce))))
  (if (<= t_0 0.001)
    0.0
    (if (<= t_0 2.0) (fma Ce 2.0 1.0) (* Ce Ce)))))

C

double code(double Ce) {
	double t_0 = exp((2.0 * Ce));
	double tmp;
	if (t_0 <= 0.001) {
		tmp = 0.0;
	} else if (t_0 <= 2.0) {
		tmp = fma(Ce, 2.0, 1.0);
	} else {
		tmp = Ce * Ce;
	}
	return tmp;
}

Julia

function code(Ce)
	t_0 = exp(Float64(2.0 * Ce))
	tmp = 0.0
	if (t_0 <= 0.001)
		tmp = 0.0;
	elseif (t_0 <= 2.0)
		tmp = fma(Ce, 2.0, 1.0);
	else
		tmp = Float64(Ce * Ce);
	end
	return tmp
end

Wolfram

code[Ce_] := Block[{t$95$0 = N[Exp[N[(2.0 * Ce), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$0, 0.001], 0.0, If[LessEqual[t$95$0, 2.0], N[(Ce * 2.0 + 1.0), $MachinePrecision], N[(Ce * Ce), $MachinePrecision]]]]

ReFlow

f(Ce):
	Ce in [-inf, +inf]
code: THEORY
BEGIN
f(Ce: real): real =
	LET t_0 = (exp(((2) * Ce))) IN
		LET tmp_1 = IF (t_0 <= (2)) THEN ((Ce * (2)) + (1)) ELSE (Ce * Ce) ENDIF IN
		LET tmp = IF (t_0 <= (1000000000000000020816681711721685132943093776702880859375e-60)) THEN (0) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if (exp.f64 (*.f64 #s(literal 2 binary64) Ce)) < 1e-3

   1. Initial program 100.0%

      \[e^{2 \cdot Ce} \]

   2. Taylor expanded in Ce around 0

      \[\leadsto 1 + 2 \cdot Ce \]

   4. Applied rewrites 51.3%

      \[\leadsto 1 + 2 \cdot Ce \]

   6. Applied rewrites 51.3%

      \[\leadsto \mathsf{fma}\left(Ce, 2, 1\right) \]

   7. Taylor expanded in Ce around inf

      \[\leadsto 2 \cdot Ce \]

   9. Applied rewrites 3.8%

      \[\leadsto 2 \cdot Ce \]

   11. Applied rewrites 26.6%

       \[\leadsto 0 \]

   if 1e-3 < (exp.f64 (*.f64 #s(literal 2 binary64) Ce)) < 2

   1. Initial program 100.0%

      \[e^{2 \cdot Ce} \]

   2. Taylor expanded in Ce around 0

      \[\leadsto 1 + 2 \cdot Ce \]

   4. Applied rewrites 51.3%

      \[\leadsto 1 + 2 \cdot Ce \]

   6. Applied rewrites 51.3%

      \[\leadsto \mathsf{fma}\left(Ce, 2, 1\right) \]

   if 2 < (exp.f64 (*.f64 #s(literal 2 binary64) Ce))

   1. Initial program 100.0%

      \[e^{2 \cdot Ce} \]

   2. Taylor expanded in Ce around 0

      \[\leadsto 1 + 2 \cdot Ce \]

   4. Applied rewrites 51.3%

      \[\leadsto 1 + 2 \cdot Ce \]

   6. Applied rewrites 51.3%

      \[\leadsto \mathsf{fma}\left(Ce, 2, 1\right) \]

   7. Taylor expanded in Ce around inf

      \[\leadsto 2 \cdot Ce \]

   9. Applied rewrites 3.8%

      \[\leadsto 2 \cdot Ce \]

   11. Applied rewrites 16.2%

       \[\leadsto Ce \cdot Ce \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 4: 87.1% accurate, 0.4× speedup

Math

\[\begin{array}{l} t_0 := e^{2 \cdot Ce}\\ \mathbf{if}\;t\_0 \leq 0:\\ \;\;\;\;0\\ \mathbf{elif}\;t\_0 \leq 2:\\ \;\;\;\;1\\ \mathbf{else}:\\ \;\;\;\;Ce \cdot Ce\\ \end{array} \]

FPCore

(FPCore (Ce)
  :precision binary64
  :pre TRUE
  (let* ((t_0 (exp (* 2.0 Ce))))
  (if (<= t_0 0.0) 0.0 (if (<= t_0 2.0) 1.0 (* Ce Ce)))))

C

double code(double Ce) {
	double t_0 = exp((2.0 * Ce));
	double tmp;
	if (t_0 <= 0.0) {
		tmp = 0.0;
	} else if (t_0 <= 2.0) {
		tmp = 1.0;
	} else {
		tmp = Ce * Ce;
	}
	return tmp;
}

Fortran

real(8) function code(ce)
use fmin_fmax_functions
    real(8), intent (in) :: ce
    real(8) :: t_0
    real(8) :: tmp
    t_0 = exp((2.0d0 * ce))
    if (t_0 <= 0.0d0) then
        tmp = 0.0d0
    else if (t_0 <= 2.0d0) then
        tmp = 1.0d0
    else
        tmp = ce * ce
    end if
    code = tmp
end function

Java

public static double code(double Ce) {
	double t_0 = Math.exp((2.0 * Ce));
	double tmp;
	if (t_0 <= 0.0) {
		tmp = 0.0;
	} else if (t_0 <= 2.0) {
		tmp = 1.0;
	} else {
		tmp = Ce * Ce;
	}
	return tmp;
}

Python

def code(Ce):
	t_0 = math.exp((2.0 * Ce))
	tmp = 0
	if t_0 <= 0.0:
		tmp = 0.0
	elif t_0 <= 2.0:
		tmp = 1.0
	else:
		tmp = Ce * Ce
	return tmp

Julia

function code(Ce)
	t_0 = exp(Float64(2.0 * Ce))
	tmp = 0.0
	if (t_0 <= 0.0)
		tmp = 0.0;
	elseif (t_0 <= 2.0)
		tmp = 1.0;
	else
		tmp = Float64(Ce * Ce);
	end
	return tmp
end

MATLAB

function tmp_2 = code(Ce)
	t_0 = exp((2.0 * Ce));
	tmp = 0.0;
	if (t_0 <= 0.0)
		tmp = 0.0;
	elseif (t_0 <= 2.0)
		tmp = 1.0;
	else
		tmp = Ce * Ce;
	end
	tmp_2 = tmp;
end

Wolfram

code[Ce_] := Block[{t$95$0 = N[Exp[N[(2.0 * Ce), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$0, 0.0], 0.0, If[LessEqual[t$95$0, 2.0], 1.0, N[(Ce * Ce), $MachinePrecision]]]]

ReFlow

f(Ce):
	Ce in [-inf, +inf]
code: THEORY
BEGIN
f(Ce: real): real =
	LET t_0 = (exp(((2) * Ce))) IN
		LET tmp_1 = IF (t_0 <= (2)) THEN (1) ELSE (Ce * Ce) ENDIF IN
		LET tmp = IF (t_0 <= (0)) THEN (0) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if (exp.f64 (*.f64 #s(literal 2 binary64) Ce)) < 0.0

   1. Initial program 100.0%

      \[e^{2 \cdot Ce} \]

   2. Taylor expanded in Ce around 0

      \[\leadsto 1 + 2 \cdot Ce \]

   4. Applied rewrites 51.3%

      \[\leadsto 1 + 2 \cdot Ce \]

   6. Applied rewrites 51.3%

      \[\leadsto \mathsf{fma}\left(Ce, 2, 1\right) \]

   7. Taylor expanded in Ce around inf

      \[\leadsto 2 \cdot Ce \]

   9. Applied rewrites 3.8%

      \[\leadsto 2 \cdot Ce \]

   11. Applied rewrites 26.6%

       \[\leadsto 0 \]

   if 0.0 < (exp.f64 (*.f64 #s(literal 2 binary64) Ce)) < 2

   1. Initial program 100.0%

      \[e^{2 \cdot Ce} \]

   2. Taylor expanded in Ce around 0

      \[\leadsto 1 \]

   4. Applied rewrites 50.4%

      \[\leadsto 1 \]

   if 2 < (exp.f64 (*.f64 #s(literal 2 binary64) Ce))

   1. Initial program 100.0%

      \[e^{2 \cdot Ce} \]

   2. Taylor expanded in Ce around 0

      \[\leadsto 1 + 2 \cdot Ce \]

   4. Applied rewrites 51.3%

      \[\leadsto 1 + 2 \cdot Ce \]

   6. Applied rewrites 51.3%

      \[\leadsto \mathsf{fma}\left(Ce, 2, 1\right) \]

   7. Taylor expanded in Ce around inf

      \[\leadsto 2 \cdot Ce \]

   9. Applied rewrites 3.8%

      \[\leadsto 2 \cdot Ce \]

   11. Applied rewrites 16.2%

       \[\leadsto Ce \cdot Ce \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 5: 74.9% accurate, 1.4× speedup

Math

\[\begin{array}{l} \mathbf{if}\;2 \cdot Ce \leq -5:\\ \;\;\;\;0\\ \mathbf{else}:\\ \;\;\;\;Ce - -1\\ \end{array} \]

FPCore

(FPCore (Ce)
  :precision binary64
  :pre TRUE
  (if (<= (* 2.0 Ce) -5.0) 0.0 (- Ce -1.0)))

C

double code(double Ce) {
	double tmp;
	if ((2.0 * Ce) <= -5.0) {
		tmp = 0.0;
	} else {
		tmp = Ce - -1.0;
	}
	return tmp;
}

Fortran

real(8) function code(ce)
use fmin_fmax_functions
    real(8), intent (in) :: ce
    real(8) :: tmp
    if ((2.0d0 * ce) <= (-5.0d0)) then
        tmp = 0.0d0
    else
        tmp = ce - (-1.0d0)
    end if
    code = tmp
end function

Java

public static double code(double Ce) {
	double tmp;
	if ((2.0 * Ce) <= -5.0) {
		tmp = 0.0;
	} else {
		tmp = Ce - -1.0;
	}
	return tmp;
}

Python

def code(Ce):
	tmp = 0
	if (2.0 * Ce) <= -5.0:
		tmp = 0.0
	else:
		tmp = Ce - -1.0
	return tmp

Julia

function code(Ce)
	tmp = 0.0
	if (Float64(2.0 * Ce) <= -5.0)
		tmp = 0.0;
	else
		tmp = Float64(Ce - -1.0);
	end
	return tmp
end

MATLAB

function tmp_2 = code(Ce)
	tmp = 0.0;
	if ((2.0 * Ce) <= -5.0)
		tmp = 0.0;
	else
		tmp = Ce - -1.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[Ce_] := If[LessEqual[N[(2.0 * Ce), $MachinePrecision], -5.0], 0.0, N[(Ce - -1.0), $MachinePrecision]]

ReFlow

f(Ce):
	Ce in [-inf, +inf]
code: THEORY
BEGIN
f(Ce: real): real =
	LET tmp = IF (((2) * Ce) <= (-5)) THEN (0) ELSE (Ce - (-1)) ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if (*.f64 #s(literal 2 binary64) Ce) < -5

   1. Initial program 100.0%

      \[e^{2 \cdot Ce} \]

   2. Taylor expanded in Ce around 0

      \[\leadsto 1 + 2 \cdot Ce \]

   4. Applied rewrites 51.3%

      \[\leadsto 1 + 2 \cdot Ce \]

   6. Applied rewrites 51.3%

      \[\leadsto \mathsf{fma}\left(Ce, 2, 1\right) \]

   7. Taylor expanded in Ce around inf

      \[\leadsto 2 \cdot Ce \]

   9. Applied rewrites 3.8%

      \[\leadsto 2 \cdot Ce \]

   11. Applied rewrites 26.6%

       \[\leadsto 0 \]

   if -5 < (*.f64 #s(literal 2 binary64) Ce)

   1. Initial program 100.0%

      \[e^{2 \cdot Ce} \]

   2. Taylor expanded in Ce around 0

      \[\leadsto 1 + 2 \cdot Ce \]

   4. Applied rewrites 51.3%

      \[\leadsto 1 + 2 \cdot Ce \]

   6. Applied rewrites 51.3%

      \[\leadsto Ce - \left(-1 - Ce\right) \]

   7. Taylor expanded in Ce around 0

      \[\leadsto Ce - -1 \]

   9. Applied rewrites 50.8%

      \[\leadsto Ce - -1 \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 6: 74.0% accurate, 1.9× speedup

Math

\[\begin{array}{l} \mathbf{if}\;2 \cdot Ce \leq -2000000:\\ \;\;\;\;0\\ \mathbf{else}:\\ \;\;\;\;1\\ \end{array} \]

FPCore

(FPCore (Ce)
  :precision binary64
  :pre TRUE
  (if (<= (* 2.0 Ce) -2000000.0) 0.0 1.0))

C

double code(double Ce) {
	double tmp;
	if ((2.0 * Ce) <= -2000000.0) {
		tmp = 0.0;
	} else {
		tmp = 1.0;
	}
	return tmp;
}

Fortran

real(8) function code(ce)
use fmin_fmax_functions
    real(8), intent (in) :: ce
    real(8) :: tmp
    if ((2.0d0 * ce) <= (-2000000.0d0)) then
        tmp = 0.0d0
    else
        tmp = 1.0d0
    end if
    code = tmp
end function

Java

public static double code(double Ce) {
	double tmp;
	if ((2.0 * Ce) <= -2000000.0) {
		tmp = 0.0;
	} else {
		tmp = 1.0;
	}
	return tmp;
}

Python

def code(Ce):
	tmp = 0
	if (2.0 * Ce) <= -2000000.0:
		tmp = 0.0
	else:
		tmp = 1.0
	return tmp

Julia

function code(Ce)
	tmp = 0.0
	if (Float64(2.0 * Ce) <= -2000000.0)
		tmp = 0.0;
	else
		tmp = 1.0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(Ce)
	tmp = 0.0;
	if ((2.0 * Ce) <= -2000000.0)
		tmp = 0.0;
	else
		tmp = 1.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[Ce_] := If[LessEqual[N[(2.0 * Ce), $MachinePrecision], -2000000.0], 0.0, 1.0]

ReFlow

f(Ce):
	Ce in [-inf, +inf]
code: THEORY
BEGIN
f(Ce: real): real =
	LET tmp = IF (((2) * Ce) <= (-2e6)) THEN (0) ELSE (1) ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if (*.f64 #s(literal 2 binary64) Ce) < -2e6

   1. Initial program 100.0%

      \[e^{2 \cdot Ce} \]

   2. Taylor expanded in Ce around 0

      \[\leadsto 1 + 2 \cdot Ce \]

   4. Applied rewrites 51.3%

      \[\leadsto 1 + 2 \cdot Ce \]

   6. Applied rewrites 51.3%

      \[\leadsto \mathsf{fma}\left(Ce, 2, 1\right) \]

   7. Taylor expanded in Ce around inf

      \[\leadsto 2 \cdot Ce \]

   9. Applied rewrites 3.8%

      \[\leadsto 2 \cdot Ce \]

   11. Applied rewrites 26.6%

       \[\leadsto 0 \]

   if -2e6 < (*.f64 #s(literal 2 binary64) Ce)

   1. Initial program 100.0%

      \[e^{2 \cdot Ce} \]

   2. Taylor expanded in Ce around 0

      \[\leadsto 1 \]

   4. Applied rewrites 50.4%

      \[\leadsto 1 \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 7: 50.4% accurate, 15.0× speedup

Math

\[1 \]

FPCore

(FPCore (Ce)
  :precision binary64
  :pre TRUE
  1.0)

C

double code(double Ce) {
	return 1.0;
}

Fortran

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

Java

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

Python

def code(Ce):
	return 1.0

Julia

function code(Ce)
	return 1.0
end

MATLAB

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

Wolfram

code[Ce_] := 1.0

ReFlow

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

Derivation

1. Initial program 100.0%

   \[e^{2 \cdot Ce} \]

2. Taylor expanded in Ce around 0

   \[\leadsto 1 \]

4. Applied rewrites 50.4%

   \[\leadsto 1 \]
5. Add Preprocessing

Reproduce

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