Numeric.SpecFunctions:incompleteBetaWorker from math-functions-0.1.5.2, A

Percentage Accurate: 98.4% → 98.5%

Time: 4.4s

Alternatives: 19

Speedup: 1.0×

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

Specification

Math

\[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (/ (* x (exp (- (+ (* y (log z)) (* (- t 1.0) (log a))) b))) y))

C

double code(double x, double y, double z, double t, double a, double b) {
	return (x * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
}

Fortran

real(8) function code(x, y, z, t, a, b)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    code = (x * exp((((y * log(z)) + ((t - 1.0d0) * log(a))) - b))) / y
end function

Java

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

Python

def code(x, y, z, t, a, b):
	return (x * math.exp((((y * math.log(z)) + ((t - 1.0) * math.log(a))) - b))) / y

Julia

function code(x, y, z, t, a, b)
	return Float64(Float64(x * exp(Float64(Float64(Float64(y * log(z)) + Float64(Float64(t - 1.0) * log(a))) - b))) / y)
end

MATLAB

function tmp = code(x, y, z, t, a, b)
	tmp = (x * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := N[(N[(x * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] + N[(N[(t - 1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	(x * (exp((((y * (ln(z))) + ((t - (1)) * (ln(a)))) - b)))) / y
END code

Initial Program: 98.4% accurate, 1.0× speedup

Math

\[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (/ (* x (exp (- (+ (* y (log z)) (* (- t 1.0) (log a))) b))) y))

C

double code(double x, double y, double z, double t, double a, double b) {
	return (x * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
}

Fortran

real(8) function code(x, y, z, t, a, b)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    code = (x * exp((((y * log(z)) + ((t - 1.0d0) * log(a))) - b))) / y
end function

Java

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

Python

def code(x, y, z, t, a, b):
	return (x * math.exp((((y * math.log(z)) + ((t - 1.0) * math.log(a))) - b))) / y

Julia

function code(x, y, z, t, a, b)
	return Float64(Float64(x * exp(Float64(Float64(Float64(y * log(z)) + Float64(Float64(t - 1.0) * log(a))) - b))) / y)
end

MATLAB

function tmp = code(x, y, z, t, a, b)
	tmp = (x * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := N[(N[(x * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] + N[(N[(t - 1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	(x * (exp((((y * (ln(z))) + ((t - (1)) * (ln(a)))) - b)))) / y
END code

Alternative 1: 98.4% accurate, 1.0× speedup

Math

\[x \cdot \frac{e^{\mathsf{fma}\left(\log a, t - 1, \log z \cdot y - b\right)}}{y} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (* x (/ (exp (fma (log a) (- t 1.0) (- (* (log z) y) b))) y)))

C

double code(double x, double y, double z, double t, double a, double b) {
	return x * (exp(fma(log(a), (t - 1.0), ((log(z) * y) - b))) / y);
}

Julia

function code(x, y, z, t, a, b)
	return Float64(x * Float64(exp(fma(log(a), Float64(t - 1.0), Float64(Float64(log(z) * y) - b))) / y))
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := N[(x * N[(N[Exp[N[(N[Log[a], $MachinePrecision] * N[(t - 1.0), $MachinePrecision] + N[(N[(N[Log[z], $MachinePrecision] * y), $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	x * ((exp((((ln(a)) * (t - (1))) + (((ln(z)) * y) - b)))) / y)
END code

Derivation

1. Initial program 98.4%

   \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
2. Step-by-step derivation

3. Applied rewrites 98.5%

   \[\leadsto x \cdot \frac{e^{\mathsf{fma}\left(\log a, t - 1, \log z \cdot y - b\right)}}{y} \]
4. Add Preprocessing

Alternative 2: 93.1% accurate, 0.7× speedup

Math

\[\begin{array}{l} t_1 := \left(t - 1\right) \cdot \log a\\ \mathbf{if}\;t\_1 \leq -1 \cdot 10^{+56}:\\ \;\;\;\;\frac{x \cdot e^{t \cdot \log a - b}}{y}\\ \mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+57}:\\ \;\;\;\;\frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{x}{e^{\mathsf{fma}\left(1 - t, \log a, b\right)}}}{y}\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* (- t 1.0) (log a))))
  (if (<= t_1 -1e+56)
    (/ (* x (exp (- (* t (log a)) b))) y)
    (if (<= t_1 5e+57)
      (/ (* x (/ (exp (- (* y (log z)) b)) a)) y)
      (/ (/ x (exp (fma (- 1.0 t) (log a) b))) y)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - 1.0) * log(a);
	double tmp;
	if (t_1 <= -1e+56) {
		tmp = (x * exp(((t * log(a)) - b))) / y;
	} else if (t_1 <= 5e+57) {
		tmp = (x * (exp(((y * log(z)) - b)) / a)) / y;
	} else {
		tmp = (x / exp(fma((1.0 - t), log(a), b))) / y;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(t - 1.0) * log(a))
	tmp = 0.0
	if (t_1 <= -1e+56)
		tmp = Float64(Float64(x * exp(Float64(Float64(t * log(a)) - b))) / y);
	elseif (t_1 <= 5e+57)
		tmp = Float64(Float64(x * Float64(exp(Float64(Float64(y * log(z)) - b)) / a)) / y);
	else
		tmp = Float64(Float64(x / exp(fma(Float64(1.0 - t), log(a), b))) / y);
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - 1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -1e+56], N[(N[(x * N[Exp[N[(N[(t * N[Log[a], $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[t$95$1, 5e+57], N[(N[(x * N[(N[Exp[N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(N[(x / N[Exp[N[(N[(1.0 - t), $MachinePrecision] * N[Log[a], $MachinePrecision] + b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET t_1 = ((t - (1)) * (ln(a))) IN
		LET tmp_1 = IF (t_1 <= (4999999999999999719059744987206815407898577214256598482944)) THEN ((x * ((exp(((y * (ln(z))) - b))) / a)) / y) ELSE ((x / (exp(((((1) - t) * (ln(a))) + b)))) / y) ENDIF IN
		LET tmp = IF (t_1 <= (-100000000000000009190283508143378238084034459715684532224)) THEN ((x * (exp(((t * (ln(a))) - b)))) / y) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)) < -1.0000000000000001e56

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]

   2. Taylor expanded in y around 0

      \[\leadsto \frac{x \cdot e^{\log a \cdot \left(t - 1\right) - b}}{y} \]
   3. Step-by-step derivation

   4. Applied rewrites 80.4%

      \[\leadsto \frac{x \cdot e^{\log a \cdot \left(t - 1\right) - b}}{y} \]

   5. Taylor expanded in t around inf

      \[\leadsto \frac{x \cdot e^{t \cdot \log a - b}}{y} \]
   6. Step-by-step derivation

   7. Applied rewrites 72.1%

      \[\leadsto \frac{x \cdot e^{t \cdot \log a - b}}{y} \]

   if -1.0000000000000001e56 < (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)) < 4.9999999999999997e57

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \left(e^{\log z \cdot y - b} \cdot {a}^{\left(t - 1\right)}\right)}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.3%

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]

   if 4.9999999999999997e57 < (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 98.4%

      \[\leadsto \frac{\frac{x}{e^{\mathsf{fma}\left(1 - t, \log a, b - \log z \cdot y\right)}}}{y} \]

   4. Taylor expanded in y around 0

      \[\leadsto \frac{\frac{x}{e^{\mathsf{fma}\left(1 - t, \log a, b\right)}}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.4%

      \[\leadsto \frac{\frac{x}{e^{\mathsf{fma}\left(1 - t, \log a, b\right)}}}{y} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 3: 92.9% accurate, 0.7× speedup

Math

\[\begin{array}{l} t_1 := \left(t - 1\right) \cdot \log a\\ \mathbf{if}\;t\_1 \leq -1 \cdot 10^{+56}:\\ \;\;\;\;\frac{x \cdot e^{t \cdot \log a - b}}{y}\\ \mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+57}:\\ \;\;\;\;\frac{\frac{e^{\log z \cdot y - b} \cdot x}{y}}{a}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{x}{e^{\mathsf{fma}\left(1 - t, \log a, b\right)}}}{y}\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* (- t 1.0) (log a))))
  (if (<= t_1 -1e+56)
    (/ (* x (exp (- (* t (log a)) b))) y)
    (if (<= t_1 5e+57)
      (/ (/ (* (exp (- (* (log z) y) b)) x) y) a)
      (/ (/ x (exp (fma (- 1.0 t) (log a) b))) y)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - 1.0) * log(a);
	double tmp;
	if (t_1 <= -1e+56) {
		tmp = (x * exp(((t * log(a)) - b))) / y;
	} else if (t_1 <= 5e+57) {
		tmp = ((exp(((log(z) * y) - b)) * x) / y) / a;
	} else {
		tmp = (x / exp(fma((1.0 - t), log(a), b))) / y;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(t - 1.0) * log(a))
	tmp = 0.0
	if (t_1 <= -1e+56)
		tmp = Float64(Float64(x * exp(Float64(Float64(t * log(a)) - b))) / y);
	elseif (t_1 <= 5e+57)
		tmp = Float64(Float64(Float64(exp(Float64(Float64(log(z) * y) - b)) * x) / y) / a);
	else
		tmp = Float64(Float64(x / exp(fma(Float64(1.0 - t), log(a), b))) / y);
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - 1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -1e+56], N[(N[(x * N[Exp[N[(N[(t * N[Log[a], $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[t$95$1, 5e+57], N[(N[(N[(N[Exp[N[(N[(N[Log[z], $MachinePrecision] * y), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision] * x), $MachinePrecision] / y), $MachinePrecision] / a), $MachinePrecision], N[(N[(x / N[Exp[N[(N[(1.0 - t), $MachinePrecision] * N[Log[a], $MachinePrecision] + b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET t_1 = ((t - (1)) * (ln(a))) IN
		LET tmp_1 = IF (t_1 <= (4999999999999999719059744987206815407898577214256598482944)) THEN ((((exp((((ln(z)) * y) - b))) * x) / y) / a) ELSE ((x / (exp(((((1) - t) * (ln(a))) + b)))) / y) ENDIF IN
		LET tmp = IF (t_1 <= (-100000000000000009190283508143378238084034459715684532224)) THEN ((x * (exp(((t * (ln(a))) - b)))) / y) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)) < -1.0000000000000001e56

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]

   2. Taylor expanded in y around 0

      \[\leadsto \frac{x \cdot e^{\log a \cdot \left(t - 1\right) - b}}{y} \]
   3. Step-by-step derivation

   4. Applied rewrites 80.4%

      \[\leadsto \frac{x \cdot e^{\log a \cdot \left(t - 1\right) - b}}{y} \]

   5. Taylor expanded in t around inf

      \[\leadsto \frac{x \cdot e^{t \cdot \log a - b}}{y} \]
   6. Step-by-step derivation

   7. Applied rewrites 72.1%

      \[\leadsto \frac{x \cdot e^{t \cdot \log a - b}}{y} \]

   if -1.0000000000000001e56 < (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)) < 4.9999999999999997e57

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \frac{{a}^{\left(t - 1\right)}}{e^{b - \log z \cdot y}}}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b - y \cdot \log z}\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.5%

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b - y \cdot \log z}\right)} \]
   7. Step-by-step derivation

   8. Applied rewrites 80.4%

      \[\leadsto \frac{\frac{e^{\log z \cdot y - b} \cdot x}{y}}{a} \]

   if 4.9999999999999997e57 < (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 98.4%

      \[\leadsto \frac{\frac{x}{e^{\mathsf{fma}\left(1 - t, \log a, b - \log z \cdot y\right)}}}{y} \]

   4. Taylor expanded in y around 0

      \[\leadsto \frac{\frac{x}{e^{\mathsf{fma}\left(1 - t, \log a, b\right)}}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.4%

      \[\leadsto \frac{\frac{x}{e^{\mathsf{fma}\left(1 - t, \log a, b\right)}}}{y} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 4: 92.8% accurate, 0.7× speedup

Math

\[\begin{array}{l} t_1 := \left(t - 1\right) \cdot \log a\\ \mathbf{if}\;t\_1 \leq -1 \cdot 10^{+56}:\\ \;\;\;\;\frac{x \cdot e^{t \cdot \log a - b}}{y}\\ \mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+57}:\\ \;\;\;\;\frac{x}{a \cdot \left(y \cdot e^{b - y \cdot \log z}\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{x}{e^{\mathsf{fma}\left(1 - t, \log a, b\right)}}}{y}\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* (- t 1.0) (log a))))
  (if (<= t_1 -1e+56)
    (/ (* x (exp (- (* t (log a)) b))) y)
    (if (<= t_1 5e+57)
      (/ x (* a (* y (exp (- b (* y (log z)))))))
      (/ (/ x (exp (fma (- 1.0 t) (log a) b))) y)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - 1.0) * log(a);
	double tmp;
	if (t_1 <= -1e+56) {
		tmp = (x * exp(((t * log(a)) - b))) / y;
	} else if (t_1 <= 5e+57) {
		tmp = x / (a * (y * exp((b - (y * log(z))))));
	} else {
		tmp = (x / exp(fma((1.0 - t), log(a), b))) / y;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(t - 1.0) * log(a))
	tmp = 0.0
	if (t_1 <= -1e+56)
		tmp = Float64(Float64(x * exp(Float64(Float64(t * log(a)) - b))) / y);
	elseif (t_1 <= 5e+57)
		tmp = Float64(x / Float64(a * Float64(y * exp(Float64(b - Float64(y * log(z)))))));
	else
		tmp = Float64(Float64(x / exp(fma(Float64(1.0 - t), log(a), b))) / y);
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - 1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -1e+56], N[(N[(x * N[Exp[N[(N[(t * N[Log[a], $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[t$95$1, 5e+57], N[(x / N[(a * N[(y * N[Exp[N[(b - N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[Exp[N[(N[(1.0 - t), $MachinePrecision] * N[Log[a], $MachinePrecision] + b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET t_1 = ((t - (1)) * (ln(a))) IN
		LET tmp_1 = IF (t_1 <= (4999999999999999719059744987206815407898577214256598482944)) THEN (x / (a * (y * (exp((b - (y * (ln(z))))))))) ELSE ((x / (exp(((((1) - t) * (ln(a))) + b)))) / y) ENDIF IN
		LET tmp = IF (t_1 <= (-100000000000000009190283508143378238084034459715684532224)) THEN ((x * (exp(((t * (ln(a))) - b)))) / y) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)) < -1.0000000000000001e56

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]

   2. Taylor expanded in y around 0

      \[\leadsto \frac{x \cdot e^{\log a \cdot \left(t - 1\right) - b}}{y} \]
   3. Step-by-step derivation

   4. Applied rewrites 80.4%

      \[\leadsto \frac{x \cdot e^{\log a \cdot \left(t - 1\right) - b}}{y} \]

   5. Taylor expanded in t around inf

      \[\leadsto \frac{x \cdot e^{t \cdot \log a - b}}{y} \]
   6. Step-by-step derivation

   7. Applied rewrites 72.1%

      \[\leadsto \frac{x \cdot e^{t \cdot \log a - b}}{y} \]

   if -1.0000000000000001e56 < (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)) < 4.9999999999999997e57

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \frac{{a}^{\left(t - 1\right)}}{e^{b - \log z \cdot y}}}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b - y \cdot \log z}\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.5%

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b - y \cdot \log z}\right)} \]

   if 4.9999999999999997e57 < (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 98.4%

      \[\leadsto \frac{\frac{x}{e^{\mathsf{fma}\left(1 - t, \log a, b - \log z \cdot y\right)}}}{y} \]

   4. Taylor expanded in y around 0

      \[\leadsto \frac{\frac{x}{e^{\mathsf{fma}\left(1 - t, \log a, b\right)}}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.4%

      \[\leadsto \frac{\frac{x}{e^{\mathsf{fma}\left(1 - t, \log a, b\right)}}}{y} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 5: 89.1% accurate, 1.1× speedup

Math

\[\begin{array}{l} t_1 := \frac{x \cdot \frac{{z}^{y}}{a}}{y}\\ \mathbf{if}\;y \leq -4.487811470813542 \cdot 10^{+146}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq 1.0779890976478968 \cdot 10^{+162}:\\ \;\;\;\;\frac{x \cdot e^{\log a \cdot \left(t - 1\right) - b}}{y}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (/ (* x (/ (pow z y) a)) y)))
  (if (<= y -4.487811470813542e+146)
    t_1
    (if (<= y 1.0779890976478968e+162)
      (/ (* x (exp (- (* (log a) (- t 1.0)) b))) y)
      t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (x * (pow(z, y) / a)) / y;
	double tmp;
	if (y <= -4.487811470813542e+146) {
		tmp = t_1;
	} else if (y <= 1.0779890976478968e+162) {
		tmp = (x * exp(((log(a) * (t - 1.0)) - b))) / y;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (x * ((z ** y) / a)) / y
    if (y <= (-4.487811470813542d+146)) then
        tmp = t_1
    else if (y <= 1.0779890976478968d+162) then
        tmp = (x * exp(((log(a) * (t - 1.0d0)) - b))) / y
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (x * (Math.pow(z, y) / a)) / y;
	double tmp;
	if (y <= -4.487811470813542e+146) {
		tmp = t_1;
	} else if (y <= 1.0779890976478968e+162) {
		tmp = (x * Math.exp(((Math.log(a) * (t - 1.0)) - b))) / y;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (x * (math.pow(z, y) / a)) / y
	tmp = 0
	if y <= -4.487811470813542e+146:
		tmp = t_1
	elif y <= 1.0779890976478968e+162:
		tmp = (x * math.exp(((math.log(a) * (t - 1.0)) - b))) / y
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(x * Float64((z ^ y) / a)) / y)
	tmp = 0.0
	if (y <= -4.487811470813542e+146)
		tmp = t_1;
	elseif (y <= 1.0779890976478968e+162)
		tmp = Float64(Float64(x * exp(Float64(Float64(log(a) * Float64(t - 1.0)) - b))) / y);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (x * ((z ^ y) / a)) / y;
	tmp = 0.0;
	if (y <= -4.487811470813542e+146)
		tmp = t_1;
	elseif (y <= 1.0779890976478968e+162)
		tmp = (x * exp(((log(a) * (t - 1.0)) - b))) / y;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x * N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[y, -4.487811470813542e+146], t$95$1, If[LessEqual[y, 1.0779890976478968e+162], N[(N[(x * N[Exp[N[(N[(N[Log[a], $MachinePrecision] * N[(t - 1.0), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET t_1 = ((x * ((z ^ y) / a)) / y) IN
		LET tmp_1 = IF (y <= (1077989097647896777079402738292583920691169942549219420111086994846658051736791162600371757674678026858707816129526900044066191864320899463109251192133550312783872)) THEN ((x * (exp((((ln(a)) * (t - (1))) - b)))) / y) ELSE t_1 ENDIF IN
		LET tmp = IF (y <= (-448781147081354223026697127459097250404963656444554029782057104740369355593374070454682374646528601635034614882674924772152752888894906666554753024)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if y < -4.4878114708135422e146 or 1.0779890976478968e162 < y

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \left(e^{\log z \cdot y - b} \cdot {a}^{\left(t - 1\right)}\right)}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.3%

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]

   7. Taylor expanded in b around 0

      \[\leadsto \frac{x \cdot \frac{{z}^{y}}{a}}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 58.8%

      \[\leadsto \frac{x \cdot \frac{{z}^{y}}{a}}{y} \]

   if -4.4878114708135422e146 < y < 1.0779890976478968e162

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]

   2. Taylor expanded in y around 0

      \[\leadsto \frac{x \cdot e^{\log a \cdot \left(t - 1\right) - b}}{y} \]
   3. Step-by-step derivation

   4. Applied rewrites 80.4%

      \[\leadsto \frac{x \cdot e^{\log a \cdot \left(t - 1\right) - b}}{y} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 6: 89.1% accurate, 1.1× speedup

Math

\[\begin{array}{l} t_1 := \frac{x \cdot \frac{{z}^{y}}{a}}{y}\\ \mathbf{if}\;y \leq -4.487811470813542 \cdot 10^{+146}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq 1.0779890976478968 \cdot 10^{+162}:\\ \;\;\;\;\frac{x}{y \cdot e^{b + \log a \cdot \left(1 - t\right)}}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (/ (* x (/ (pow z y) a)) y)))
  (if (<= y -4.487811470813542e+146)
    t_1
    (if (<= y 1.0779890976478968e+162)
      (/ x (* y (exp (+ b (* (log a) (- 1.0 t))))))
      t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (x * (pow(z, y) / a)) / y;
	double tmp;
	if (y <= -4.487811470813542e+146) {
		tmp = t_1;
	} else if (y <= 1.0779890976478968e+162) {
		tmp = x / (y * exp((b + (log(a) * (1.0 - t)))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (x * ((z ** y) / a)) / y
    if (y <= (-4.487811470813542d+146)) then
        tmp = t_1
    else if (y <= 1.0779890976478968d+162) then
        tmp = x / (y * exp((b + (log(a) * (1.0d0 - t)))))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (x * (Math.pow(z, y) / a)) / y;
	double tmp;
	if (y <= -4.487811470813542e+146) {
		tmp = t_1;
	} else if (y <= 1.0779890976478968e+162) {
		tmp = x / (y * Math.exp((b + (Math.log(a) * (1.0 - t)))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (x * (math.pow(z, y) / a)) / y
	tmp = 0
	if y <= -4.487811470813542e+146:
		tmp = t_1
	elif y <= 1.0779890976478968e+162:
		tmp = x / (y * math.exp((b + (math.log(a) * (1.0 - t)))))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(x * Float64((z ^ y) / a)) / y)
	tmp = 0.0
	if (y <= -4.487811470813542e+146)
		tmp = t_1;
	elseif (y <= 1.0779890976478968e+162)
		tmp = Float64(x / Float64(y * exp(Float64(b + Float64(log(a) * Float64(1.0 - t))))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (x * ((z ^ y) / a)) / y;
	tmp = 0.0;
	if (y <= -4.487811470813542e+146)
		tmp = t_1;
	elseif (y <= 1.0779890976478968e+162)
		tmp = x / (y * exp((b + (log(a) * (1.0 - t)))));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x * N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[y, -4.487811470813542e+146], t$95$1, If[LessEqual[y, 1.0779890976478968e+162], N[(x / N[(y * N[Exp[N[(b + N[(N[Log[a], $MachinePrecision] * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET t_1 = ((x * ((z ^ y) / a)) / y) IN
		LET tmp_1 = IF (y <= (1077989097647896777079402738292583920691169942549219420111086994846658051736791162600371757674678026858707816129526900044066191864320899463109251192133550312783872)) THEN (x / (y * (exp((b + ((ln(a)) * ((1) - t))))))) ELSE t_1 ENDIF IN
		LET tmp = IF (y <= (-448781147081354223026697127459097250404963656444554029782057104740369355593374070454682374646528601635034614882674924772152752888894906666554753024)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if y < -4.4878114708135422e146 or 1.0779890976478968e162 < y

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \left(e^{\log z \cdot y - b} \cdot {a}^{\left(t - 1\right)}\right)}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.3%

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]

   7. Taylor expanded in b around 0

      \[\leadsto \frac{x \cdot \frac{{z}^{y}}{a}}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 58.8%

      \[\leadsto \frac{x \cdot \frac{{z}^{y}}{a}}{y} \]

   if -4.4878114708135422e146 < y < 1.0779890976478968e162

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 98.4%

      \[\leadsto \frac{\frac{x}{e^{\mathsf{fma}\left(1 - t, \log a, b - \log z \cdot y\right)}}}{y} \]

   4. Taylor expanded in y around 0

      \[\leadsto \frac{x}{y \cdot e^{b + \log a \cdot \left(1 - t\right)}} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.5%

      \[\leadsto \frac{x}{y \cdot e^{b + \log a \cdot \left(1 - t\right)}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 7: 80.9% accurate, 1.1× speedup

Math

\[\begin{array}{l} t_1 := \frac{x \cdot e^{t \cdot \log a - b}}{y}\\ \mathbf{if}\;t \leq -1.1376912938711205 \cdot 10^{-5}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 3.44694239537578 \cdot 10^{-110}:\\ \;\;\;\;\frac{x}{a \cdot \left(y \cdot e^{b}\right)}\\ \mathbf{elif}\;t \leq 37619.67410937715:\\ \;\;\;\;\frac{x \cdot \frac{{z}^{y}}{a}}{y}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (/ (* x (exp (- (* t (log a)) b))) y)))
  (if (<= t -1.1376912938711205e-5)
    t_1
    (if (<= t 3.44694239537578e-110)
      (/ x (* a (* y (exp b))))
      (if (<= t 37619.67410937715) (/ (* x (/ (pow z y) a)) y) t_1)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (x * exp(((t * log(a)) - b))) / y;
	double tmp;
	if (t <= -1.1376912938711205e-5) {
		tmp = t_1;
	} else if (t <= 3.44694239537578e-110) {
		tmp = x / (a * (y * exp(b)));
	} else if (t <= 37619.67410937715) {
		tmp = (x * (pow(z, y) / a)) / y;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (x * exp(((t * log(a)) - b))) / y
    if (t <= (-1.1376912938711205d-5)) then
        tmp = t_1
    else if (t <= 3.44694239537578d-110) then
        tmp = x / (a * (y * exp(b)))
    else if (t <= 37619.67410937715d0) then
        tmp = (x * ((z ** y) / a)) / y
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (x * Math.exp(((t * Math.log(a)) - b))) / y;
	double tmp;
	if (t <= -1.1376912938711205e-5) {
		tmp = t_1;
	} else if (t <= 3.44694239537578e-110) {
		tmp = x / (a * (y * Math.exp(b)));
	} else if (t <= 37619.67410937715) {
		tmp = (x * (Math.pow(z, y) / a)) / y;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (x * math.exp(((t * math.log(a)) - b))) / y
	tmp = 0
	if t <= -1.1376912938711205e-5:
		tmp = t_1
	elif t <= 3.44694239537578e-110:
		tmp = x / (a * (y * math.exp(b)))
	elif t <= 37619.67410937715:
		tmp = (x * (math.pow(z, y) / a)) / y
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(x * exp(Float64(Float64(t * log(a)) - b))) / y)
	tmp = 0.0
	if (t <= -1.1376912938711205e-5)
		tmp = t_1;
	elseif (t <= 3.44694239537578e-110)
		tmp = Float64(x / Float64(a * Float64(y * exp(b))));
	elseif (t <= 37619.67410937715)
		tmp = Float64(Float64(x * Float64((z ^ y) / a)) / y);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (x * exp(((t * log(a)) - b))) / y;
	tmp = 0.0;
	if (t <= -1.1376912938711205e-5)
		tmp = t_1;
	elseif (t <= 3.44694239537578e-110)
		tmp = x / (a * (y * exp(b)));
	elseif (t <= 37619.67410937715)
		tmp = (x * ((z ^ y) / a)) / y;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x * N[Exp[N[(N[(t * N[Log[a], $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[t, -1.1376912938711205e-5], t$95$1, If[LessEqual[t, 3.44694239537578e-110], N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 37619.67410937715], N[(N[(x * N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], t$95$1]]]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET t_1 = ((x * (exp(((t * (ln(a))) - b)))) / y) IN
		LET tmp_2 = IF (t <= (376196741093771488522179424762725830078125e-37)) THEN ((x * ((z ^ y) / a)) / y) ELSE t_1 ENDIF IN
		LET tmp_1 = IF (t <= (344694239537578005443002202313520006573815104706055640197992766291943956292339658349535828826763147068263861537106175790952351825967188628539480143482139572875498772320596267248505444043335197031090987872598511532333434837497436787577869733453947025547818691889657462257279263440068461932241916656494140625e-415)) THEN (x / (a * (y * (exp(b))))) ELSE tmp_2 ENDIF IN
		LET tmp = IF (t <= (-1137691293871120486159119467028943972763954661786556243896484375e-68)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if t < -1.1376912938711205e-5 or 37619.674109377149 < t

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]

   2. Taylor expanded in y around 0

      \[\leadsto \frac{x \cdot e^{\log a \cdot \left(t - 1\right) - b}}{y} \]
   3. Step-by-step derivation

   4. Applied rewrites 80.4%

      \[\leadsto \frac{x \cdot e^{\log a \cdot \left(t - 1\right) - b}}{y} \]

   5. Taylor expanded in t around inf

      \[\leadsto \frac{x \cdot e^{t \cdot \log a - b}}{y} \]
   6. Step-by-step derivation

   7. Applied rewrites 72.1%

      \[\leadsto \frac{x \cdot e^{t \cdot \log a - b}}{y} \]

   if -1.1376912938711205e-5 < t < 3.4469423953757801e-110

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \frac{{a}^{\left(t - 1\right)}}{e^{b - \log z \cdot y}}}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b - y \cdot \log z}\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.5%

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b - y \cdot \log z}\right)} \]

   7. Taylor expanded in y around 0

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b}\right)} \]
   8. Step-by-step derivation

   9. Applied rewrites 58.9%

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b}\right)} \]

   if 3.4469423953757801e-110 < t < 37619.674109377149

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \left(e^{\log z \cdot y - b} \cdot {a}^{\left(t - 1\right)}\right)}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.3%

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]

   7. Taylor expanded in b around 0

      \[\leadsto \frac{x \cdot \frac{{z}^{y}}{a}}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 58.8%

      \[\leadsto \frac{x \cdot \frac{{z}^{y}}{a}}{y} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 8: 74.5% accurate, 1.1× speedup

Math

\[\begin{array}{l} t_1 := \frac{x}{e^{-\log a \cdot t} \cdot y}\\ \mathbf{if}\;t \leq -9.35655120049614 \cdot 10^{+46}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 3.44694239537578 \cdot 10^{-110}:\\ \;\;\;\;\frac{x}{a \cdot \left(y \cdot e^{b}\right)}\\ \mathbf{elif}\;t \leq 4.137731671845732 \cdot 10^{+55}:\\ \;\;\;\;\frac{x \cdot \frac{{z}^{y}}{a}}{y}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (/ x (* (exp (- (* (log a) t))) y))))
  (if (<= t -9.35655120049614e+46)
    t_1
    (if (<= t 3.44694239537578e-110)
      (/ x (* a (* y (exp b))))
      (if (<= t 4.137731671845732e+55)
        (/ (* x (/ (pow z y) a)) y)
        t_1)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x / (exp(-(log(a) * t)) * y);
	double tmp;
	if (t <= -9.35655120049614e+46) {
		tmp = t_1;
	} else if (t <= 3.44694239537578e-110) {
		tmp = x / (a * (y * exp(b)));
	} else if (t <= 4.137731671845732e+55) {
		tmp = (x * (pow(z, y) / a)) / y;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = x / (exp(-(log(a) * t)) * y)
    if (t <= (-9.35655120049614d+46)) then
        tmp = t_1
    else if (t <= 3.44694239537578d-110) then
        tmp = x / (a * (y * exp(b)))
    else if (t <= 4.137731671845732d+55) then
        tmp = (x * ((z ** y) / a)) / y
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x / (Math.exp(-(Math.log(a) * t)) * y);
	double tmp;
	if (t <= -9.35655120049614e+46) {
		tmp = t_1;
	} else if (t <= 3.44694239537578e-110) {
		tmp = x / (a * (y * Math.exp(b)));
	} else if (t <= 4.137731671845732e+55) {
		tmp = (x * (Math.pow(z, y) / a)) / y;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x / (math.exp(-(math.log(a) * t)) * y)
	tmp = 0
	if t <= -9.35655120049614e+46:
		tmp = t_1
	elif t <= 3.44694239537578e-110:
		tmp = x / (a * (y * math.exp(b)))
	elif t <= 4.137731671845732e+55:
		tmp = (x * (math.pow(z, y) / a)) / y
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x / Float64(exp(Float64(-Float64(log(a) * t))) * y))
	tmp = 0.0
	if (t <= -9.35655120049614e+46)
		tmp = t_1;
	elseif (t <= 3.44694239537578e-110)
		tmp = Float64(x / Float64(a * Float64(y * exp(b))));
	elseif (t <= 4.137731671845732e+55)
		tmp = Float64(Float64(x * Float64((z ^ y) / a)) / y);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x / (exp(-(log(a) * t)) * y);
	tmp = 0.0;
	if (t <= -9.35655120049614e+46)
		tmp = t_1;
	elseif (t <= 3.44694239537578e-110)
		tmp = x / (a * (y * exp(b)));
	elseif (t <= 4.137731671845732e+55)
		tmp = (x * ((z ^ y) / a)) / y;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(N[Exp[(-N[(N[Log[a], $MachinePrecision] * t), $MachinePrecision])], $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -9.35655120049614e+46], t$95$1, If[LessEqual[t, 3.44694239537578e-110], N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 4.137731671845732e+55], N[(N[(x * N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], t$95$1]]]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET t_1 = (x / ((exp((- ((ln(a)) * t)))) * y)) IN
		LET tmp_2 = IF (t <= (41377316718457317424917093860443300082961675575644651520)) THEN ((x * ((z ^ y) / a)) / y) ELSE t_1 ENDIF IN
		LET tmp_1 = IF (t <= (344694239537578005443002202313520006573815104706055640197992766291943956292339658349535828826763147068263861537106175790952351825967188628539480143482139572875498772320596267248505444043335197031090987872598511532333434837497436787577869733453947025547818691889657462257279263440068461932241916656494140625e-415)) THEN (x / (a * (y * (exp(b))))) ELSE tmp_2 ENDIF IN
		LET tmp = IF (t <= (-93565512004961398445155192925373820466989367296)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if t < -9.3565512004961398e46 or 4.1377316718457317e55 < t

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 98.4%

      \[\leadsto \frac{\frac{x}{e^{\mathsf{fma}\left(1 - t, \log a, b - \log z \cdot y\right)}}}{y} \]

   4. Taylor expanded in t around inf

      \[\leadsto \frac{\frac{x}{e^{-1 \cdot \left(t \cdot \log a\right)}}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 48.3%

      \[\leadsto \frac{\frac{x}{e^{-1 \cdot \left(t \cdot \log a\right)}}}{y} \]
   7. Step-by-step derivation

   8. Applied rewrites 48.3%

      \[\leadsto \frac{x}{e^{-\log a \cdot t} \cdot y} \]

   if -9.3565512004961398e46 < t < 3.4469423953757801e-110

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \frac{{a}^{\left(t - 1\right)}}{e^{b - \log z \cdot y}}}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b - y \cdot \log z}\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.5%

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b - y \cdot \log z}\right)} \]

   7. Taylor expanded in y around 0

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b}\right)} \]
   8. Step-by-step derivation

   9. Applied rewrites 58.9%

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b}\right)} \]

   if 3.4469423953757801e-110 < t < 4.1377316718457317e55

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \left(e^{\log z \cdot y - b} \cdot {a}^{\left(t - 1\right)}\right)}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.3%

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]

   7. Taylor expanded in b around 0

      \[\leadsto \frac{x \cdot \frac{{z}^{y}}{a}}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 58.8%

      \[\leadsto \frac{x \cdot \frac{{z}^{y}}{a}}{y} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 9: 73.7% accurate, 0.4× speedup

Math

\[\begin{array}{l} t_1 := e^{-b}\\ t_2 := \frac{\left|x\right| \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y}\\ \mathsf{copysign}\left(1, x\right) \cdot \begin{array}{l} \mathbf{if}\;t\_2 \leq -4 \cdot 10^{-118}:\\ \;\;\;\;\frac{\left|x\right| \cdot \frac{{z}^{y}}{a}}{y}\\ \mathbf{elif}\;t\_2 \leq 0:\\ \;\;\;\;\frac{t\_1 \cdot 0}{y}\\ \mathbf{else}:\\ \;\;\;\;\frac{\left|x\right| \cdot \frac{t\_1}{a}}{y}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (exp (- b)))
       (t_2
        (/
         (*
          (fabs x)
          (exp (- (+ (* y (log z)) (* (- t 1.0) (log a))) b)))
         y)))
  (*
   (copysign 1.0 x)
   (if (<= t_2 -4e-118)
     (/ (* (fabs x) (/ (pow z y) a)) y)
     (if (<= t_2 0.0)
       (/ (* t_1 0.0) y)
       (/ (* (fabs x) (/ t_1 a)) y))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = exp(-b);
	double t_2 = (fabs(x) * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
	double tmp;
	if (t_2 <= -4e-118) {
		tmp = (fabs(x) * (pow(z, y) / a)) / y;
	} else if (t_2 <= 0.0) {
		tmp = (t_1 * 0.0) / y;
	} else {
		tmp = (fabs(x) * (t_1 / a)) / y;
	}
	return copysign(1.0, x) * tmp;
}

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = Math.exp(-b);
	double t_2 = (Math.abs(x) * Math.exp((((y * Math.log(z)) + ((t - 1.0) * Math.log(a))) - b))) / y;
	double tmp;
	if (t_2 <= -4e-118) {
		tmp = (Math.abs(x) * (Math.pow(z, y) / a)) / y;
	} else if (t_2 <= 0.0) {
		tmp = (t_1 * 0.0) / y;
	} else {
		tmp = (Math.abs(x) * (t_1 / a)) / y;
	}
	return Math.copySign(1.0, x) * tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = math.exp(-b)
	t_2 = (math.fabs(x) * math.exp((((y * math.log(z)) + ((t - 1.0) * math.log(a))) - b))) / y
	tmp = 0
	if t_2 <= -4e-118:
		tmp = (math.fabs(x) * (math.pow(z, y) / a)) / y
	elif t_2 <= 0.0:
		tmp = (t_1 * 0.0) / y
	else:
		tmp = (math.fabs(x) * (t_1 / a)) / y
	return math.copysign(1.0, x) * tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = exp(Float64(-b))
	t_2 = Float64(Float64(abs(x) * exp(Float64(Float64(Float64(y * log(z)) + Float64(Float64(t - 1.0) * log(a))) - b))) / y)
	tmp = 0.0
	if (t_2 <= -4e-118)
		tmp = Float64(Float64(abs(x) * Float64((z ^ y) / a)) / y);
	elseif (t_2 <= 0.0)
		tmp = Float64(Float64(t_1 * 0.0) / y);
	else
		tmp = Float64(Float64(abs(x) * Float64(t_1 / a)) / y);
	end
	return Float64(copysign(1.0, x) * tmp)
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = exp(-b);
	t_2 = (abs(x) * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
	tmp = 0.0;
	if (t_2 <= -4e-118)
		tmp = (abs(x) * ((z ^ y) / a)) / y;
	elseif (t_2 <= 0.0)
		tmp = (t_1 * 0.0) / y;
	else
		tmp = (abs(x) * (t_1 / a)) / y;
	end
	tmp_2 = (sign(x) * abs(1.0)) * tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[Exp[(-b)], $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[Abs[x], $MachinePrecision] * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] + N[(N[(t - 1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$2, -4e-118], N[(N[(N[Abs[x], $MachinePrecision] * N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[t$95$2, 0.0], N[(N[(t$95$1 * 0.0), $MachinePrecision] / y), $MachinePrecision], N[(N[(N[Abs[x], $MachinePrecision] * N[(t$95$1 / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if (/.f64 (*.f64 x (exp.f64 (-.f64 (+.f64 (*.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y) < -3.9999999999999999e-118

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \left(e^{\log z \cdot y - b} \cdot {a}^{\left(t - 1\right)}\right)}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.3%

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]

   7. Taylor expanded in b around 0

      \[\leadsto \frac{x \cdot \frac{{z}^{y}}{a}}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 58.8%

      \[\leadsto \frac{x \cdot \frac{{z}^{y}}{a}}{y} \]

   if -3.9999999999999999e-118 < (/.f64 (*.f64 x (exp.f64 (-.f64 (+.f64 (*.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y) < -0.0

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]

   2. Taylor expanded in b around inf

      \[\leadsto \frac{x \cdot e^{-1 \cdot b}}{y} \]
   3. Step-by-step derivation

   4. Applied rewrites 48.3%

      \[\leadsto \frac{x \cdot e^{-1 \cdot b}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 48.3%

      \[\leadsto \frac{e^{-b} \cdot x}{y} \]

   7. Taylor expanded in undef-var around zero

      \[\leadsto \frac{e^{-b} \cdot 0}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 40.0%

      \[\leadsto \frac{e^{-b} \cdot 0}{y} \]

   if -0.0 < (/.f64 (*.f64 x (exp.f64 (-.f64 (+.f64 (*.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y)

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \left(e^{\log z \cdot y - b} \cdot {a}^{\left(t - 1\right)}\right)}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.3%

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]

   7. Taylor expanded in y around 0

      \[\leadsto \frac{x \cdot \frac{e^{\mathsf{neg}\left(b\right)}}{a}}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 58.5%

      \[\leadsto \frac{x \cdot \frac{e^{-b}}{a}}{y} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 10: 71.8% accurate, 0.4× speedup

Math

\[\begin{array}{l} t_1 := e^{-b}\\ t_2 := \frac{\left|x\right| \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y}\\ \mathsf{copysign}\left(1, x\right) \cdot \begin{array}{l} \mathbf{if}\;t\_2 \leq -4 \cdot 10^{-118}:\\ \;\;\;\;\frac{\left|x\right| \cdot \frac{1 + b \cdot \left(0.5 \cdot b - 1\right)}{a}}{y}\\ \mathbf{elif}\;t\_2 \leq 0:\\ \;\;\;\;\frac{t\_1 \cdot 0}{y}\\ \mathbf{else}:\\ \;\;\;\;\frac{\left|x\right| \cdot \frac{t\_1}{a}}{y}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (exp (- b)))
       (t_2
        (/
         (*
          (fabs x)
          (exp (- (+ (* y (log z)) (* (- t 1.0) (log a))) b)))
         y)))
  (*
   (copysign 1.0 x)
   (if (<= t_2 -4e-118)
     (/ (* (fabs x) (/ (+ 1.0 (* b (- (* 0.5 b) 1.0))) a)) y)
     (if (<= t_2 0.0)
       (/ (* t_1 0.0) y)
       (/ (* (fabs x) (/ t_1 a)) y))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = exp(-b);
	double t_2 = (fabs(x) * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
	double tmp;
	if (t_2 <= -4e-118) {
		tmp = (fabs(x) * ((1.0 + (b * ((0.5 * b) - 1.0))) / a)) / y;
	} else if (t_2 <= 0.0) {
		tmp = (t_1 * 0.0) / y;
	} else {
		tmp = (fabs(x) * (t_1 / a)) / y;
	}
	return copysign(1.0, x) * tmp;
}

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = Math.exp(-b);
	double t_2 = (Math.abs(x) * Math.exp((((y * Math.log(z)) + ((t - 1.0) * Math.log(a))) - b))) / y;
	double tmp;
	if (t_2 <= -4e-118) {
		tmp = (Math.abs(x) * ((1.0 + (b * ((0.5 * b) - 1.0))) / a)) / y;
	} else if (t_2 <= 0.0) {
		tmp = (t_1 * 0.0) / y;
	} else {
		tmp = (Math.abs(x) * (t_1 / a)) / y;
	}
	return Math.copySign(1.0, x) * tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = math.exp(-b)
	t_2 = (math.fabs(x) * math.exp((((y * math.log(z)) + ((t - 1.0) * math.log(a))) - b))) / y
	tmp = 0
	if t_2 <= -4e-118:
		tmp = (math.fabs(x) * ((1.0 + (b * ((0.5 * b) - 1.0))) / a)) / y
	elif t_2 <= 0.0:
		tmp = (t_1 * 0.0) / y
	else:
		tmp = (math.fabs(x) * (t_1 / a)) / y
	return math.copysign(1.0, x) * tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = exp(Float64(-b))
	t_2 = Float64(Float64(abs(x) * exp(Float64(Float64(Float64(y * log(z)) + Float64(Float64(t - 1.0) * log(a))) - b))) / y)
	tmp = 0.0
	if (t_2 <= -4e-118)
		tmp = Float64(Float64(abs(x) * Float64(Float64(1.0 + Float64(b * Float64(Float64(0.5 * b) - 1.0))) / a)) / y);
	elseif (t_2 <= 0.0)
		tmp = Float64(Float64(t_1 * 0.0) / y);
	else
		tmp = Float64(Float64(abs(x) * Float64(t_1 / a)) / y);
	end
	return Float64(copysign(1.0, x) * tmp)
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = exp(-b);
	t_2 = (abs(x) * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
	tmp = 0.0;
	if (t_2 <= -4e-118)
		tmp = (abs(x) * ((1.0 + (b * ((0.5 * b) - 1.0))) / a)) / y;
	elseif (t_2 <= 0.0)
		tmp = (t_1 * 0.0) / y;
	else
		tmp = (abs(x) * (t_1 / a)) / y;
	end
	tmp_2 = (sign(x) * abs(1.0)) * tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[Exp[(-b)], $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[Abs[x], $MachinePrecision] * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] + N[(N[(t - 1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$2, -4e-118], N[(N[(N[Abs[x], $MachinePrecision] * N[(N[(1.0 + N[(b * N[(N[(0.5 * b), $MachinePrecision] - 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[t$95$2, 0.0], N[(N[(t$95$1 * 0.0), $MachinePrecision] / y), $MachinePrecision], N[(N[(N[Abs[x], $MachinePrecision] * N[(t$95$1 / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if (/.f64 (*.f64 x (exp.f64 (-.f64 (+.f64 (*.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y) < -3.9999999999999999e-118

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \left(e^{\log z \cdot y - b} \cdot {a}^{\left(t - 1\right)}\right)}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.3%

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]

   7. Taylor expanded in y around 0

      \[\leadsto \frac{x \cdot \frac{e^{\mathsf{neg}\left(b\right)}}{a}}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 58.5%

      \[\leadsto \frac{x \cdot \frac{e^{-b}}{a}}{y} \]

   10. Taylor expanded in b around 0

       \[\leadsto \frac{x \cdot \frac{1 + b \cdot \left(\frac{1}{2} \cdot b - 1\right)}{a}}{y} \]
   11. Step-by-step derivation

   12. Applied rewrites 38.9%

       \[\leadsto \frac{x \cdot \frac{1 + b \cdot \left(0.5 \cdot b - 1\right)}{a}}{y} \]

   if -3.9999999999999999e-118 < (/.f64 (*.f64 x (exp.f64 (-.f64 (+.f64 (*.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y) < -0.0

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]

   2. Taylor expanded in b around inf

      \[\leadsto \frac{x \cdot e^{-1 \cdot b}}{y} \]
   3. Step-by-step derivation

   4. Applied rewrites 48.3%

      \[\leadsto \frac{x \cdot e^{-1 \cdot b}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 48.3%

      \[\leadsto \frac{e^{-b} \cdot x}{y} \]

   7. Taylor expanded in undef-var around zero

      \[\leadsto \frac{e^{-b} \cdot 0}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 40.0%

      \[\leadsto \frac{e^{-b} \cdot 0}{y} \]

   if -0.0 < (/.f64 (*.f64 x (exp.f64 (-.f64 (+.f64 (*.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y)

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \left(e^{\log z \cdot y - b} \cdot {a}^{\left(t - 1\right)}\right)}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.3%

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]

   7. Taylor expanded in y around 0

      \[\leadsto \frac{x \cdot \frac{e^{\mathsf{neg}\left(b\right)}}{a}}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 58.5%

      \[\leadsto \frac{x \cdot \frac{e^{-b}}{a}}{y} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 11: 71.2% accurate, 0.4× speedup

Math

\[\begin{array}{l} t_1 := \frac{\left|x\right| \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y}\\ \mathsf{copysign}\left(1, x\right) \cdot \begin{array}{l} \mathbf{if}\;t\_1 \leq -4 \cdot 10^{-118}:\\ \;\;\;\;\frac{\left|x\right| \cdot \frac{1 + b \cdot \left(0.5 \cdot b - 1\right)}{a}}{y}\\ \mathbf{elif}\;t\_1 \leq 0:\\ \;\;\;\;\frac{e^{-b} \cdot 0}{y}\\ \mathbf{else}:\\ \;\;\;\;\frac{\left|x\right|}{a \cdot \left(y \cdot e^{b}\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1
        (/
         (*
          (fabs x)
          (exp (- (+ (* y (log z)) (* (- t 1.0) (log a))) b)))
         y)))
  (*
   (copysign 1.0 x)
   (if (<= t_1 -4e-118)
     (/ (* (fabs x) (/ (+ 1.0 (* b (- (* 0.5 b) 1.0))) a)) y)
     (if (<= t_1 0.0)
       (/ (* (exp (- b)) 0.0) y)
       (/ (fabs x) (* a (* y (exp b)))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (fabs(x) * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
	double tmp;
	if (t_1 <= -4e-118) {
		tmp = (fabs(x) * ((1.0 + (b * ((0.5 * b) - 1.0))) / a)) / y;
	} else if (t_1 <= 0.0) {
		tmp = (exp(-b) * 0.0) / y;
	} else {
		tmp = fabs(x) / (a * (y * exp(b)));
	}
	return copysign(1.0, x) * tmp;
}

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (Math.abs(x) * Math.exp((((y * Math.log(z)) + ((t - 1.0) * Math.log(a))) - b))) / y;
	double tmp;
	if (t_1 <= -4e-118) {
		tmp = (Math.abs(x) * ((1.0 + (b * ((0.5 * b) - 1.0))) / a)) / y;
	} else if (t_1 <= 0.0) {
		tmp = (Math.exp(-b) * 0.0) / y;
	} else {
		tmp = Math.abs(x) / (a * (y * Math.exp(b)));
	}
	return Math.copySign(1.0, x) * tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (math.fabs(x) * math.exp((((y * math.log(z)) + ((t - 1.0) * math.log(a))) - b))) / y
	tmp = 0
	if t_1 <= -4e-118:
		tmp = (math.fabs(x) * ((1.0 + (b * ((0.5 * b) - 1.0))) / a)) / y
	elif t_1 <= 0.0:
		tmp = (math.exp(-b) * 0.0) / y
	else:
		tmp = math.fabs(x) / (a * (y * math.exp(b)))
	return math.copysign(1.0, x) * tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(abs(x) * exp(Float64(Float64(Float64(y * log(z)) + Float64(Float64(t - 1.0) * log(a))) - b))) / y)
	tmp = 0.0
	if (t_1 <= -4e-118)
		tmp = Float64(Float64(abs(x) * Float64(Float64(1.0 + Float64(b * Float64(Float64(0.5 * b) - 1.0))) / a)) / y);
	elseif (t_1 <= 0.0)
		tmp = Float64(Float64(exp(Float64(-b)) * 0.0) / y);
	else
		tmp = Float64(abs(x) / Float64(a * Float64(y * exp(b))));
	end
	return Float64(copysign(1.0, x) * tmp)
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (abs(x) * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
	tmp = 0.0;
	if (t_1 <= -4e-118)
		tmp = (abs(x) * ((1.0 + (b * ((0.5 * b) - 1.0))) / a)) / y;
	elseif (t_1 <= 0.0)
		tmp = (exp(-b) * 0.0) / y;
	else
		tmp = abs(x) / (a * (y * exp(b)));
	end
	tmp_2 = (sign(x) * abs(1.0)) * tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[Abs[x], $MachinePrecision] * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] + N[(N[(t - 1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$1, -4e-118], N[(N[(N[Abs[x], $MachinePrecision] * N[(N[(1.0 + N[(b * N[(N[(0.5 * b), $MachinePrecision] - 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[t$95$1, 0.0], N[(N[(N[Exp[(-b)], $MachinePrecision] * 0.0), $MachinePrecision] / y), $MachinePrecision], N[(N[Abs[x], $MachinePrecision] / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]

Derivation

1. Split input into 3 regimes

2. if (/.f64 (*.f64 x (exp.f64 (-.f64 (+.f64 (*.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y) < -3.9999999999999999e-118

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \left(e^{\log z \cdot y - b} \cdot {a}^{\left(t - 1\right)}\right)}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.3%

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]

   7. Taylor expanded in y around 0

      \[\leadsto \frac{x \cdot \frac{e^{\mathsf{neg}\left(b\right)}}{a}}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 58.5%

      \[\leadsto \frac{x \cdot \frac{e^{-b}}{a}}{y} \]

   10. Taylor expanded in b around 0

       \[\leadsto \frac{x \cdot \frac{1 + b \cdot \left(\frac{1}{2} \cdot b - 1\right)}{a}}{y} \]
   11. Step-by-step derivation

   12. Applied rewrites 38.9%

       \[\leadsto \frac{x \cdot \frac{1 + b \cdot \left(0.5 \cdot b - 1\right)}{a}}{y} \]

   if -3.9999999999999999e-118 < (/.f64 (*.f64 x (exp.f64 (-.f64 (+.f64 (*.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y) < -0.0

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]

   2. Taylor expanded in b around inf

      \[\leadsto \frac{x \cdot e^{-1 \cdot b}}{y} \]
   3. Step-by-step derivation

   4. Applied rewrites 48.3%

      \[\leadsto \frac{x \cdot e^{-1 \cdot b}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 48.3%

      \[\leadsto \frac{e^{-b} \cdot x}{y} \]

   7. Taylor expanded in undef-var around zero

      \[\leadsto \frac{e^{-b} \cdot 0}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 40.0%

      \[\leadsto \frac{e^{-b} \cdot 0}{y} \]

   if -0.0 < (/.f64 (*.f64 x (exp.f64 (-.f64 (+.f64 (*.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y)

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \frac{{a}^{\left(t - 1\right)}}{e^{b - \log z \cdot y}}}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b - y \cdot \log z}\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.5%

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b - y \cdot \log z}\right)} \]

   7. Taylor expanded in y around 0

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b}\right)} \]
   8. Step-by-step derivation

   9. Applied rewrites 58.9%

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b}\right)} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 12: 71.2% accurate, 0.4× speedup

Math

\[\begin{array}{l} t_1 := \frac{\left|x\right| \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y}\\ \mathsf{copysign}\left(1, x\right) \cdot \begin{array}{l} \mathbf{if}\;t\_1 \leq -4 \cdot 10^{-118}:\\ \;\;\;\;\frac{\frac{\left|x\right|}{e^{b} \cdot y}}{a}\\ \mathbf{elif}\;t\_1 \leq 0:\\ \;\;\;\;\frac{e^{-b} \cdot 0}{y}\\ \mathbf{else}:\\ \;\;\;\;\frac{\left|x\right|}{a \cdot \left(y \cdot e^{b}\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1
        (/
         (*
          (fabs x)
          (exp (- (+ (* y (log z)) (* (- t 1.0) (log a))) b)))
         y)))
  (*
   (copysign 1.0 x)
   (if (<= t_1 -4e-118)
     (/ (/ (fabs x) (* (exp b) y)) a)
     (if (<= t_1 0.0)
       (/ (* (exp (- b)) 0.0) y)
       (/ (fabs x) (* a (* y (exp b)))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (fabs(x) * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
	double tmp;
	if (t_1 <= -4e-118) {
		tmp = (fabs(x) / (exp(b) * y)) / a;
	} else if (t_1 <= 0.0) {
		tmp = (exp(-b) * 0.0) / y;
	} else {
		tmp = fabs(x) / (a * (y * exp(b)));
	}
	return copysign(1.0, x) * tmp;
}

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (Math.abs(x) * Math.exp((((y * Math.log(z)) + ((t - 1.0) * Math.log(a))) - b))) / y;
	double tmp;
	if (t_1 <= -4e-118) {
		tmp = (Math.abs(x) / (Math.exp(b) * y)) / a;
	} else if (t_1 <= 0.0) {
		tmp = (Math.exp(-b) * 0.0) / y;
	} else {
		tmp = Math.abs(x) / (a * (y * Math.exp(b)));
	}
	return Math.copySign(1.0, x) * tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (math.fabs(x) * math.exp((((y * math.log(z)) + ((t - 1.0) * math.log(a))) - b))) / y
	tmp = 0
	if t_1 <= -4e-118:
		tmp = (math.fabs(x) / (math.exp(b) * y)) / a
	elif t_1 <= 0.0:
		tmp = (math.exp(-b) * 0.0) / y
	else:
		tmp = math.fabs(x) / (a * (y * math.exp(b)))
	return math.copysign(1.0, x) * tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(abs(x) * exp(Float64(Float64(Float64(y * log(z)) + Float64(Float64(t - 1.0) * log(a))) - b))) / y)
	tmp = 0.0
	if (t_1 <= -4e-118)
		tmp = Float64(Float64(abs(x) / Float64(exp(b) * y)) / a);
	elseif (t_1 <= 0.0)
		tmp = Float64(Float64(exp(Float64(-b)) * 0.0) / y);
	else
		tmp = Float64(abs(x) / Float64(a * Float64(y * exp(b))));
	end
	return Float64(copysign(1.0, x) * tmp)
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (abs(x) * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
	tmp = 0.0;
	if (t_1 <= -4e-118)
		tmp = (abs(x) / (exp(b) * y)) / a;
	elseif (t_1 <= 0.0)
		tmp = (exp(-b) * 0.0) / y;
	else
		tmp = abs(x) / (a * (y * exp(b)));
	end
	tmp_2 = (sign(x) * abs(1.0)) * tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[Abs[x], $MachinePrecision] * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] + N[(N[(t - 1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$1, -4e-118], N[(N[(N[Abs[x], $MachinePrecision] / N[(N[Exp[b], $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[t$95$1, 0.0], N[(N[(N[Exp[(-b)], $MachinePrecision] * 0.0), $MachinePrecision] / y), $MachinePrecision], N[(N[Abs[x], $MachinePrecision] / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]

Derivation

1. Split input into 3 regimes

2. if (/.f64 (*.f64 x (exp.f64 (-.f64 (+.f64 (*.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y) < -3.9999999999999999e-118

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \frac{{a}^{\left(t - 1\right)}}{e^{b - \log z \cdot y}}}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b - y \cdot \log z}\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.5%

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b - y \cdot \log z}\right)} \]

   7. Taylor expanded in y around 0

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b}\right)} \]
   8. Step-by-step derivation

   9. Applied rewrites 58.9%

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b}\right)} \]
   10. Step-by-step derivation

   11. Applied rewrites 58.7%

       \[\leadsto \frac{\frac{x}{e^{b} \cdot y}}{a} \]

   if -3.9999999999999999e-118 < (/.f64 (*.f64 x (exp.f64 (-.f64 (+.f64 (*.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y) < -0.0

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]

   2. Taylor expanded in b around inf

      \[\leadsto \frac{x \cdot e^{-1 \cdot b}}{y} \]
   3. Step-by-step derivation

   4. Applied rewrites 48.3%

      \[\leadsto \frac{x \cdot e^{-1 \cdot b}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 48.3%

      \[\leadsto \frac{e^{-b} \cdot x}{y} \]

   7. Taylor expanded in undef-var around zero

      \[\leadsto \frac{e^{-b} \cdot 0}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 40.0%

      \[\leadsto \frac{e^{-b} \cdot 0}{y} \]

   if -0.0 < (/.f64 (*.f64 x (exp.f64 (-.f64 (+.f64 (*.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y)

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \frac{{a}^{\left(t - 1\right)}}{e^{b - \log z \cdot y}}}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b - y \cdot \log z}\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.5%

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b - y \cdot \log z}\right)} \]

   7. Taylor expanded in y around 0

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b}\right)} \]
   8. Step-by-step derivation

   9. Applied rewrites 58.9%

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b}\right)} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 13: 71.1% accurate, 0.4× speedup

Math

\[\begin{array}{l} t_1 := \frac{\left|x\right| \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y}\\ t_2 := \frac{\left|x\right|}{a \cdot \left(y \cdot e^{b}\right)}\\ \mathsf{copysign}\left(1, x\right) \cdot \begin{array}{l} \mathbf{if}\;t\_1 \leq -4 \cdot 10^{-118}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t\_1 \leq 0:\\ \;\;\;\;\frac{e^{-b} \cdot 0}{y}\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1
        (/
         (*
          (fabs x)
          (exp (- (+ (* y (log z)) (* (- t 1.0) (log a))) b)))
         y))
       (t_2 (/ (fabs x) (* a (* y (exp b))))))
  (*
   (copysign 1.0 x)
   (if (<= t_1 -4e-118)
     t_2
     (if (<= t_1 0.0) (/ (* (exp (- b)) 0.0) y) t_2)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (fabs(x) * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
	double t_2 = fabs(x) / (a * (y * exp(b)));
	double tmp;
	if (t_1 <= -4e-118) {
		tmp = t_2;
	} else if (t_1 <= 0.0) {
		tmp = (exp(-b) * 0.0) / y;
	} else {
		tmp = t_2;
	}
	return copysign(1.0, x) * tmp;
}

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (Math.abs(x) * Math.exp((((y * Math.log(z)) + ((t - 1.0) * Math.log(a))) - b))) / y;
	double t_2 = Math.abs(x) / (a * (y * Math.exp(b)));
	double tmp;
	if (t_1 <= -4e-118) {
		tmp = t_2;
	} else if (t_1 <= 0.0) {
		tmp = (Math.exp(-b) * 0.0) / y;
	} else {
		tmp = t_2;
	}
	return Math.copySign(1.0, x) * tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (math.fabs(x) * math.exp((((y * math.log(z)) + ((t - 1.0) * math.log(a))) - b))) / y
	t_2 = math.fabs(x) / (a * (y * math.exp(b)))
	tmp = 0
	if t_1 <= -4e-118:
		tmp = t_2
	elif t_1 <= 0.0:
		tmp = (math.exp(-b) * 0.0) / y
	else:
		tmp = t_2
	return math.copysign(1.0, x) * tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(abs(x) * exp(Float64(Float64(Float64(y * log(z)) + Float64(Float64(t - 1.0) * log(a))) - b))) / y)
	t_2 = Float64(abs(x) / Float64(a * Float64(y * exp(b))))
	tmp = 0.0
	if (t_1 <= -4e-118)
		tmp = t_2;
	elseif (t_1 <= 0.0)
		tmp = Float64(Float64(exp(Float64(-b)) * 0.0) / y);
	else
		tmp = t_2;
	end
	return Float64(copysign(1.0, x) * tmp)
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (abs(x) * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
	t_2 = abs(x) / (a * (y * exp(b)));
	tmp = 0.0;
	if (t_1 <= -4e-118)
		tmp = t_2;
	elseif (t_1 <= 0.0)
		tmp = (exp(-b) * 0.0) / y;
	else
		tmp = t_2;
	end
	tmp_2 = (sign(x) * abs(1.0)) * tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[Abs[x], $MachinePrecision] * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] + N[(N[(t - 1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, Block[{t$95$2 = N[(N[Abs[x], $MachinePrecision] / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$1, -4e-118], t$95$2, If[LessEqual[t$95$1, 0.0], N[(N[(N[Exp[(-b)], $MachinePrecision] * 0.0), $MachinePrecision] / y), $MachinePrecision], t$95$2]]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if (/.f64 (*.f64 x (exp.f64 (-.f64 (+.f64 (*.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y) < -3.9999999999999999e-118 or -0.0 < (/.f64 (*.f64 x (exp.f64 (-.f64 (+.f64 (*.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y)

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \frac{{a}^{\left(t - 1\right)}}{e^{b - \log z \cdot y}}}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b - y \cdot \log z}\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.5%

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b - y \cdot \log z}\right)} \]

   7. Taylor expanded in y around 0

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b}\right)} \]
   8. Step-by-step derivation

   9. Applied rewrites 58.9%

      \[\leadsto \frac{x}{a \cdot \left(y \cdot e^{b}\right)} \]

   if -3.9999999999999999e-118 < (/.f64 (*.f64 x (exp.f64 (-.f64 (+.f64 (*.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y) < -0.0

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]

   2. Taylor expanded in b around inf

      \[\leadsto \frac{x \cdot e^{-1 \cdot b}}{y} \]
   3. Step-by-step derivation

   4. Applied rewrites 48.3%

      \[\leadsto \frac{x \cdot e^{-1 \cdot b}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 48.3%

      \[\leadsto \frac{e^{-b} \cdot x}{y} \]

   7. Taylor expanded in undef-var around zero

      \[\leadsto \frac{e^{-b} \cdot 0}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 40.0%

      \[\leadsto \frac{e^{-b} \cdot 0}{y} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 14: 69.3% accurate, 0.2× speedup

Math

\[\begin{array}{l} t_1 := e^{-b}\\ t_2 := \frac{\left|x\right| \cdot \frac{1 + -1 \cdot b}{a}}{y}\\ t_3 := \frac{\left|x\right| \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y}\\ t_4 := \frac{t\_1 \cdot \left|x\right|}{y}\\ \mathsf{copysign}\left(1, x\right) \cdot \begin{array}{l} \mathbf{if}\;t\_3 \leq -\infty:\\ \;\;\;\;t\_4\\ \mathbf{elif}\;t\_3 \leq -4 \cdot 10^{-118}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t\_3 \leq 0:\\ \;\;\;\;\frac{t\_1 \cdot 0}{y}\\ \mathbf{elif}\;t\_3 \leq 10^{+302}:\\ \;\;\;\;t\_2\\ \mathbf{else}:\\ \;\;\;\;t\_4\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (exp (- b)))
       (t_2 (/ (* (fabs x) (/ (+ 1.0 (* -1.0 b)) a)) y))
       (t_3
        (/
         (*
          (fabs x)
          (exp (- (+ (* y (log z)) (* (- t 1.0) (log a))) b)))
         y))
       (t_4 (/ (* t_1 (fabs x)) y)))
  (*
   (copysign 1.0 x)
   (if (<= t_3 (- INFINITY))
     t_4
     (if (<= t_3 -4e-118)
       t_2
       (if (<= t_3 0.0)
         (/ (* t_1 0.0) y)
         (if (<= t_3 1e+302) t_2 t_4)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = exp(-b);
	double t_2 = (fabs(x) * ((1.0 + (-1.0 * b)) / a)) / y;
	double t_3 = (fabs(x) * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
	double t_4 = (t_1 * fabs(x)) / y;
	double tmp;
	if (t_3 <= -((double) INFINITY)) {
		tmp = t_4;
	} else if (t_3 <= -4e-118) {
		tmp = t_2;
	} else if (t_3 <= 0.0) {
		tmp = (t_1 * 0.0) / y;
	} else if (t_3 <= 1e+302) {
		tmp = t_2;
	} else {
		tmp = t_4;
	}
	return copysign(1.0, x) * tmp;
}

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = Math.exp(-b);
	double t_2 = (Math.abs(x) * ((1.0 + (-1.0 * b)) / a)) / y;
	double t_3 = (Math.abs(x) * Math.exp((((y * Math.log(z)) + ((t - 1.0) * Math.log(a))) - b))) / y;
	double t_4 = (t_1 * Math.abs(x)) / y;
	double tmp;
	if (t_3 <= -Double.POSITIVE_INFINITY) {
		tmp = t_4;
	} else if (t_3 <= -4e-118) {
		tmp = t_2;
	} else if (t_3 <= 0.0) {
		tmp = (t_1 * 0.0) / y;
	} else if (t_3 <= 1e+302) {
		tmp = t_2;
	} else {
		tmp = t_4;
	}
	return Math.copySign(1.0, x) * tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = math.exp(-b)
	t_2 = (math.fabs(x) * ((1.0 + (-1.0 * b)) / a)) / y
	t_3 = (math.fabs(x) * math.exp((((y * math.log(z)) + ((t - 1.0) * math.log(a))) - b))) / y
	t_4 = (t_1 * math.fabs(x)) / y
	tmp = 0
	if t_3 <= -math.inf:
		tmp = t_4
	elif t_3 <= -4e-118:
		tmp = t_2
	elif t_3 <= 0.0:
		tmp = (t_1 * 0.0) / y
	elif t_3 <= 1e+302:
		tmp = t_2
	else:
		tmp = t_4
	return math.copysign(1.0, x) * tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = exp(Float64(-b))
	t_2 = Float64(Float64(abs(x) * Float64(Float64(1.0 + Float64(-1.0 * b)) / a)) / y)
	t_3 = Float64(Float64(abs(x) * exp(Float64(Float64(Float64(y * log(z)) + Float64(Float64(t - 1.0) * log(a))) - b))) / y)
	t_4 = Float64(Float64(t_1 * abs(x)) / y)
	tmp = 0.0
	if (t_3 <= Float64(-Inf))
		tmp = t_4;
	elseif (t_3 <= -4e-118)
		tmp = t_2;
	elseif (t_3 <= 0.0)
		tmp = Float64(Float64(t_1 * 0.0) / y);
	elseif (t_3 <= 1e+302)
		tmp = t_2;
	else
		tmp = t_4;
	end
	return Float64(copysign(1.0, x) * tmp)
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = exp(-b);
	t_2 = (abs(x) * ((1.0 + (-1.0 * b)) / a)) / y;
	t_3 = (abs(x) * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
	t_4 = (t_1 * abs(x)) / y;
	tmp = 0.0;
	if (t_3 <= -Inf)
		tmp = t_4;
	elseif (t_3 <= -4e-118)
		tmp = t_2;
	elseif (t_3 <= 0.0)
		tmp = (t_1 * 0.0) / y;
	elseif (t_3 <= 1e+302)
		tmp = t_2;
	else
		tmp = t_4;
	end
	tmp_2 = (sign(x) * abs(1.0)) * tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[Exp[(-b)], $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[Abs[x], $MachinePrecision] * N[(N[(1.0 + N[(-1.0 * b), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[Abs[x], $MachinePrecision] * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] + N[(N[(t - 1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, Block[{t$95$4 = N[(N[(t$95$1 * N[Abs[x], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$3, (-Infinity)], t$95$4, If[LessEqual[t$95$3, -4e-118], t$95$2, If[LessEqual[t$95$3, 0.0], N[(N[(t$95$1 * 0.0), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[t$95$3, 1e+302], t$95$2, t$95$4]]]]), $MachinePrecision]]]]]

Derivation

1. Split input into 3 regimes

2. if (/.f64 (*.f64 x (exp.f64 (-.f64 (+.f64 (*.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y) < -inf.0 or 1.0000000000000001e302 < (/.f64 (*.f64 x (exp.f64 (-.f64 (+.f64 (*.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y)

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]

   2. Taylor expanded in b around inf

      \[\leadsto \frac{x \cdot e^{-1 \cdot b}}{y} \]
   3. Step-by-step derivation

   4. Applied rewrites 48.3%

      \[\leadsto \frac{x \cdot e^{-1 \cdot b}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 48.3%

      \[\leadsto \frac{e^{-b} \cdot x}{y} \]

   if -inf.0 < (/.f64 (*.f64 x (exp.f64 (-.f64 (+.f64 (*.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y) < -3.9999999999999999e-118 or -0.0 < (/.f64 (*.f64 x (exp.f64 (-.f64 (+.f64 (*.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y) < 1.0000000000000001e302

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \left(e^{\log z \cdot y - b} \cdot {a}^{\left(t - 1\right)}\right)}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.3%

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]

   7. Taylor expanded in y around 0

      \[\leadsto \frac{x \cdot \frac{e^{\mathsf{neg}\left(b\right)}}{a}}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 58.5%

      \[\leadsto \frac{x \cdot \frac{e^{-b}}{a}}{y} \]

   10. Taylor expanded in b around 0

       \[\leadsto \frac{x \cdot \frac{1 + -1 \cdot b}{a}}{y} \]
   11. Step-by-step derivation

   12. Applied rewrites 31.6%

       \[\leadsto \frac{x \cdot \frac{1 + -1 \cdot b}{a}}{y} \]

   if -3.9999999999999999e-118 < (/.f64 (*.f64 x (exp.f64 (-.f64 (+.f64 (*.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y) < -0.0

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]

   2. Taylor expanded in b around inf

      \[\leadsto \frac{x \cdot e^{-1 \cdot b}}{y} \]
   3. Step-by-step derivation

   4. Applied rewrites 48.3%

      \[\leadsto \frac{x \cdot e^{-1 \cdot b}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 48.3%

      \[\leadsto \frac{e^{-b} \cdot x}{y} \]

   7. Taylor expanded in undef-var around zero

      \[\leadsto \frac{e^{-b} \cdot 0}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 40.0%

      \[\leadsto \frac{e^{-b} \cdot 0}{y} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 15: 58.2% accurate, 1.4× speedup

Math

\[\begin{array}{l} t_1 := \frac{e^{-b} \cdot x}{y}\\ \mathbf{if}\;b \leq -230.16391864326246:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq 6.0848945134952526 \cdot 10^{-276}:\\ \;\;\;\;\frac{x \cdot 1}{a \cdot y}\\ \mathbf{elif}\;b \leq 808892543032.006:\\ \;\;\;\;\frac{x \cdot \frac{1}{a}}{y}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (/ (* (exp (- b)) x) y)))
  (if (<= b -230.16391864326246)
    t_1
    (if (<= b 6.0848945134952526e-276)
      (/ (* x 1.0) (* a y))
      (if (<= b 808892543032.006) (/ (* x (/ 1.0 a)) y) t_1)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (exp(-b) * x) / y;
	double tmp;
	if (b <= -230.16391864326246) {
		tmp = t_1;
	} else if (b <= 6.0848945134952526e-276) {
		tmp = (x * 1.0) / (a * y);
	} else if (b <= 808892543032.006) {
		tmp = (x * (1.0 / a)) / y;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (exp(-b) * x) / y
    if (b <= (-230.16391864326246d0)) then
        tmp = t_1
    else if (b <= 6.0848945134952526d-276) then
        tmp = (x * 1.0d0) / (a * y)
    else if (b <= 808892543032.006d0) then
        tmp = (x * (1.0d0 / a)) / y
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (Math.exp(-b) * x) / y;
	double tmp;
	if (b <= -230.16391864326246) {
		tmp = t_1;
	} else if (b <= 6.0848945134952526e-276) {
		tmp = (x * 1.0) / (a * y);
	} else if (b <= 808892543032.006) {
		tmp = (x * (1.0 / a)) / y;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (math.exp(-b) * x) / y
	tmp = 0
	if b <= -230.16391864326246:
		tmp = t_1
	elif b <= 6.0848945134952526e-276:
		tmp = (x * 1.0) / (a * y)
	elif b <= 808892543032.006:
		tmp = (x * (1.0 / a)) / y
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(exp(Float64(-b)) * x) / y)
	tmp = 0.0
	if (b <= -230.16391864326246)
		tmp = t_1;
	elseif (b <= 6.0848945134952526e-276)
		tmp = Float64(Float64(x * 1.0) / Float64(a * y));
	elseif (b <= 808892543032.006)
		tmp = Float64(Float64(x * Float64(1.0 / a)) / y);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (exp(-b) * x) / y;
	tmp = 0.0;
	if (b <= -230.16391864326246)
		tmp = t_1;
	elseif (b <= 6.0848945134952526e-276)
		tmp = (x * 1.0) / (a * y);
	elseif (b <= 808892543032.006)
		tmp = (x * (1.0 / a)) / y;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[Exp[(-b)], $MachinePrecision] * x), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[b, -230.16391864326246], t$95$1, If[LessEqual[b, 6.0848945134952526e-276], N[(N[(x * 1.0), $MachinePrecision] / N[(a * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 808892543032.006], N[(N[(x * N[(1.0 / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], t$95$1]]]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET t_1 = (((exp((- b))) * x) / y) IN
		LET tmp_2 = IF (b <= (8088925430320059814453125e-13)) THEN ((x * ((1) / a)) / y) ELSE t_1 ENDIF IN
		LET tmp_1 = IF (b <= (6084894513495252566218674801816738133253155496278644968315656829348885524299692621680388435929922461489687134158955085645581132674873741003125093496859024416374411662175270940317796164351949687460319643648526471153604903458587209157120285552553653637290699110751503207210499134946322518987607584160710645492009565643527923630992391883548270048110420111866693110875933456733065917501528894328281445223280937020974665058592342213272688251261666304261373255482997386149612719501625346066733338855797857816700745912309644728637410746003650867380552965315845974675036702393361410296386375129042347093452606118261619345634439981943371888135118183733529247970983622195717543945647776126861572265625e-966)) THEN ((x * (1)) / (a * y)) ELSE tmp_2 ENDIF IN
		LET tmp = IF (b <= (-230163918643262462637721910141408443450927734375e-45)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if b < -230.16391864326246 or 808892543032.00598 < b

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]

   2. Taylor expanded in b around inf

      \[\leadsto \frac{x \cdot e^{-1 \cdot b}}{y} \]
   3. Step-by-step derivation

   4. Applied rewrites 48.3%

      \[\leadsto \frac{x \cdot e^{-1 \cdot b}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 48.3%

      \[\leadsto \frac{e^{-b} \cdot x}{y} \]

   if -230.16391864326246 < b < 6.0848945134952526e-276

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \left(e^{\log z \cdot y - b} \cdot {a}^{\left(t - 1\right)}\right)}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x \cdot e^{y \cdot \log z - b}}{a \cdot y} \]
   5. Step-by-step derivation

   6. Applied rewrites 72.2%

      \[\leadsto \frac{x \cdot e^{y \cdot \log z - b}}{a \cdot y} \]

   7. Taylor expanded in b around 0

      \[\leadsto \frac{x \cdot {z}^{y}}{a \cdot y} \]
   8. Step-by-step derivation

   9. Applied rewrites 53.4%

      \[\leadsto \frac{x \cdot {z}^{y}}{a \cdot y} \]

   10. Taylor expanded in y around 0

       \[\leadsto \frac{x \cdot 1}{a \cdot y} \]
   11. Step-by-step derivation

   12. Applied rewrites 30.1%

       \[\leadsto \frac{x \cdot 1}{a \cdot y} \]

   if 6.0848945134952526e-276 < b < 808892543032.00598

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \left(e^{\log z \cdot y - b} \cdot {a}^{\left(t - 1\right)}\right)}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.3%

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]

   7. Taylor expanded in b around 0

      \[\leadsto \frac{x \cdot \frac{{z}^{y}}{a}}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 58.8%

      \[\leadsto \frac{x \cdot \frac{{z}^{y}}{a}}{y} \]

   10. Taylor expanded in y around 0

       \[\leadsto \frac{x \cdot \frac{1}{a}}{y} \]
   11. Step-by-step derivation

   12. Applied rewrites 30.0%

       \[\leadsto \frac{x \cdot \frac{1}{a}}{y} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 16: 34.3% accurate, 2.1× speedup

Math

\[\begin{array}{l} \mathbf{if}\;b \leq 2.3873157706662934 \cdot 10^{+35}:\\ \;\;\;\;\frac{x \cdot \frac{1 + -1 \cdot b}{a}}{y}\\ \mathbf{else}:\\ \;\;\;\;\frac{x \cdot 1}{a \cdot y}\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (if (<= b 2.3873157706662934e+35)
  (/ (* x (/ (+ 1.0 (* -1.0 b)) a)) y)
  (/ (* x 1.0) (* a y))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (b <= 2.3873157706662934e+35) {
		tmp = (x * ((1.0 + (-1.0 * b)) / a)) / y;
	} else {
		tmp = (x * 1.0) / (a * y);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (b <= 2.3873157706662934d+35) then
        tmp = (x * ((1.0d0 + ((-1.0d0) * b)) / a)) / y
    else
        tmp = (x * 1.0d0) / (a * y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (b <= 2.3873157706662934e+35) {
		tmp = (x * ((1.0 + (-1.0 * b)) / a)) / y;
	} else {
		tmp = (x * 1.0) / (a * y);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if b <= 2.3873157706662934e+35:
		tmp = (x * ((1.0 + (-1.0 * b)) / a)) / y
	else:
		tmp = (x * 1.0) / (a * y)
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (b <= 2.3873157706662934e+35)
		tmp = Float64(Float64(x * Float64(Float64(1.0 + Float64(-1.0 * b)) / a)) / y);
	else
		tmp = Float64(Float64(x * 1.0) / Float64(a * y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (b <= 2.3873157706662934e+35)
		tmp = (x * ((1.0 + (-1.0 * b)) / a)) / y;
	else
		tmp = (x * 1.0) / (a * y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, 2.3873157706662934e+35], N[(N[(x * N[(N[(1.0 + N[(-1.0 * b), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(N[(x * 1.0), $MachinePrecision] / N[(a * y), $MachinePrecision]), $MachinePrecision]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET tmp = IF (b <= (238731577066629341521517928071036928)) THEN ((x * (((1) + ((-1) * b)) / a)) / y) ELSE ((x * (1)) / (a * y)) ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if b < 2.3873157706662934e35

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \left(e^{\log z \cdot y - b} \cdot {a}^{\left(t - 1\right)}\right)}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.3%

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]

   7. Taylor expanded in y around 0

      \[\leadsto \frac{x \cdot \frac{e^{\mathsf{neg}\left(b\right)}}{a}}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 58.5%

      \[\leadsto \frac{x \cdot \frac{e^{-b}}{a}}{y} \]

   10. Taylor expanded in b around 0

       \[\leadsto \frac{x \cdot \frac{1 + -1 \cdot b}{a}}{y} \]
   11. Step-by-step derivation

   12. Applied rewrites 31.6%

       \[\leadsto \frac{x \cdot \frac{1 + -1 \cdot b}{a}}{y} \]

   if 2.3873157706662934e35 < b

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \left(e^{\log z \cdot y - b} \cdot {a}^{\left(t - 1\right)}\right)}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x \cdot e^{y \cdot \log z - b}}{a \cdot y} \]
   5. Step-by-step derivation

   6. Applied rewrites 72.2%

      \[\leadsto \frac{x \cdot e^{y \cdot \log z - b}}{a \cdot y} \]

   7. Taylor expanded in b around 0

      \[\leadsto \frac{x \cdot {z}^{y}}{a \cdot y} \]
   8. Step-by-step derivation

   9. Applied rewrites 53.4%

      \[\leadsto \frac{x \cdot {z}^{y}}{a \cdot y} \]

   10. Taylor expanded in y around 0

       \[\leadsto \frac{x \cdot 1}{a \cdot y} \]
   11. Step-by-step derivation

   12. Applied rewrites 30.1%

       \[\leadsto \frac{x \cdot 1}{a \cdot y} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 17: 30.1% accurate, 2.9× speedup

Math

\[\begin{array}{l} \mathbf{if}\;y \leq 1.1934423192491068 \cdot 10^{-296}:\\ \;\;\;\;\frac{x \cdot \frac{1}{a}}{y}\\ \mathbf{else}:\\ \;\;\;\;\frac{x \cdot 1}{a \cdot y}\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (if (<= y 1.1934423192491068e-296)
  (/ (* x (/ 1.0 a)) y)
  (/ (* x 1.0) (* a y))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (y <= 1.1934423192491068e-296) {
		tmp = (x * (1.0 / a)) / y;
	} else {
		tmp = (x * 1.0) / (a * y);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (y <= 1.1934423192491068d-296) then
        tmp = (x * (1.0d0 / a)) / y
    else
        tmp = (x * 1.0d0) / (a * y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (y <= 1.1934423192491068e-296) {
		tmp = (x * (1.0 / a)) / y;
	} else {
		tmp = (x * 1.0) / (a * y);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if y <= 1.1934423192491068e-296:
		tmp = (x * (1.0 / a)) / y
	else:
		tmp = (x * 1.0) / (a * y)
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (y <= 1.1934423192491068e-296)
		tmp = Float64(Float64(x * Float64(1.0 / a)) / y);
	else
		tmp = Float64(Float64(x * 1.0) / Float64(a * y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (y <= 1.1934423192491068e-296)
		tmp = (x * (1.0 / a)) / y;
	else
		tmp = (x * 1.0) / (a * y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, 1.1934423192491068e-296], N[(N[(x * N[(1.0 / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(N[(x * 1.0), $MachinePrecision] / N[(a * y), $MachinePrecision]), $MachinePrecision]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET tmp = IF (y <= (119344231924910675225940106063171085672279802184063308530063775165290421840261276897786962547481880074640454595310392599399062001210719031461006491119027361960995927787888663506598752784692126053368213339201800057776909016204855924424726972108859133360445029944142093938338912995152421309930722837836935044100565692041422308117933455211556946455586718804746488864524956067718021078524620645800813342603918911518062576254095948425603804155882958556869333852592633919387339318088529132180674480312736370198229107798683368046235428045615059667214127034223513240617465756154585480046435510761806534722473677789004966790380120986842122242117217332581481158922921265621112156845400004652445387940229060857490195335373073248774744570255279541015625e-1036)) THEN ((x * ((1) / a)) / y) ELSE ((x * (1)) / (a * y)) ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if y < 1.1934423192491068e-296

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \left(e^{\log z \cdot y - b} \cdot {a}^{\left(t - 1\right)}\right)}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]
   5. Step-by-step derivation

   6. Applied rewrites 80.3%

      \[\leadsto \frac{x \cdot \frac{e^{y \cdot \log z - b}}{a}}{y} \]

   7. Taylor expanded in b around 0

      \[\leadsto \frac{x \cdot \frac{{z}^{y}}{a}}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 58.8%

      \[\leadsto \frac{x \cdot \frac{{z}^{y}}{a}}{y} \]

   10. Taylor expanded in y around 0

       \[\leadsto \frac{x \cdot \frac{1}{a}}{y} \]
   11. Step-by-step derivation

   12. Applied rewrites 30.0%

       \[\leadsto \frac{x \cdot \frac{1}{a}}{y} \]

   if 1.1934423192491068e-296 < y

   1. Initial program 98.4%

      \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.4%

      \[\leadsto \frac{x \cdot \left(e^{\log z \cdot y - b} \cdot {a}^{\left(t - 1\right)}\right)}{y} \]

   4. Taylor expanded in t around 0

      \[\leadsto \frac{x \cdot e^{y \cdot \log z - b}}{a \cdot y} \]
   5. Step-by-step derivation

   6. Applied rewrites 72.2%

      \[\leadsto \frac{x \cdot e^{y \cdot \log z - b}}{a \cdot y} \]

   7. Taylor expanded in b around 0

      \[\leadsto \frac{x \cdot {z}^{y}}{a \cdot y} \]
   8. Step-by-step derivation

   9. Applied rewrites 53.4%

      \[\leadsto \frac{x \cdot {z}^{y}}{a \cdot y} \]

   10. Taylor expanded in y around 0

       \[\leadsto \frac{x \cdot 1}{a \cdot y} \]
   11. Step-by-step derivation

   12. Applied rewrites 30.1%

       \[\leadsto \frac{x \cdot 1}{a \cdot y} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 18: 30.0% accurate, 4.1× speedup

Math

\[\frac{x \cdot 1}{a \cdot y} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (/ (* x 1.0) (* a y)))

C

double code(double x, double y, double z, double t, double a, double b) {
	return (x * 1.0) / (a * y);
}

Fortran

real(8) function code(x, y, z, t, a, b)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    code = (x * 1.0d0) / (a * y)
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	return (x * 1.0) / (a * y);
}

Python

def code(x, y, z, t, a, b):
	return (x * 1.0) / (a * y)

Julia

function code(x, y, z, t, a, b)
	return Float64(Float64(x * 1.0) / Float64(a * y))
end

MATLAB

function tmp = code(x, y, z, t, a, b)
	tmp = (x * 1.0) / (a * y);
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := N[(N[(x * 1.0), $MachinePrecision] / N[(a * y), $MachinePrecision]), $MachinePrecision]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	(x * (1)) / (a * y)
END code

Derivation

1. Initial program 98.4%

   \[\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y} \]
2. Step-by-step derivation

3. Applied rewrites 79.4%

   \[\leadsto \frac{x \cdot \left(e^{\log z \cdot y - b} \cdot {a}^{\left(t - 1\right)}\right)}{y} \]

4. Taylor expanded in t around 0

   \[\leadsto \frac{x \cdot e^{y \cdot \log z - b}}{a \cdot y} \]
5. Step-by-step derivation

6. Applied rewrites 72.2%

   \[\leadsto \frac{x \cdot e^{y \cdot \log z - b}}{a \cdot y} \]

7. Taylor expanded in b around 0

   \[\leadsto \frac{x \cdot {z}^{y}}{a \cdot y} \]
8. Step-by-step derivation

9. Applied rewrites 53.4%

   \[\leadsto \frac{x \cdot {z}^{y}}{a \cdot y} \]

10. Taylor expanded in y around 0

    \[\leadsto \frac{x \cdot 1}{a \cdot y} \]
11. Step-by-step derivation

12. Applied rewrites 30.1%

    \[\leadsto \frac{x \cdot 1}{a \cdot y} \]
13. Add Preprocessing

Reproduce

herbie shell --seed 2026092 
(FPCore (x y z t a b)
  :name "Numeric.SpecFunctions:incompleteBetaWorker from math-functions-0.1.5.2, A"
  :precision binary64
  (/ (* x (exp (- (+ (* y (log z)) (* (- t 1.0) (log a))) b))) y))