Numeric.SpecFunctions:logGamma from math-functions-0.1.5.2

Percentage Accurate: 55.9% → 55.9%

Time: 4.4s

Alternatives: 8

Speedup: 1.0×

Specification

\[\mathsf{TRUE}\left(\right)\]

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: 55.9% 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: 55.9% 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 58.9%

   \[\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: 45.7% 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 -3.4 \cdot 10^{-81}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;t \leq 8 \cdot 10^{-55}:\\ \;\;\;\;\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 -3.4e-81)
     t_3
     (if (<= t 8e-55) (/ (* (+ 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 <= -3.4e-81) {
		tmp = t_3;
	} else if (t <= 8e-55) {
		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 <= (-3.4d-81)) then
        tmp = t_3
    else if (t <= 8d-55) 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 <= -3.4e-81) {
		tmp = t_3;
	} else if (t <= 8e-55) {
		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 <= -3.4e-81:
		tmp = t_3
	elif t <= 8e-55:
		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 <= -3.4e-81)
		tmp = t_3;
	elseif (t <= 8e-55)
		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 <= -3.4e-81)
		tmp = t_3;
	elseif (t <= 8e-55)
		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, -3.4e-81], t$95$3, If[LessEqual[t, 8e-55], 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 < -3.3999999999999999e-81 or 7.99999999999999996e-55 < t

   1. Initial program 55.3%

      \[\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 48.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} \]

   if -3.3999999999999999e-81 < t < 7.99999999999999996e-55

   1. Initial program 64.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}{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 49.5%

      \[\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: 35.9% 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.2 \cdot 10^{+157}:\\ \;\;\;\;\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.2e+157) (/ (+ (* (+ (* 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.2e+157) {
		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.2d+157) 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.2e+157) {
		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.2e+157:
		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.2e+157)
		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.2e+157)
		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.2e+157], 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.2e157

   1. Initial program 59.9%

      \[\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.7%

      \[\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 34.9%

      \[\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.2e157 < z

   1. Initial program 51.8%

      \[\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 31.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: 39.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 58.9%

   \[\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 38.8%

   \[\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: 34.7% 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 58.9%

   \[\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 38.8%

   \[\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 32.1%

   \[\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 58.9%

   \[\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 38.8%

   \[\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 32.1%

   \[\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 5.9%

    \[\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 58.9%

   \[\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 38.8%

   \[\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 3.0%

   \[\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 4.6%

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

Alternative 8: 2.9% accurate, 5.9× speedup

Math

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

FPCore

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

C

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

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
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;
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 58.9%

   \[\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 38.8%

   \[\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 3.0%

   \[\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 4.6%

    \[\leadsto \left(\left(y + a\right) \cdot y + b\right) \cdot y \]

12. Taylor expanded in x around inf

    \[\leadsto x \cdot {y}^{\color{blue}{3}} \]

14. Applied rewrites 3.0%

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

Reproduce

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