Numeric.SpecFunctions:logGamma from math-functions-0.1.5.2

Percentage Accurate: 54.3% → 54.3%

Time: 4.5s

Alternatives: 7

Speedup: 1.0×

Specification

Math

\[\begin{array}{l} \\ \frac{\left(\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y + 230661.510616\right) \cdot y + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (/
  (+ (* (+ (* (+ (* (+ (* x y) z) y) 27464.7644705) y) 230661.510616) y) t)
  (+ (* (+ (* (+ (* (+ y a) y) b) y) c) y) i)))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	return ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    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), intent (in) :: c
    real(8), intent (in) :: i
    code = ((((((((x * y) + z) * y) + 27464.7644705d0) * y) + 230661.510616d0) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i)
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	return ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
}

Python

def code(x, y, z, t, a, b, c, i):
	return ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i)

Julia

function code(x, y, z, t, a, b, c, i)
	return Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / Float64(Float64(Float64(Float64(Float64(Float64(Float64(y + a) * y) + b) * y) + c) * y) + i))
end

MATLAB

function tmp = code(x, y, z, t, a, b, c, i)
	tmp = ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(N[(N[(N[(N[(N[(N[(N[(N[(x * y), $MachinePrecision] + z), $MachinePrecision] * y), $MachinePrecision] + 27464.7644705), $MachinePrecision] * y), $MachinePrecision] + 230661.510616), $MachinePrecision] * y), $MachinePrecision] + t), $MachinePrecision] / N[(N[(N[(N[(N[(N[(N[(y + a), $MachinePrecision] * y), $MachinePrecision] + b), $MachinePrecision] * y), $MachinePrecision] + c), $MachinePrecision] * y), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision]

Initial Program: 54.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{\left(\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y + 230661.510616\right) \cdot y + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (/
  (+ (* (+ (* (+ (* (+ (* x y) z) y) 27464.7644705) y) 230661.510616) y) t)
  (+ (* (+ (* (+ (* (+ y a) y) b) y) c) y) i)))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	return ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    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), intent (in) :: c
    real(8), intent (in) :: i
    code = ((((((((x * y) + z) * y) + 27464.7644705d0) * y) + 230661.510616d0) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i)
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	return ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
}

Python

def code(x, y, z, t, a, b, c, i):
	return ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i)

Julia

function code(x, y, z, t, a, b, c, i)
	return Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / Float64(Float64(Float64(Float64(Float64(Float64(Float64(y + a) * y) + b) * y) + c) * y) + i))
end

MATLAB

function tmp = code(x, y, z, t, a, b, c, i)
	tmp = ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(N[(N[(N[(N[(N[(N[(N[(N[(x * y), $MachinePrecision] + z), $MachinePrecision] * y), $MachinePrecision] + 27464.7644705), $MachinePrecision] * y), $MachinePrecision] + 230661.510616), $MachinePrecision] * y), $MachinePrecision] + t), $MachinePrecision] / N[(N[(N[(N[(N[(N[(N[(y + a), $MachinePrecision] * y), $MachinePrecision] + b), $MachinePrecision] * y), $MachinePrecision] + c), $MachinePrecision] * y), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision]

Alternative 1: 54.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{\left(\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y + 230661.510616\right) \cdot y + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (/
  (+ (* (+ (* (+ (* (+ (* x y) z) y) 27464.7644705) y) 230661.510616) y) t)
  (+ (* (+ (* (+ (* (+ y a) y) b) y) c) y) i)))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	return ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    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), intent (in) :: c
    real(8), intent (in) :: i
    code = ((((((((x * y) + z) * y) + 27464.7644705d0) * y) + 230661.510616d0) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i)
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	return ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
}

Python

def code(x, y, z, t, a, b, c, i):
	return ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i)

Julia

function code(x, y, z, t, a, b, c, i)
	return Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / Float64(Float64(Float64(Float64(Float64(Float64(Float64(y + a) * y) + b) * y) + c) * y) + i))
end

MATLAB

function tmp = code(x, y, z, t, a, b, c, i)
	tmp = ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(N[(N[(N[(N[(N[(N[(N[(N[(x * y), $MachinePrecision] + z), $MachinePrecision] * y), $MachinePrecision] + 27464.7644705), $MachinePrecision] * y), $MachinePrecision] + 230661.510616), $MachinePrecision] * y), $MachinePrecision] + t), $MachinePrecision] / N[(N[(N[(N[(N[(N[(N[(y + a), $MachinePrecision] * y), $MachinePrecision] + b), $MachinePrecision] * y), $MachinePrecision] + c), $MachinePrecision] * y), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 56.6%

   \[\frac{\left(\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y + 230661.510616\right) \cdot y + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]
2. Add Preprocessing
3. Add Preprocessing

Alternative 2: 44.6% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i\\ t_2 := \left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y\\ t_3 := \frac{t\_2 + t}{t\_1}\\ \mathbf{if}\;t \leq -2.65 \cdot 10^{-85}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;t \leq 5.1 \cdot 10^{-126}:\\ \;\;\;\;\frac{\left(t\_2 + 230661.510616\right) \cdot y}{t\_1}\\ \mathbf{else}:\\ \;\;\;\;t\_3\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (+ (* (+ (* (+ (* (+ y a) y) b) y) c) y) i))
        (t_2 (* (+ (* (+ (* x y) z) y) 27464.7644705) y))
        (t_3 (/ (+ t_2 t) t_1)))
   (if (<= t -2.65e-85)
     t_3
     (if (<= t 5.1e-126) (/ (* (+ t_2 230661.510616) y) t_1) t_3))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = ((((((y + a) * y) + b) * y) + c) * y) + i;
	double t_2 = ((((x * y) + z) * y) + 27464.7644705) * y;
	double t_3 = (t_2 + t) / t_1;
	double tmp;
	if (t <= -2.65e-85) {
		tmp = t_3;
	} else if (t <= 5.1e-126) {
		tmp = ((t_2 + 230661.510616) * y) / t_1;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_1 = ((((((y + a) * y) + b) * y) + c) * y) + i
    t_2 = ((((x * y) + z) * y) + 27464.7644705d0) * y
    t_3 = (t_2 + t) / t_1
    if (t <= (-2.65d-85)) then
        tmp = t_3
    else if (t <= 5.1d-126) then
        tmp = ((t_2 + 230661.510616d0) * y) / t_1
    else
        tmp = t_3
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = ((((((y + a) * y) + b) * y) + c) * y) + i;
	double t_2 = ((((x * y) + z) * y) + 27464.7644705) * y;
	double t_3 = (t_2 + t) / t_1;
	double tmp;
	if (t <= -2.65e-85) {
		tmp = t_3;
	} else if (t <= 5.1e-126) {
		tmp = ((t_2 + 230661.510616) * y) / t_1;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = ((((((y + a) * y) + b) * y) + c) * y) + i
	t_2 = ((((x * y) + z) * y) + 27464.7644705) * y
	t_3 = (t_2 + t) / t_1
	tmp = 0
	if t <= -2.65e-85:
		tmp = t_3
	elif t <= 5.1e-126:
		tmp = ((t_2 + 230661.510616) * y) / t_1
	else:
		tmp = t_3
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(Float64(Float64(Float64(Float64(Float64(Float64(y + a) * y) + b) * y) + c) * y) + i)
	t_2 = Float64(Float64(Float64(Float64(Float64(x * y) + z) * y) + 27464.7644705) * y)
	t_3 = Float64(Float64(t_2 + t) / t_1)
	tmp = 0.0
	if (t <= -2.65e-85)
		tmp = t_3;
	elseif (t <= 5.1e-126)
		tmp = Float64(Float64(Float64(t_2 + 230661.510616) * y) / t_1);
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = ((((((y + a) * y) + b) * y) + c) * y) + i;
	t_2 = ((((x * y) + z) * y) + 27464.7644705) * y;
	t_3 = (t_2 + t) / t_1;
	tmp = 0.0;
	if (t <= -2.65e-85)
		tmp = t_3;
	elseif (t <= 5.1e-126)
		tmp = ((t_2 + 230661.510616) * y) / t_1;
	else
		tmp = t_3;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(N[(N[(N[(N[(N[(y + a), $MachinePrecision] * y), $MachinePrecision] + b), $MachinePrecision] * y), $MachinePrecision] + c), $MachinePrecision] * y), $MachinePrecision] + i), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(N[(N[(x * y), $MachinePrecision] + z), $MachinePrecision] * y), $MachinePrecision] + 27464.7644705), $MachinePrecision] * y), $MachinePrecision]}, Block[{t$95$3 = N[(N[(t$95$2 + t), $MachinePrecision] / t$95$1), $MachinePrecision]}, If[LessEqual[t, -2.65e-85], t$95$3, If[LessEqual[t, 5.1e-126], N[(N[(N[(t$95$2 + 230661.510616), $MachinePrecision] * y), $MachinePrecision] / t$95$1), $MachinePrecision], t$95$3]]]]]

Derivation

1. Split input into 2 regimes

2. if t < -2.64999999999999984e-85 or 5.10000000000000002e-126 < t

   1. Initial program 57.0%

      \[\frac{\left(\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y + 230661.510616\right) \cdot y + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0

      \[\leadsto \frac{\color{blue}{y \cdot \left(\frac{28832688827}{125000} + y \cdot \left(\frac{54929528941}{2000000} + y \cdot z\right)\right)} + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]

   5. Applied rewrites 50.4%

      \[\leadsto \frac{\color{blue}{\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y} + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]

   if -2.64999999999999984e-85 < t < 5.10000000000000002e-126

   1. Initial program 56.0%

      \[\frac{\left(\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y + 230661.510616\right) \cdot y + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0

      \[\leadsto \frac{\color{blue}{t + y \cdot \left(\frac{28832688827}{125000} + y \cdot \left(\frac{54929528941}{2000000} + y \cdot z\right)\right)}}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]

   5. Applied rewrites 45.9%

      \[\leadsto \frac{\color{blue}{\left(\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y + 230661.510616\right) \cdot y}}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 3: 34.7% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(\left(y + a\right) \cdot y + b\right) \cdot y\\ t_2 := \left(t\_1 + c\right) \cdot y + i\\ \mathbf{if}\;z \leq 4.7 \cdot 10^{+114}:\\ \;\;\;\;\frac{\left(x \cdot y + z\right) \cdot y + t}{t\_2}\\ \mathbf{else}:\\ \;\;\;\;\frac{t\_1 + t}{t\_2}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (* (+ (* (+ y a) y) b) y)) (t_2 (+ (* (+ t_1 c) y) i)))
   (if (<= z 4.7e+114) (/ (+ (* (+ (* x y) z) y) t) t_2) (/ (+ t_1 t) t_2))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (((y + a) * y) + b) * y;
	double t_2 = ((t_1 + c) * y) + i;
	double tmp;
	if (z <= 4.7e+114) {
		tmp = ((((x * y) + z) * y) + t) / t_2;
	} else {
		tmp = (t_1 + t) / t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (((y + a) * y) + b) * y
    t_2 = ((t_1 + c) * y) + i
    if (z <= 4.7d+114) then
        tmp = ((((x * y) + z) * y) + t) / t_2
    else
        tmp = (t_1 + t) / t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (((y + a) * y) + b) * y;
	double t_2 = ((t_1 + c) * y) + i;
	double tmp;
	if (z <= 4.7e+114) {
		tmp = ((((x * y) + z) * y) + t) / t_2;
	} else {
		tmp = (t_1 + t) / t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = (((y + a) * y) + b) * y
	t_2 = ((t_1 + c) * y) + i
	tmp = 0
	if z <= 4.7e+114:
		tmp = ((((x * y) + z) * y) + t) / t_2
	else:
		tmp = (t_1 + t) / t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(Float64(Float64(Float64(y + a) * y) + b) * y)
	t_2 = Float64(Float64(Float64(t_1 + c) * y) + i)
	tmp = 0.0
	if (z <= 4.7e+114)
		tmp = Float64(Float64(Float64(Float64(Float64(x * y) + z) * y) + t) / t_2);
	else
		tmp = Float64(Float64(t_1 + t) / t_2);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = (((y + a) * y) + b) * y;
	t_2 = ((t_1 + c) * y) + i;
	tmp = 0.0;
	if (z <= 4.7e+114)
		tmp = ((((x * y) + z) * y) + t) / t_2;
	else
		tmp = (t_1 + t) / t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(N[(N[(y + a), $MachinePrecision] * y), $MachinePrecision] + b), $MachinePrecision] * y), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(t$95$1 + c), $MachinePrecision] * y), $MachinePrecision] + i), $MachinePrecision]}, If[LessEqual[z, 4.7e+114], N[(N[(N[(N[(N[(x * y), $MachinePrecision] + z), $MachinePrecision] * y), $MachinePrecision] + t), $MachinePrecision] / t$95$2), $MachinePrecision], N[(N[(t$95$1 + t), $MachinePrecision] / t$95$2), $MachinePrecision]]]]

Derivation

1. Split input into 2 regimes

2. if z < 4.7000000000000001e114

   1. Initial program 56.5%

      \[\frac{\left(\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y + 230661.510616\right) \cdot y + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0

      \[\leadsto \frac{\color{blue}{y \cdot \left(\frac{28832688827}{125000} + y \cdot \left(\frac{54929528941}{2000000} + y \cdot z\right)\right)} + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]

   5. Applied rewrites 39.5%

      \[\leadsto \frac{\color{blue}{\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y} + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]

   6. Taylor expanded in x around inf

      \[\leadsto \frac{\color{blue}{x \cdot \left(\frac{y \cdot \left(\frac{28832688827}{125000} + y \cdot \left(\frac{54929528941}{2000000} + y \cdot z\right)\right)}{x} + {y}^{4}\right)} + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]

   8. Applied rewrites 35.8%

      \[\leadsto \frac{\color{blue}{\left(x \cdot y + z\right) \cdot y} + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]

   if 4.7000000000000001e114 < z

   1. Initial program 56.7%

      \[\frac{\left(\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y + 230661.510616\right) \cdot y + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0

      \[\leadsto \frac{\color{blue}{\left(x \cdot {y}^{4} + y \cdot \left(\frac{28832688827}{125000} + y \cdot \left(\frac{54929528941}{2000000} + y \cdot z\right)\right)\right)} + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]

   5. Applied rewrites 34.9%

      \[\leadsto \frac{\color{blue}{\left(\left(y + a\right) \cdot y + b\right) \cdot y} + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 4: 37.9% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \frac{\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (/
  (+ (* (+ (* (+ (* x y) z) y) 27464.7644705) y) t)
  (+ (* (+ (* (+ (* (+ y a) y) b) y) c) y) i)))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	return ((((((x * y) + z) * y) + 27464.7644705) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    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), intent (in) :: c
    real(8), intent (in) :: i
    code = ((((((x * y) + z) * y) + 27464.7644705d0) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i)
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	return ((((((x * y) + z) * y) + 27464.7644705) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
}

Python

def code(x, y, z, t, a, b, c, i):
	return ((((((x * y) + z) * y) + 27464.7644705) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i)

Julia

function code(x, y, z, t, a, b, c, i)
	return Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * y) + z) * y) + 27464.7644705) * y) + t) / Float64(Float64(Float64(Float64(Float64(Float64(Float64(y + a) * y) + b) * y) + c) * y) + i))
end

MATLAB

function tmp = code(x, y, z, t, a, b, c, i)
	tmp = ((((((x * y) + z) * y) + 27464.7644705) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(N[(N[(N[(N[(N[(N[(x * y), $MachinePrecision] + z), $MachinePrecision] * y), $MachinePrecision] + 27464.7644705), $MachinePrecision] * y), $MachinePrecision] + t), $MachinePrecision] / N[(N[(N[(N[(N[(N[(N[(y + a), $MachinePrecision] * y), $MachinePrecision] + b), $MachinePrecision] * y), $MachinePrecision] + c), $MachinePrecision] * y), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 56.6%

   \[\frac{\left(\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y + 230661.510616\right) \cdot y + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]
2. Add Preprocessing

3. Taylor expanded in x around 0

   \[\leadsto \frac{\color{blue}{y \cdot \left(\frac{28832688827}{125000} + y \cdot \left(\frac{54929528941}{2000000} + y \cdot z\right)\right)} + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]

5. Applied rewrites 39.6%

   \[\leadsto \frac{\color{blue}{\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y} + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]
6. Add Preprocessing

Alternative 5: 33.5% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \frac{\left(x \cdot y + z\right) \cdot y + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (/ (+ (* (+ (* x y) z) y) t) (+ (* (+ (* (+ (* (+ y a) y) b) y) c) y) i)))

C

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

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    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), intent (in) :: c
    real(8), intent (in) :: i
    code = ((((x * y) + z) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i)
end function

Java

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

Python

def code(x, y, z, t, a, b, c, i):
	return ((((x * y) + z) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i)

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(N[(N[(N[(N[(x * y), $MachinePrecision] + z), $MachinePrecision] * y), $MachinePrecision] + t), $MachinePrecision] / N[(N[(N[(N[(N[(N[(N[(y + a), $MachinePrecision] * y), $MachinePrecision] + b), $MachinePrecision] * y), $MachinePrecision] + c), $MachinePrecision] * y), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 56.6%

   \[\frac{\left(\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y + 230661.510616\right) \cdot y + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]
2. Add Preprocessing

3. Taylor expanded in x around 0

   \[\leadsto \frac{\color{blue}{y \cdot \left(\frac{28832688827}{125000} + y \cdot \left(\frac{54929528941}{2000000} + y \cdot z\right)\right)} + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]

5. Applied rewrites 39.6%

   \[\leadsto \frac{\color{blue}{\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y} + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]

6. Taylor expanded in x around inf

   \[\leadsto \frac{\color{blue}{x \cdot \left(\frac{y \cdot \left(\frac{28832688827}{125000} + y \cdot \left(\frac{54929528941}{2000000} + y \cdot z\right)\right)}{x} + {y}^{4}\right)} + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]

8. Applied rewrites 33.8%

   \[\leadsto \frac{\color{blue}{\left(x \cdot y + z\right) \cdot y} + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]
9. Add Preprocessing

Alternative 6: 6.1% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \frac{\left(x \cdot y + z\right) \cdot y}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (/ (* (+ (* x y) z) y) (+ (* (+ (* (+ (* (+ y a) y) b) y) c) y) i)))

C

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

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    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), intent (in) :: c
    real(8), intent (in) :: i
    code = (((x * y) + z) * y) / (((((((y + a) * y) + b) * y) + c) * y) + i)
end function

Java

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

Python

def code(x, y, z, t, a, b, c, i):
	return (((x * y) + z) * y) / (((((((y + a) * y) + b) * y) + c) * y) + i)

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(N[(N[(N[(x * y), $MachinePrecision] + z), $MachinePrecision] * y), $MachinePrecision] / N[(N[(N[(N[(N[(N[(N[(y + a), $MachinePrecision] * y), $MachinePrecision] + b), $MachinePrecision] * y), $MachinePrecision] + c), $MachinePrecision] * y), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 56.6%

   \[\frac{\left(\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y + 230661.510616\right) \cdot y + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]
2. Add Preprocessing

3. Taylor expanded in x around 0

   \[\leadsto \frac{\color{blue}{y \cdot \left(\frac{28832688827}{125000} + y \cdot \left(\frac{54929528941}{2000000} + y \cdot z\right)\right)} + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]

5. Applied rewrites 39.6%

   \[\leadsto \frac{\color{blue}{\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y} + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]

6. Taylor expanded in x around inf

   \[\leadsto \frac{\color{blue}{x \cdot \left(\frac{y \cdot \left(\frac{28832688827}{125000} + y \cdot \left(\frac{54929528941}{2000000} + y \cdot z\right)\right)}{x} + {y}^{4}\right)} + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]

8. Applied rewrites 33.8%

   \[\leadsto \frac{\color{blue}{\left(x \cdot y + z\right) \cdot y} + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]

9. Taylor expanded in x around 0

   \[\leadsto \frac{\color{blue}{t + \left(x \cdot {y}^{4} + y \cdot \left(\frac{28832688827}{125000} + y \cdot \left(\frac{54929528941}{2000000} + y \cdot z\right)\right)\right)}}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]

11. Applied rewrites 7.3%

    \[\leadsto \frac{\color{blue}{\left(x \cdot y + z\right) \cdot y}}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]
12. Add Preprocessing

Alternative 7: 3.9% accurate, 4.2× speedup

Math

\[\begin{array}{l} \\ \left(\left(y + a\right) \cdot y + b\right) \cdot y \end{array} \]

FPCore

(FPCore (x y z t a b c i) :precision binary64 (* (+ (* (+ y a) y) b) y))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	return (((y + a) * y) + b) * y;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    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), intent (in) :: c
    real(8), intent (in) :: i
    code = (((y + a) * y) + b) * y
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	return (((y + a) * y) + b) * y;
}

Python

def code(x, y, z, t, a, b, c, i):
	return (((y + a) * y) + b) * y

Julia

function code(x, y, z, t, a, b, c, i)
	return Float64(Float64(Float64(Float64(y + a) * y) + b) * y)
end

MATLAB

function tmp = code(x, y, z, t, a, b, c, i)
	tmp = (((y + a) * y) + b) * y;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(N[(N[(N[(y + a), $MachinePrecision] * y), $MachinePrecision] + b), $MachinePrecision] * y), $MachinePrecision]

Derivation

1. Initial program 56.6%

   \[\frac{\left(\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y + 230661.510616\right) \cdot y + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]
2. Add Preprocessing

3. Taylor expanded in x around 0

   \[\leadsto \frac{\color{blue}{y \cdot \left(\frac{28832688827}{125000} + y \cdot \left(\frac{54929528941}{2000000} + y \cdot z\right)\right)} + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]

5. Applied rewrites 39.6%

   \[\leadsto \frac{\color{blue}{\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y} + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \]

6. Taylor expanded in x around inf

   \[\leadsto \color{blue}{x \cdot \left(\frac{t}{x \cdot \left(i + y \cdot \left(c + y \cdot \left(b + y \cdot \left(a + y\right)\right)\right)\right)} + \left(\frac{y \cdot \left(\frac{28832688827}{125000} + y \cdot \left(\frac{54929528941}{2000000} + y \cdot z\right)\right)}{x \cdot \left(i + y \cdot \left(c + y \cdot \left(b + y \cdot \left(a + y\right)\right)\right)\right)} + \frac{{y}^{4}}{i + y \cdot \left(c + y \cdot \left(b + y \cdot \left(a + y\right)\right)\right)}\right)\right)} \]

8. Applied rewrites 2.8%

   \[\leadsto \color{blue}{\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y + 230661.510616} \]

9. Taylor expanded in x around -inf

   \[\leadsto -1 \cdot \left(x \cdot \color{blue}{\left(-1 \cdot \frac{\frac{28832688827}{125000} + y \cdot \left(\frac{54929528941}{2000000} + y \cdot z\right)}{x} + -1 \cdot {y}^{3}\right)}\right) \]

11. Applied rewrites 3.6%

    \[\leadsto \left(\left(y + a\right) \cdot y + b\right) \cdot y \]
12. Add Preprocessing

Reproduce

herbie shell --seed 2024313 
(FPCore (x y z t a b c i)
  :name "Numeric.SpecFunctions:logGamma from math-functions-0.1.5.2"
  :precision binary64
  (/ (+ (* (+ (* (+ (* (+ (* x y) z) y) 27464.7644705) y) 230661.510616) y) t) (+ (* (+ (* (+ (* (+ y a) y) b) y) c) y) i)))