Statistics.Distribution.Poisson.Internal:probability from math-functions-0.1.5.2

Percentage Accurate: 100.0% → 100.0%

Time: 13.0s

Alternatives: 18

Speedup: 1.0×

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

Specification

Math

\[\begin{array}{l} \\ e^{\left(x + y \cdot \log y\right) - z} \end{array} \]

FPCore

(FPCore (x y z) :precision binary64 (exp (- (+ x (* y (log y))) z)))

C

double code(double x, double y, double z) {
	return exp(((x + (y * log(y))) - z));
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = exp(((x + (y * log(y))) - z))
end function

Java

public static double code(double x, double y, double z) {
	return Math.exp(((x + (y * Math.log(y))) - z));
}

Python

def code(x, y, z):
	return math.exp(((x + (y * math.log(y))) - z))

Julia

function code(x, y, z)
	return exp(Float64(Float64(x + Float64(y * log(y))) - z))
end

MATLAB

function tmp = code(x, y, z)
	tmp = exp(((x + (y * log(y))) - z));
end

Wolfram

code[x_, y_, z_] := N[Exp[N[(N[(x + N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]], $MachinePrecision]

Initial Program: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ e^{\left(x + y \cdot \log y\right) - z} \end{array} \]

FPCore

(FPCore (x y z) :precision binary64 (exp (- (+ x (* y (log y))) z)))

C

double code(double x, double y, double z) {
	return exp(((x + (y * log(y))) - z));
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = exp(((x + (y * log(y))) - z))
end function

Java

public static double code(double x, double y, double z) {
	return Math.exp(((x + (y * Math.log(y))) - z));
}

Python

def code(x, y, z):
	return math.exp(((x + (y * math.log(y))) - z))

Julia

function code(x, y, z)
	return exp(Float64(Float64(x + Float64(y * log(y))) - z))
end

MATLAB

function tmp = code(x, y, z)
	tmp = exp(((x + (y * log(y))) - z));
end

Wolfram

code[x_, y_, z_] := N[Exp[N[(N[(x + N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]], $MachinePrecision]

Alternative 1: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ e^{\left(x + y \cdot \log y\right) - z} \end{array} \]

FPCore

(FPCore (x y z) :precision binary64 (exp (- (+ x (* y (log y))) z)))

C

double code(double x, double y, double z) {
	return exp(((x + (y * log(y))) - z));
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = exp(((x + (y * log(y))) - z))
end function

Java

public static double code(double x, double y, double z) {
	return Math.exp(((x + (y * Math.log(y))) - z));
}

Python

def code(x, y, z):
	return math.exp(((x + (y * math.log(y))) - z))

Julia

function code(x, y, z)
	return exp(Float64(Float64(x + Float64(y * log(y))) - z))
end

MATLAB

function tmp = code(x, y, z)
	tmp = exp(((x + (y * log(y))) - z));
end

Wolfram

code[x_, y_, z_] := N[Exp[N[(N[(x + N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]], $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[e^{\left(x + y \cdot \log y\right) - z} \]
2. Add Preprocessing
3. Add Preprocessing

Alternative 2: 89.7% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \cdot \log y \leq -2 \cdot 10^{-303}:\\ \;\;\;\;\frac{{y}^{y}}{e^{z - x}}\\ \mathbf{else}:\\ \;\;\;\;{y}^{y}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= (* y (log y)) -2e-303) (/ (pow y y) (exp (- z x))) (pow y y)))

C

double code(double x, double y, double z) {
	double tmp;
	if ((y * log(y)) <= -2e-303) {
		tmp = pow(y, y) / exp((z - x));
	} else {
		tmp = pow(y, y);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if ((y * log(y)) <= (-2d-303)) then
        tmp = (y ** y) / exp((z - x))
    else
        tmp = y ** y
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if ((y * Math.log(y)) <= -2e-303) {
		tmp = Math.pow(y, y) / Math.exp((z - x));
	} else {
		tmp = Math.pow(y, y);
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if (y * math.log(y)) <= -2e-303:
		tmp = math.pow(y, y) / math.exp((z - x))
	else:
		tmp = math.pow(y, y)
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (Float64(y * log(y)) <= -2e-303)
		tmp = Float64((y ^ y) / exp(Float64(z - x)));
	else
		tmp = y ^ y;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if ((y * log(y)) <= -2e-303)
		tmp = (y ^ y) / exp((z - x));
	else
		tmp = y ^ y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision], -2e-303], N[(N[Power[y, y], $MachinePrecision] / N[Exp[N[(z - x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[Power[y, y], $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if (*.f64 y (log.f64 y)) < -1.99999999999999986e-303

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   if -1.99999999999999986e-303 < (*.f64 y (log.f64 y))

   1. Initial program 99.9%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 3: 73.9% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := e^{-z}\\ \mathbf{if}\;x \leq -4.8 \cdot 10^{+69}:\\ \;\;\;\;e^{x}\\ \mathbf{elif}\;x \leq -7.4 \cdot 10^{-122}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;x \leq 4.5 \cdot 10^{-305}:\\ \;\;\;\;{y}^{y}\\ \mathbf{elif}\;x \leq 1.36 \cdot 10^{-244}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;x \leq 7.2 \cdot 10^{-6}:\\ \;\;\;\;e^{y \cdot \log y}\\ \mathbf{else}:\\ \;\;\;\;e^{x}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (exp (- z))))
   (if (<= x -4.8e+69)
     (exp x)
     (if (<= x -7.4e-122)
       t_0
       (if (<= x 4.5e-305)
         (pow y y)
         (if (<= x 1.36e-244)
           t_0
           (if (<= x 7.2e-6) (exp (* y (log y))) (exp x))))))))

C

double code(double x, double y, double z) {
	double t_0 = exp(-z);
	double tmp;
	if (x <= -4.8e+69) {
		tmp = exp(x);
	} else if (x <= -7.4e-122) {
		tmp = t_0;
	} else if (x <= 4.5e-305) {
		tmp = pow(y, y);
	} else if (x <= 1.36e-244) {
		tmp = t_0;
	} else if (x <= 7.2e-6) {
		tmp = exp((y * log(y)));
	} else {
		tmp = exp(x);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = exp(-z)
    if (x <= (-4.8d+69)) then
        tmp = exp(x)
    else if (x <= (-7.4d-122)) then
        tmp = t_0
    else if (x <= 4.5d-305) then
        tmp = y ** y
    else if (x <= 1.36d-244) then
        tmp = t_0
    else if (x <= 7.2d-6) then
        tmp = exp((y * log(y)))
    else
        tmp = exp(x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = Math.exp(-z);
	double tmp;
	if (x <= -4.8e+69) {
		tmp = Math.exp(x);
	} else if (x <= -7.4e-122) {
		tmp = t_0;
	} else if (x <= 4.5e-305) {
		tmp = Math.pow(y, y);
	} else if (x <= 1.36e-244) {
		tmp = t_0;
	} else if (x <= 7.2e-6) {
		tmp = Math.exp((y * Math.log(y)));
	} else {
		tmp = Math.exp(x);
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = math.exp(-z)
	tmp = 0
	if x <= -4.8e+69:
		tmp = math.exp(x)
	elif x <= -7.4e-122:
		tmp = t_0
	elif x <= 4.5e-305:
		tmp = math.pow(y, y)
	elif x <= 1.36e-244:
		tmp = t_0
	elif x <= 7.2e-6:
		tmp = math.exp((y * math.log(y)))
	else:
		tmp = math.exp(x)
	return tmp

Julia

function code(x, y, z)
	t_0 = exp(Float64(-z))
	tmp = 0.0
	if (x <= -4.8e+69)
		tmp = exp(x);
	elseif (x <= -7.4e-122)
		tmp = t_0;
	elseif (x <= 4.5e-305)
		tmp = y ^ y;
	elseif (x <= 1.36e-244)
		tmp = t_0;
	elseif (x <= 7.2e-6)
		tmp = exp(Float64(y * log(y)));
	else
		tmp = exp(x);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = exp(-z);
	tmp = 0.0;
	if (x <= -4.8e+69)
		tmp = exp(x);
	elseif (x <= -7.4e-122)
		tmp = t_0;
	elseif (x <= 4.5e-305)
		tmp = y ^ y;
	elseif (x <= 1.36e-244)
		tmp = t_0;
	elseif (x <= 7.2e-6)
		tmp = exp((y * log(y)));
	else
		tmp = exp(x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[Exp[(-z)], $MachinePrecision]}, If[LessEqual[x, -4.8e+69], N[Exp[x], $MachinePrecision], If[LessEqual[x, -7.4e-122], t$95$0, If[LessEqual[x, 4.5e-305], N[Power[y, y], $MachinePrecision], If[LessEqual[x, 1.36e-244], t$95$0, If[LessEqual[x, 7.2e-6], N[Exp[N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Exp[x], $MachinePrecision]]]]]]]

Derivation

1. Split input into 4 regimes

2. if x < -4.8000000000000003e69 or 7.19999999999999967e-6 < x

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -4.8000000000000003e69 < x < -7.3999999999999995e-122 or 4.5000000000000002e-305 < x < 1.36e-244

   1. Initial program 99.8%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -7.3999999999999995e-122 < x < 4.5000000000000002e-305

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 1.36e-244 < x < 7.19999999999999967e-6

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 4: 83.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -3.45 \cdot 10^{+47}:\\ \;\;\;\;e^{x}\\ \mathbf{elif}\;x \leq 5.3 \cdot 10^{+23}:\\ \;\;\;\;\frac{{y}^{y}}{e^{z}}\\ \mathbf{else}:\\ \;\;\;\;e^{x}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -3.45e+47)
   (exp x)
   (if (<= x 5.3e+23) (/ (pow y y) (exp z)) (exp x))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -3.45e+47) {
		tmp = exp(x);
	} else if (x <= 5.3e+23) {
		tmp = pow(y, y) / exp(z);
	} else {
		tmp = exp(x);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (x <= (-3.45d+47)) then
        tmp = exp(x)
    else if (x <= 5.3d+23) then
        tmp = (y ** y) / exp(z)
    else
        tmp = exp(x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= -3.45e+47) {
		tmp = Math.exp(x);
	} else if (x <= 5.3e+23) {
		tmp = Math.pow(y, y) / Math.exp(z);
	} else {
		tmp = Math.exp(x);
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -3.45e+47:
		tmp = math.exp(x)
	elif x <= 5.3e+23:
		tmp = math.pow(y, y) / math.exp(z)
	else:
		tmp = math.exp(x)
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -3.45e+47)
		tmp = exp(x);
	elseif (x <= 5.3e+23)
		tmp = Float64((y ^ y) / exp(z));
	else
		tmp = exp(x);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -3.45e+47)
		tmp = exp(x);
	elseif (x <= 5.3e+23)
		tmp = (y ^ y) / exp(z);
	else
		tmp = exp(x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -3.45e+47], N[Exp[x], $MachinePrecision], If[LessEqual[x, 5.3e+23], N[(N[Power[y, y], $MachinePrecision] / N[Exp[z], $MachinePrecision]), $MachinePrecision], N[Exp[x], $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if x < -3.4500000000000002e47 or 5.3000000000000001e23 < x

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -3.4500000000000002e47 < x < 5.3000000000000001e23

   1. Initial program 99.9%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 5: 73.8% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := e^{-z}\\ \mathbf{if}\;x \leq -1.75 \cdot 10^{+69}:\\ \;\;\;\;e^{x}\\ \mathbf{elif}\;x \leq -1.9 \cdot 10^{-123}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;x \leq 2.8 \cdot 10^{-308}:\\ \;\;\;\;{y}^{y}\\ \mathbf{elif}\;x \leq 1.36 \cdot 10^{-244}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;x \leq 7.2 \cdot 10^{-6}:\\ \;\;\;\;{y}^{y}\\ \mathbf{else}:\\ \;\;\;\;e^{x}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (exp (- z))))
   (if (<= x -1.75e+69)
     (exp x)
     (if (<= x -1.9e-123)
       t_0
       (if (<= x 2.8e-308)
         (pow y y)
         (if (<= x 1.36e-244) t_0 (if (<= x 7.2e-6) (pow y y) (exp x))))))))

C

double code(double x, double y, double z) {
	double t_0 = exp(-z);
	double tmp;
	if (x <= -1.75e+69) {
		tmp = exp(x);
	} else if (x <= -1.9e-123) {
		tmp = t_0;
	} else if (x <= 2.8e-308) {
		tmp = pow(y, y);
	} else if (x <= 1.36e-244) {
		tmp = t_0;
	} else if (x <= 7.2e-6) {
		tmp = pow(y, y);
	} else {
		tmp = exp(x);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = exp(-z)
    if (x <= (-1.75d+69)) then
        tmp = exp(x)
    else if (x <= (-1.9d-123)) then
        tmp = t_0
    else if (x <= 2.8d-308) then
        tmp = y ** y
    else if (x <= 1.36d-244) then
        tmp = t_0
    else if (x <= 7.2d-6) then
        tmp = y ** y
    else
        tmp = exp(x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = Math.exp(-z);
	double tmp;
	if (x <= -1.75e+69) {
		tmp = Math.exp(x);
	} else if (x <= -1.9e-123) {
		tmp = t_0;
	} else if (x <= 2.8e-308) {
		tmp = Math.pow(y, y);
	} else if (x <= 1.36e-244) {
		tmp = t_0;
	} else if (x <= 7.2e-6) {
		tmp = Math.pow(y, y);
	} else {
		tmp = Math.exp(x);
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = math.exp(-z)
	tmp = 0
	if x <= -1.75e+69:
		tmp = math.exp(x)
	elif x <= -1.9e-123:
		tmp = t_0
	elif x <= 2.8e-308:
		tmp = math.pow(y, y)
	elif x <= 1.36e-244:
		tmp = t_0
	elif x <= 7.2e-6:
		tmp = math.pow(y, y)
	else:
		tmp = math.exp(x)
	return tmp

Julia

function code(x, y, z)
	t_0 = exp(Float64(-z))
	tmp = 0.0
	if (x <= -1.75e+69)
		tmp = exp(x);
	elseif (x <= -1.9e-123)
		tmp = t_0;
	elseif (x <= 2.8e-308)
		tmp = y ^ y;
	elseif (x <= 1.36e-244)
		tmp = t_0;
	elseif (x <= 7.2e-6)
		tmp = y ^ y;
	else
		tmp = exp(x);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = exp(-z);
	tmp = 0.0;
	if (x <= -1.75e+69)
		tmp = exp(x);
	elseif (x <= -1.9e-123)
		tmp = t_0;
	elseif (x <= 2.8e-308)
		tmp = y ^ y;
	elseif (x <= 1.36e-244)
		tmp = t_0;
	elseif (x <= 7.2e-6)
		tmp = y ^ y;
	else
		tmp = exp(x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[Exp[(-z)], $MachinePrecision]}, If[LessEqual[x, -1.75e+69], N[Exp[x], $MachinePrecision], If[LessEqual[x, -1.9e-123], t$95$0, If[LessEqual[x, 2.8e-308], N[Power[y, y], $MachinePrecision], If[LessEqual[x, 1.36e-244], t$95$0, If[LessEqual[x, 7.2e-6], N[Power[y, y], $MachinePrecision], N[Exp[x], $MachinePrecision]]]]]]]

Derivation

1. Split input into 3 regimes

2. if x < -1.74999999999999994e69 or 7.19999999999999967e-6 < x

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.74999999999999994e69 < x < -1.89999999999999998e-123 or 2.79999999999999984e-308 < x < 1.36e-244

   1. Initial program 99.8%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.89999999999999998e-123 < x < 2.79999999999999984e-308 or 1.36e-244 < x < 7.19999999999999967e-6

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 6: 73.5% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := e^{-z}\\ \mathbf{if}\;x \leq -1.65 \cdot 10^{+69}:\\ \;\;\;\;e^{x}\\ \mathbf{elif}\;x \leq -2.35 \cdot 10^{-123}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;x \leq 2 \cdot 10^{-306}:\\ \;\;\;\;e^{y}\\ \mathbf{elif}\;x \leq 1.02 \cdot 10^{+22}:\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;e^{x}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (exp (- z))))
   (if (<= x -1.65e+69)
     (exp x)
     (if (<= x -2.35e-123)
       t_0
       (if (<= x 2e-306) (exp y) (if (<= x 1.02e+22) t_0 (exp x)))))))

C

double code(double x, double y, double z) {
	double t_0 = exp(-z);
	double tmp;
	if (x <= -1.65e+69) {
		tmp = exp(x);
	} else if (x <= -2.35e-123) {
		tmp = t_0;
	} else if (x <= 2e-306) {
		tmp = exp(y);
	} else if (x <= 1.02e+22) {
		tmp = t_0;
	} else {
		tmp = exp(x);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = exp(-z)
    if (x <= (-1.65d+69)) then
        tmp = exp(x)
    else if (x <= (-2.35d-123)) then
        tmp = t_0
    else if (x <= 2d-306) then
        tmp = exp(y)
    else if (x <= 1.02d+22) then
        tmp = t_0
    else
        tmp = exp(x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = Math.exp(-z);
	double tmp;
	if (x <= -1.65e+69) {
		tmp = Math.exp(x);
	} else if (x <= -2.35e-123) {
		tmp = t_0;
	} else if (x <= 2e-306) {
		tmp = Math.exp(y);
	} else if (x <= 1.02e+22) {
		tmp = t_0;
	} else {
		tmp = Math.exp(x);
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = math.exp(-z)
	tmp = 0
	if x <= -1.65e+69:
		tmp = math.exp(x)
	elif x <= -2.35e-123:
		tmp = t_0
	elif x <= 2e-306:
		tmp = math.exp(y)
	elif x <= 1.02e+22:
		tmp = t_0
	else:
		tmp = math.exp(x)
	return tmp

Julia

function code(x, y, z)
	t_0 = exp(Float64(-z))
	tmp = 0.0
	if (x <= -1.65e+69)
		tmp = exp(x);
	elseif (x <= -2.35e-123)
		tmp = t_0;
	elseif (x <= 2e-306)
		tmp = exp(y);
	elseif (x <= 1.02e+22)
		tmp = t_0;
	else
		tmp = exp(x);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = exp(-z);
	tmp = 0.0;
	if (x <= -1.65e+69)
		tmp = exp(x);
	elseif (x <= -2.35e-123)
		tmp = t_0;
	elseif (x <= 2e-306)
		tmp = exp(y);
	elseif (x <= 1.02e+22)
		tmp = t_0;
	else
		tmp = exp(x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[Exp[(-z)], $MachinePrecision]}, If[LessEqual[x, -1.65e+69], N[Exp[x], $MachinePrecision], If[LessEqual[x, -2.35e-123], t$95$0, If[LessEqual[x, 2e-306], N[Exp[y], $MachinePrecision], If[LessEqual[x, 1.02e+22], t$95$0, N[Exp[x], $MachinePrecision]]]]]]

Derivation

1. Split input into 3 regimes

2. if x < -1.6499999999999999e69 or 1.02e22 < x

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.6499999999999999e69 < x < -2.3500000000000001e-123 or 2.00000000000000006e-306 < x < 1.02e22

   1. Initial program 99.9%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -2.3500000000000001e-123 < x < 2.00000000000000006e-306

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

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

Alternative 7: 73.9% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -55000:\\ \;\;\;\;e^{x}\\ \mathbf{elif}\;x \leq 7.2 \cdot 10^{-6}:\\ \;\;\;\;e^{y}\\ \mathbf{else}:\\ \;\;\;\;e^{x}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -55000.0) (exp x) (if (<= x 7.2e-6) (exp y) (exp x))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -55000.0) {
		tmp = exp(x);
	} else if (x <= 7.2e-6) {
		tmp = exp(y);
	} else {
		tmp = exp(x);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (x <= (-55000.0d0)) then
        tmp = exp(x)
    else if (x <= 7.2d-6) then
        tmp = exp(y)
    else
        tmp = exp(x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= -55000.0) {
		tmp = Math.exp(x);
	} else if (x <= 7.2e-6) {
		tmp = Math.exp(y);
	} else {
		tmp = Math.exp(x);
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -55000.0:
		tmp = math.exp(x)
	elif x <= 7.2e-6:
		tmp = math.exp(y)
	else:
		tmp = math.exp(x)
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -55000.0)
		tmp = exp(x);
	elseif (x <= 7.2e-6)
		tmp = exp(y);
	else
		tmp = exp(x);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -55000.0)
		tmp = exp(x);
	elseif (x <= 7.2e-6)
		tmp = exp(y);
	else
		tmp = exp(x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -55000.0], N[Exp[x], $MachinePrecision], If[LessEqual[x, 7.2e-6], N[Exp[y], $MachinePrecision], N[Exp[x], $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if x < -55000 or 7.19999999999999967e-6 < x

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -55000 < x < 7.19999999999999967e-6

   1. Initial program 99.9%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

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

Alternative 8: 69.5% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq 1.55 \cdot 10^{+96}:\\ \;\;\;\;e^{x}\\ \mathbf{else}:\\ \;\;\;\;1 + y \cdot \left(1 + y \cdot \left(0.5 + y \cdot 0.16666666666666666\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= y 1.55e+96)
   (exp x)
   (+ 1.0 (* y (+ 1.0 (* y (+ 0.5 (* y 0.16666666666666666))))))))

C

double code(double x, double y, double z) {
	double tmp;
	if (y <= 1.55e+96) {
		tmp = exp(x);
	} else {
		tmp = 1.0 + (y * (1.0 + (y * (0.5 + (y * 0.16666666666666666)))));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (y <= 1.55d+96) then
        tmp = exp(x)
    else
        tmp = 1.0d0 + (y * (1.0d0 + (y * (0.5d0 + (y * 0.16666666666666666d0)))))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (y <= 1.55e+96) {
		tmp = Math.exp(x);
	} else {
		tmp = 1.0 + (y * (1.0 + (y * (0.5 + (y * 0.16666666666666666)))));
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if y <= 1.55e+96:
		tmp = math.exp(x)
	else:
		tmp = 1.0 + (y * (1.0 + (y * (0.5 + (y * 0.16666666666666666)))))
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (y <= 1.55e+96)
		tmp = exp(x);
	else
		tmp = Float64(1.0 + Float64(y * Float64(1.0 + Float64(y * Float64(0.5 + Float64(y * 0.16666666666666666))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (y <= 1.55e+96)
		tmp = exp(x);
	else
		tmp = 1.0 + (y * (1.0 + (y * (0.5 + (y * 0.16666666666666666)))));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[y, 1.55e+96], N[Exp[x], $MachinePrecision], N[(1.0 + N[(y * N[(1.0 + N[(y * N[(0.5 + N[(y * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if y < 1.5499999999999999e96

   1. Initial program 99.9%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 1.5499999999999999e96 < y

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   8. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   10. Simplified 0

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

Alternative 9: 56.0% accurate, 9.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -1.5 \cdot 10^{-5}:\\ \;\;\;\;z \cdot \left(\left(z \cdot z\right) \cdot -0.16666666666666666\right)\\ \mathbf{elif}\;x \leq 1.6 \cdot 10^{+100}:\\ \;\;\;\;1 + y \cdot \left(1 + y \cdot \left(0.5 + y \cdot 0.16666666666666666\right)\right)\\ \mathbf{else}:\\ \;\;\;\;1 + x \cdot \left(1 + x \cdot \left(0.5 + x \cdot 0.16666666666666666\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -1.5e-5)
   (* z (* (* z z) -0.16666666666666666))
   (if (<= x 1.6e+100)
     (+ 1.0 (* y (+ 1.0 (* y (+ 0.5 (* y 0.16666666666666666))))))
     (+ 1.0 (* x (+ 1.0 (* x (+ 0.5 (* x 0.16666666666666666)))))))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -1.5e-5) {
		tmp = z * ((z * z) * -0.16666666666666666);
	} else if (x <= 1.6e+100) {
		tmp = 1.0 + (y * (1.0 + (y * (0.5 + (y * 0.16666666666666666)))));
	} else {
		tmp = 1.0 + (x * (1.0 + (x * (0.5 + (x * 0.16666666666666666)))));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (x <= (-1.5d-5)) then
        tmp = z * ((z * z) * (-0.16666666666666666d0))
    else if (x <= 1.6d+100) then
        tmp = 1.0d0 + (y * (1.0d0 + (y * (0.5d0 + (y * 0.16666666666666666d0)))))
    else
        tmp = 1.0d0 + (x * (1.0d0 + (x * (0.5d0 + (x * 0.16666666666666666d0)))))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= -1.5e-5) {
		tmp = z * ((z * z) * -0.16666666666666666);
	} else if (x <= 1.6e+100) {
		tmp = 1.0 + (y * (1.0 + (y * (0.5 + (y * 0.16666666666666666)))));
	} else {
		tmp = 1.0 + (x * (1.0 + (x * (0.5 + (x * 0.16666666666666666)))));
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -1.5e-5:
		tmp = z * ((z * z) * -0.16666666666666666)
	elif x <= 1.6e+100:
		tmp = 1.0 + (y * (1.0 + (y * (0.5 + (y * 0.16666666666666666)))))
	else:
		tmp = 1.0 + (x * (1.0 + (x * (0.5 + (x * 0.16666666666666666)))))
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -1.5e-5)
		tmp = Float64(z * Float64(Float64(z * z) * -0.16666666666666666));
	elseif (x <= 1.6e+100)
		tmp = Float64(1.0 + Float64(y * Float64(1.0 + Float64(y * Float64(0.5 + Float64(y * 0.16666666666666666))))));
	else
		tmp = Float64(1.0 + Float64(x * Float64(1.0 + Float64(x * Float64(0.5 + Float64(x * 0.16666666666666666))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -1.5e-5)
		tmp = z * ((z * z) * -0.16666666666666666);
	elseif (x <= 1.6e+100)
		tmp = 1.0 + (y * (1.0 + (y * (0.5 + (y * 0.16666666666666666)))));
	else
		tmp = 1.0 + (x * (1.0 + (x * (0.5 + (x * 0.16666666666666666)))));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -1.5e-5], N[(z * N[(N[(z * z), $MachinePrecision] * -0.16666666666666666), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.6e+100], N[(1.0 + N[(y * N[(1.0 + N[(y * N[(0.5 + N[(y * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 + N[(x * N[(1.0 + N[(x * N[(0.5 + N[(x * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if x < -1.50000000000000004e-5

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -1.50000000000000004e-5 < x < 1.5999999999999999e100

   1. Initial program 99.9%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   8. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if 1.5999999999999999e100 < x

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 10: 52.0% accurate, 9.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -1.5 \cdot 10^{-5}:\\ \;\;\;\;z \cdot \left(\left(z \cdot z\right) \cdot -0.16666666666666666\right)\\ \mathbf{elif}\;x \leq 3.5 \cdot 10^{+95}:\\ \;\;\;\;1 + y \cdot \left(1 + y \cdot 0.5\right)\\ \mathbf{else}:\\ \;\;\;\;1 + x \cdot \left(1 + x \cdot \left(0.5 + x \cdot 0.16666666666666666\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -1.5e-5)
   (* z (* (* z z) -0.16666666666666666))
   (if (<= x 3.5e+95)
     (+ 1.0 (* y (+ 1.0 (* y 0.5))))
     (+ 1.0 (* x (+ 1.0 (* x (+ 0.5 (* x 0.16666666666666666)))))))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -1.5e-5) {
		tmp = z * ((z * z) * -0.16666666666666666);
	} else if (x <= 3.5e+95) {
		tmp = 1.0 + (y * (1.0 + (y * 0.5)));
	} else {
		tmp = 1.0 + (x * (1.0 + (x * (0.5 + (x * 0.16666666666666666)))));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (x <= (-1.5d-5)) then
        tmp = z * ((z * z) * (-0.16666666666666666d0))
    else if (x <= 3.5d+95) then
        tmp = 1.0d0 + (y * (1.0d0 + (y * 0.5d0)))
    else
        tmp = 1.0d0 + (x * (1.0d0 + (x * (0.5d0 + (x * 0.16666666666666666d0)))))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= -1.5e-5) {
		tmp = z * ((z * z) * -0.16666666666666666);
	} else if (x <= 3.5e+95) {
		tmp = 1.0 + (y * (1.0 + (y * 0.5)));
	} else {
		tmp = 1.0 + (x * (1.0 + (x * (0.5 + (x * 0.16666666666666666)))));
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -1.5e-5:
		tmp = z * ((z * z) * -0.16666666666666666)
	elif x <= 3.5e+95:
		tmp = 1.0 + (y * (1.0 + (y * 0.5)))
	else:
		tmp = 1.0 + (x * (1.0 + (x * (0.5 + (x * 0.16666666666666666)))))
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -1.5e-5)
		tmp = Float64(z * Float64(Float64(z * z) * -0.16666666666666666));
	elseif (x <= 3.5e+95)
		tmp = Float64(1.0 + Float64(y * Float64(1.0 + Float64(y * 0.5))));
	else
		tmp = Float64(1.0 + Float64(x * Float64(1.0 + Float64(x * Float64(0.5 + Float64(x * 0.16666666666666666))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -1.5e-5)
		tmp = z * ((z * z) * -0.16666666666666666);
	elseif (x <= 3.5e+95)
		tmp = 1.0 + (y * (1.0 + (y * 0.5)));
	else
		tmp = 1.0 + (x * (1.0 + (x * (0.5 + (x * 0.16666666666666666)))));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -1.5e-5], N[(z * N[(N[(z * z), $MachinePrecision] * -0.16666666666666666), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 3.5e+95], N[(1.0 + N[(y * N[(1.0 + N[(y * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 + N[(x * N[(1.0 + N[(x * N[(0.5 + N[(x * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if x < -1.50000000000000004e-5

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -1.50000000000000004e-5 < x < 3.5e95

   1. Initial program 99.9%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   8. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if 3.5e95 < x

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 11: 49.7% accurate, 10.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -4.3 \cdot 10^{-7}:\\ \;\;\;\;z \cdot \left(\left(z \cdot z\right) \cdot -0.16666666666666666\right)\\ \mathbf{elif}\;x \leq 1.35 \cdot 10^{+153}:\\ \;\;\;\;1 + y \cdot \left(1 + y \cdot 0.5\right)\\ \mathbf{else}:\\ \;\;\;\;1 + x \cdot \left(1 + x \cdot 0.5\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -4.3e-7)
   (* z (* (* z z) -0.16666666666666666))
   (if (<= x 1.35e+153)
     (+ 1.0 (* y (+ 1.0 (* y 0.5))))
     (+ 1.0 (* x (+ 1.0 (* x 0.5)))))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -4.3e-7) {
		tmp = z * ((z * z) * -0.16666666666666666);
	} else if (x <= 1.35e+153) {
		tmp = 1.0 + (y * (1.0 + (y * 0.5)));
	} else {
		tmp = 1.0 + (x * (1.0 + (x * 0.5)));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (x <= (-4.3d-7)) then
        tmp = z * ((z * z) * (-0.16666666666666666d0))
    else if (x <= 1.35d+153) then
        tmp = 1.0d0 + (y * (1.0d0 + (y * 0.5d0)))
    else
        tmp = 1.0d0 + (x * (1.0d0 + (x * 0.5d0)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= -4.3e-7) {
		tmp = z * ((z * z) * -0.16666666666666666);
	} else if (x <= 1.35e+153) {
		tmp = 1.0 + (y * (1.0 + (y * 0.5)));
	} else {
		tmp = 1.0 + (x * (1.0 + (x * 0.5)));
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -4.3e-7:
		tmp = z * ((z * z) * -0.16666666666666666)
	elif x <= 1.35e+153:
		tmp = 1.0 + (y * (1.0 + (y * 0.5)))
	else:
		tmp = 1.0 + (x * (1.0 + (x * 0.5)))
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -4.3e-7)
		tmp = Float64(z * Float64(Float64(z * z) * -0.16666666666666666));
	elseif (x <= 1.35e+153)
		tmp = Float64(1.0 + Float64(y * Float64(1.0 + Float64(y * 0.5))));
	else
		tmp = Float64(1.0 + Float64(x * Float64(1.0 + Float64(x * 0.5))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -4.3e-7)
		tmp = z * ((z * z) * -0.16666666666666666);
	elseif (x <= 1.35e+153)
		tmp = 1.0 + (y * (1.0 + (y * 0.5)));
	else
		tmp = 1.0 + (x * (1.0 + (x * 0.5)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -4.3e-7], N[(z * N[(N[(z * z), $MachinePrecision] * -0.16666666666666666), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.35e+153], N[(1.0 + N[(y * N[(1.0 + N[(y * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 + N[(x * N[(1.0 + N[(x * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if x < -4.3000000000000001e-7

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -4.3000000000000001e-7 < x < 1.35e153

   1. Initial program 99.9%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   8. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if 1.35e153 < x

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 12: 43.5% accurate, 10.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -1.36 \cdot 10^{-5}:\\ \;\;\;\;z \cdot \left(\left(z \cdot z\right) \cdot -0.16666666666666666\right)\\ \mathbf{elif}\;x \leq 2.6 \cdot 10^{+153}:\\ \;\;\;\;1 + z \cdot \left(0.5 \cdot z\right)\\ \mathbf{else}:\\ \;\;\;\;1 + x \cdot \left(1 + x \cdot 0.5\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -1.36e-5)
   (* z (* (* z z) -0.16666666666666666))
   (if (<= x 2.6e+153)
     (+ 1.0 (* z (* 0.5 z)))
     (+ 1.0 (* x (+ 1.0 (* x 0.5)))))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -1.36e-5) {
		tmp = z * ((z * z) * -0.16666666666666666);
	} else if (x <= 2.6e+153) {
		tmp = 1.0 + (z * (0.5 * z));
	} else {
		tmp = 1.0 + (x * (1.0 + (x * 0.5)));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (x <= (-1.36d-5)) then
        tmp = z * ((z * z) * (-0.16666666666666666d0))
    else if (x <= 2.6d+153) then
        tmp = 1.0d0 + (z * (0.5d0 * z))
    else
        tmp = 1.0d0 + (x * (1.0d0 + (x * 0.5d0)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= -1.36e-5) {
		tmp = z * ((z * z) * -0.16666666666666666);
	} else if (x <= 2.6e+153) {
		tmp = 1.0 + (z * (0.5 * z));
	} else {
		tmp = 1.0 + (x * (1.0 + (x * 0.5)));
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -1.36e-5:
		tmp = z * ((z * z) * -0.16666666666666666)
	elif x <= 2.6e+153:
		tmp = 1.0 + (z * (0.5 * z))
	else:
		tmp = 1.0 + (x * (1.0 + (x * 0.5)))
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -1.36e-5)
		tmp = Float64(z * Float64(Float64(z * z) * -0.16666666666666666));
	elseif (x <= 2.6e+153)
		tmp = Float64(1.0 + Float64(z * Float64(0.5 * z)));
	else
		tmp = Float64(1.0 + Float64(x * Float64(1.0 + Float64(x * 0.5))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -1.36e-5)
		tmp = z * ((z * z) * -0.16666666666666666);
	elseif (x <= 2.6e+153)
		tmp = 1.0 + (z * (0.5 * z));
	else
		tmp = 1.0 + (x * (1.0 + (x * 0.5)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -1.36e-5], N[(z * N[(N[(z * z), $MachinePrecision] * -0.16666666666666666), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.6e+153], N[(1.0 + N[(z * N[(0.5 * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 + N[(x * N[(1.0 + N[(x * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if x < -1.36000000000000002e-5

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -1.36000000000000002e-5 < x < 2.5999999999999999e153

   1. Initial program 99.9%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if 2.5999999999999999e153 < x

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 13: 32.5% accurate, 13.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -2.1 \cdot 10^{+69}:\\ \;\;\;\;z \cdot \left(\left(z \cdot z\right) \cdot -0.16666666666666666\right)\\ \mathbf{elif}\;z \leq 1.02 \cdot 10^{+97}:\\ \;\;\;\;1 + y\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(z \cdot z\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -2.1e+69)
   (* z (* (* z z) -0.16666666666666666))
   (if (<= z 1.02e+97) (+ 1.0 y) (* 0.5 (* z z)))))

C

double code(double x, double y, double z) {
	double tmp;
	if (z <= -2.1e+69) {
		tmp = z * ((z * z) * -0.16666666666666666);
	} else if (z <= 1.02e+97) {
		tmp = 1.0 + y;
	} else {
		tmp = 0.5 * (z * z);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (z <= (-2.1d+69)) then
        tmp = z * ((z * z) * (-0.16666666666666666d0))
    else if (z <= 1.02d+97) then
        tmp = 1.0d0 + y
    else
        tmp = 0.5d0 * (z * z)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (z <= -2.1e+69) {
		tmp = z * ((z * z) * -0.16666666666666666);
	} else if (z <= 1.02e+97) {
		tmp = 1.0 + y;
	} else {
		tmp = 0.5 * (z * z);
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if z <= -2.1e+69:
		tmp = z * ((z * z) * -0.16666666666666666)
	elif z <= 1.02e+97:
		tmp = 1.0 + y
	else:
		tmp = 0.5 * (z * z)
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (z <= -2.1e+69)
		tmp = Float64(z * Float64(Float64(z * z) * -0.16666666666666666));
	elseif (z <= 1.02e+97)
		tmp = Float64(1.0 + y);
	else
		tmp = Float64(0.5 * Float64(z * z));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (z <= -2.1e+69)
		tmp = z * ((z * z) * -0.16666666666666666);
	elseif (z <= 1.02e+97)
		tmp = 1.0 + y;
	else
		tmp = 0.5 * (z * z);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[z, -2.1e+69], N[(z * N[(N[(z * z), $MachinePrecision] * -0.16666666666666666), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.02e+97], N[(1.0 + y), $MachinePrecision], N[(0.5 * N[(z * z), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if z < -2.10000000000000015e69

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -2.10000000000000015e69 < z < 1.02000000000000003e97

   1. Initial program 99.9%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   8. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if 1.02000000000000003e97 < z

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   11. Simplified 0

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

Alternative 14: 29.1% accurate, 13.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 0.5 \cdot \left(z \cdot z\right)\\ \mathbf{if}\;z \leq -2.4 \cdot 10^{+74}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;z \leq 9.6 \cdot 10^{+96}:\\ \;\;\;\;1 + y\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (* 0.5 (* z z))))
   (if (<= z -2.4e+74) t_0 (if (<= z 9.6e+96) (+ 1.0 y) t_0))))

C

double code(double x, double y, double z) {
	double t_0 = 0.5 * (z * z);
	double tmp;
	if (z <= -2.4e+74) {
		tmp = t_0;
	} else if (z <= 9.6e+96) {
		tmp = 1.0 + y;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = 0.5d0 * (z * z)
    if (z <= (-2.4d+74)) then
        tmp = t_0
    else if (z <= 9.6d+96) then
        tmp = 1.0d0 + y
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = 0.5 * (z * z);
	double tmp;
	if (z <= -2.4e+74) {
		tmp = t_0;
	} else if (z <= 9.6e+96) {
		tmp = 1.0 + y;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = 0.5 * (z * z)
	tmp = 0
	if z <= -2.4e+74:
		tmp = t_0
	elif z <= 9.6e+96:
		tmp = 1.0 + y
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(0.5 * Float64(z * z))
	tmp = 0.0
	if (z <= -2.4e+74)
		tmp = t_0;
	elseif (z <= 9.6e+96)
		tmp = Float64(1.0 + y);
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = 0.5 * (z * z);
	tmp = 0.0;
	if (z <= -2.4e+74)
		tmp = t_0;
	elseif (z <= 9.6e+96)
		tmp = 1.0 + y;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(0.5 * N[(z * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.4e+74], t$95$0, If[LessEqual[z, 9.6e+96], N[(1.0 + y), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if z < -2.40000000000000008e74 or 9.59999999999999972e96 < z

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -2.40000000000000008e74 < z < 9.59999999999999972e96

   1. Initial program 99.9%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   8. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   10. Simplified 0

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

Alternative 15: 34.4% accurate, 17.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -1.5 \cdot 10^{-5}:\\ \;\;\;\;z \cdot \left(\left(z \cdot z\right) \cdot -0.16666666666666666\right)\\ \mathbf{else}:\\ \;\;\;\;1 + z \cdot \left(0.5 \cdot z\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -1.5e-5)
   (* z (* (* z z) -0.16666666666666666))
   (+ 1.0 (* z (* 0.5 z)))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -1.5e-5) {
		tmp = z * ((z * z) * -0.16666666666666666);
	} else {
		tmp = 1.0 + (z * (0.5 * z));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (x <= (-1.5d-5)) then
        tmp = z * ((z * z) * (-0.16666666666666666d0))
    else
        tmp = 1.0d0 + (z * (0.5d0 * z))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= -1.5e-5) {
		tmp = z * ((z * z) * -0.16666666666666666);
	} else {
		tmp = 1.0 + (z * (0.5 * z));
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -1.5e-5:
		tmp = z * ((z * z) * -0.16666666666666666)
	else:
		tmp = 1.0 + (z * (0.5 * z))
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -1.5e-5)
		tmp = Float64(z * Float64(Float64(z * z) * -0.16666666666666666));
	else
		tmp = Float64(1.0 + Float64(z * Float64(0.5 * z)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -1.5e-5)
		tmp = z * ((z * z) * -0.16666666666666666);
	else
		tmp = 1.0 + (z * (0.5 * z));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -1.5e-5], N[(z * N[(N[(z * z), $MachinePrecision] * -0.16666666666666666), $MachinePrecision]), $MachinePrecision], N[(1.0 + N[(z * N[(0.5 * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if x < -1.50000000000000004e-5

   1. Initial program 100.0%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -1.50000000000000004e-5 < x

   1. Initial program 99.9%

      \[e^{\left(x + y \cdot \log y\right) - z} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   11. Simplified 0

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

Alternative 16: 15.6% accurate, 69.0× speedup

Math

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

FPCore

(FPCore (x y z) :precision binary64 (+ 1.0 y))

C

double code(double x, double y, double z) {
	return 1.0 + y;
}

Fortran

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

Java

public static double code(double x, double y, double z) {
	return 1.0 + y;
}

Python

def code(x, y, z):
	return 1.0 + y

Julia

function code(x, y, z)
	return Float64(1.0 + y)
end

MATLAB

function tmp = code(x, y, z)
	tmp = 1.0 + y;
end

Wolfram

code[x_, y_, z_] := N[(1.0 + y), $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[e^{\left(x + y \cdot \log y\right) - z} \]
2. Add Preprocessing

3. Taylor expanded in y around inf 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]

7. Applied egg-rr 0

   \[\leadsto expr\]

8. Taylor expanded in y around 0 0

   \[\leadsto expr\]

10. Simplified 0

    \[\leadsto expr\]
11. Add Preprocessing

Alternative 17: 14.8% accurate, 69.0× speedup

Math

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

FPCore

(FPCore (x y z) :precision binary64 (+ 1.0 x))

C

double code(double x, double y, double z) {
	return 1.0 + x;
}

Fortran

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

Java

public static double code(double x, double y, double z) {
	return 1.0 + x;
}

Python

def code(x, y, z):
	return 1.0 + x

Julia

function code(x, y, z)
	return Float64(1.0 + x)
end

MATLAB

function tmp = code(x, y, z)
	tmp = 1.0 + x;
end

Wolfram

code[x_, y_, z_] := N[(1.0 + x), $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[e^{\left(x + y \cdot \log y\right) - z} \]
2. Add Preprocessing

3. Taylor expanded in x around inf 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 18: 14.6% accurate, 207.0× speedup

Math

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

FPCore

(FPCore (x y z) :precision binary64 1.0)

C

double code(double x, double y, double z) {
	return 1.0;
}

Fortran

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

Java

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

Python

def code(x, y, z):
	return 1.0

Julia

function code(x, y, z)
	return 1.0
end

MATLAB

function tmp = code(x, y, z)
	tmp = 1.0;
end

Wolfram

code[x_, y_, z_] := 1.0

Derivation

1. Initial program 100.0%

   \[e^{\left(x + y \cdot \log y\right) - z} \]
2. Add Preprocessing

3. Taylor expanded in y around inf 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]

7. Applied egg-rr 0

   \[\leadsto expr\]
8. Add Preprocessing

Developer target: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ e^{\left(x - z\right) + \log y \cdot y} \end{array} \]

FPCore

(FPCore (x y z) :precision binary64 (exp (+ (- x z) (* (log y) y))))

C

double code(double x, double y, double z) {
	return exp(((x - z) + (log(y) * y)));
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = exp(((x - z) + (log(y) * y)))
end function

Java

public static double code(double x, double y, double z) {
	return Math.exp(((x - z) + (Math.log(y) * y)));
}

Python

def code(x, y, z):
	return math.exp(((x - z) + (math.log(y) * y)))

Julia

function code(x, y, z)
	return exp(Float64(Float64(x - z) + Float64(log(y) * y)))
end

MATLAB

function tmp = code(x, y, z)
	tmp = exp(((x - z) + (log(y) * y)));
end

Wolfram

code[x_, y_, z_] := N[Exp[N[(N[(x - z), $MachinePrecision] + N[(N[Log[y], $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]

Reproduce

herbie shell --seed 2024110 
(FPCore (x y z)
  :name "Statistics.Distribution.Poisson.Internal:probability from math-functions-0.1.5.2"
  :precision binary64

  :alt
  (exp (+ (- x z) (* (log y) y)))

  (exp (- (+ x (* y (log y))) z)))