Graphics.Rendering.Chart.SparkLine:renderSparkLine from Chart-1.5.3

Percentage Accurate: 97.0% → 99.8%

Time: 10.2s

Alternatives: 13

Speedup: 1.0×

Specification

Math

\[\begin{array}{l} \\ x - \frac{y - z}{\frac{\left(t - z\right) + 1}{a}} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (- x (/ (- y z) (/ (+ (- t z) 1.0) a))))

C

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

Fortran

real(8) function code(x, y, z, t, a)
    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
    code = x - ((y - z) / (((t - z) + 1.0d0) / a))
end function

Java

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

Python

def code(x, y, z, t, a):
	return x - ((y - z) / (((t - z) + 1.0) / a))

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 97.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ x - \frac{y - z}{\frac{\left(t - z\right) + 1}{a}} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (- x (/ (- y z) (/ (+ (- t z) 1.0) a))))

C

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

Fortran

real(8) function code(x, y, z, t, a)
    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
    code = x - ((y - z) / (((t - z) + 1.0d0) / a))
end function

Java

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

Python

def code(x, y, z, t, a):
	return x - ((y - z) / (((t - z) + 1.0) / a))

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 99.8% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z t a)
 :precision binary64
 (+ x (* a (/ (- z y) (+ (- t z) 1.0)))))

C

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

Fortran

real(8) function code(x, y, z, t, a)
    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
    code = x + (a * ((z - y) / ((t - z) + 1.0d0)))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 2: 68.6% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x - y \cdot a\\ t_2 := x - y \cdot \frac{a}{t}\\ \mathbf{if}\;t \leq -0.95:\\ \;\;\;\;t_2\\ \mathbf{elif}\;t \leq 2.75 \cdot 10^{-242}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq 3.8 \cdot 10^{-163}:\\ \;\;\;\;x + y \cdot \frac{a}{z}\\ \mathbf{elif}\;t \leq 7.5 \cdot 10^{+104}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (- x (* y a))) (t_2 (- x (* y (/ a t)))))
   (if (<= t -0.95)
     t_2
     (if (<= t 2.75e-242)
       t_1
       (if (<= t 3.8e-163)
         (+ x (* y (/ a z)))
         (if (<= t 7.5e+104) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = x - (y * a);
	double t_2 = x - (y * (a / t));
	double tmp;
	if (t <= -0.95) {
		tmp = t_2;
	} else if (t <= 2.75e-242) {
		tmp = t_1;
	} else if (t <= 3.8e-163) {
		tmp = x + (y * (a / z));
	} else if (t <= 7.5e+104) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = x - (y * a)
    t_2 = x - (y * (a / t))
    if (t <= (-0.95d0)) then
        tmp = t_2
    else if (t <= 2.75d-242) then
        tmp = t_1
    else if (t <= 3.8d-163) then
        tmp = x + (y * (a / z))
    else if (t <= 7.5d+104) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = x - (y * a);
	double t_2 = x - (y * (a / t));
	double tmp;
	if (t <= -0.95) {
		tmp = t_2;
	} else if (t <= 2.75e-242) {
		tmp = t_1;
	} else if (t <= 3.8e-163) {
		tmp = x + (y * (a / z));
	} else if (t <= 7.5e+104) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = x - (y * a)
	t_2 = x - (y * (a / t))
	tmp = 0
	if t <= -0.95:
		tmp = t_2
	elif t <= 2.75e-242:
		tmp = t_1
	elif t <= 3.8e-163:
		tmp = x + (y * (a / z))
	elif t <= 7.5e+104:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(x - Float64(y * a))
	t_2 = Float64(x - Float64(y * Float64(a / t)))
	tmp = 0.0
	if (t <= -0.95)
		tmp = t_2;
	elseif (t <= 2.75e-242)
		tmp = t_1;
	elseif (t <= 3.8e-163)
		tmp = Float64(x + Float64(y * Float64(a / z)));
	elseif (t <= 7.5e+104)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = x - (y * a);
	t_2 = x - (y * (a / t));
	tmp = 0.0;
	if (t <= -0.95)
		tmp = t_2;
	elseif (t <= 2.75e-242)
		tmp = t_1;
	elseif (t <= 3.8e-163)
		tmp = x + (y * (a / z));
	elseif (t <= 7.5e+104)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(y * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(y * N[(a / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -0.95], t$95$2, If[LessEqual[t, 2.75e-242], t$95$1, If[LessEqual[t, 3.8e-163], N[(x + N[(y * N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 7.5e+104], t$95$1, t$95$2]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 3: 69.0% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x - y \cdot a\\ t_2 := x - a \cdot \frac{y}{t}\\ \mathbf{if}\;t \leq -12.5:\\ \;\;\;\;t_2\\ \mathbf{elif}\;t \leq 1.65 \cdot 10^{-239}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq 4.1 \cdot 10^{-162}:\\ \;\;\;\;x + y \cdot \frac{a}{z}\\ \mathbf{elif}\;t \leq 7.5 \cdot 10^{+104}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (- x (* y a))) (t_2 (- x (* a (/ y t)))))
   (if (<= t -12.5)
     t_2
     (if (<= t 1.65e-239)
       t_1
       (if (<= t 4.1e-162)
         (+ x (* y (/ a z)))
         (if (<= t 7.5e+104) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = x - (y * a);
	double t_2 = x - (a * (y / t));
	double tmp;
	if (t <= -12.5) {
		tmp = t_2;
	} else if (t <= 1.65e-239) {
		tmp = t_1;
	} else if (t <= 4.1e-162) {
		tmp = x + (y * (a / z));
	} else if (t <= 7.5e+104) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = x - (y * a)
    t_2 = x - (a * (y / t))
    if (t <= (-12.5d0)) then
        tmp = t_2
    else if (t <= 1.65d-239) then
        tmp = t_1
    else if (t <= 4.1d-162) then
        tmp = x + (y * (a / z))
    else if (t <= 7.5d+104) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = x - (y * a);
	double t_2 = x - (a * (y / t));
	double tmp;
	if (t <= -12.5) {
		tmp = t_2;
	} else if (t <= 1.65e-239) {
		tmp = t_1;
	} else if (t <= 4.1e-162) {
		tmp = x + (y * (a / z));
	} else if (t <= 7.5e+104) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = x - (y * a)
	t_2 = x - (a * (y / t))
	tmp = 0
	if t <= -12.5:
		tmp = t_2
	elif t <= 1.65e-239:
		tmp = t_1
	elif t <= 4.1e-162:
		tmp = x + (y * (a / z))
	elif t <= 7.5e+104:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(x - Float64(y * a))
	t_2 = Float64(x - Float64(a * Float64(y / t)))
	tmp = 0.0
	if (t <= -12.5)
		tmp = t_2;
	elseif (t <= 1.65e-239)
		tmp = t_1;
	elseif (t <= 4.1e-162)
		tmp = Float64(x + Float64(y * Float64(a / z)));
	elseif (t <= 7.5e+104)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = x - (y * a);
	t_2 = x - (a * (y / t));
	tmp = 0.0;
	if (t <= -12.5)
		tmp = t_2;
	elseif (t <= 1.65e-239)
		tmp = t_1;
	elseif (t <= 4.1e-162)
		tmp = x + (y * (a / z));
	elseif (t <= 7.5e+104)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(y * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(a * N[(y / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -12.5], t$95$2, If[LessEqual[t, 1.65e-239], t$95$1, If[LessEqual[t, 4.1e-162], N[(x + N[(y * N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 7.5e+104], t$95$1, t$95$2]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 4: 86.7% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -1.3 \cdot 10^{+162} \lor \neg \left(z \leq 2.9 \cdot 10^{+60}\right):\\ \;\;\;\;x + \frac{z - y}{\frac{-z}{a}}\\ \mathbf{else}:\\ \;\;\;\;x - y \cdot \frac{a}{t + \left(1 - z\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (or (<= z -1.3e+162) (not (<= z 2.9e+60)))
   (+ x (/ (- z y) (/ (- z) a)))
   (- x (* y (/ a (+ t (- 1.0 z)))))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((z <= -1.3e+162) || !(z <= 2.9e+60)) {
		tmp = x + ((z - y) / (-z / a));
	} else {
		tmp = x - (y * (a / (t + (1.0 - z))));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if ((z <= (-1.3d+162)) .or. (.not. (z <= 2.9d+60))) then
        tmp = x + ((z - y) / (-z / a))
    else
        tmp = x - (y * (a / (t + (1.0d0 - z))))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((z <= -1.3e+162) || !(z <= 2.9e+60)) {
		tmp = x + ((z - y) / (-z / a));
	} else {
		tmp = x - (y * (a / (t + (1.0 - z))));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if (z <= -1.3e+162) or not (z <= 2.9e+60):
		tmp = x + ((z - y) / (-z / a))
	else:
		tmp = x - (y * (a / (t + (1.0 - z))))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if ((z <= -1.3e+162) || !(z <= 2.9e+60))
		tmp = Float64(x + Float64(Float64(z - y) / Float64(Float64(-z) / a)));
	else
		tmp = Float64(x - Float64(y * Float64(a / Float64(t + Float64(1.0 - z)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if ((z <= -1.3e+162) || ~((z <= 2.9e+60)))
		tmp = x + ((z - y) / (-z / a));
	else
		tmp = x - (y * (a / (t + (1.0 - z))));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -1.3e+162], N[Not[LessEqual[z, 2.9e+60]], $MachinePrecision]], N[(x + N[(N[(z - y), $MachinePrecision] / N[((-z) / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - N[(y * N[(a / N[(t + N[(1.0 - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 5: 91.8% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -1.25 \cdot 10^{+45} \lor \neg \left(t \leq 8 \cdot 10^{+76}\right):\\ \;\;\;\;x + \frac{a}{t} \cdot \left(z - y\right)\\ \mathbf{else}:\\ \;\;\;\;x + a \cdot \frac{z - y}{1 - z}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (or (<= t -1.25e+45) (not (<= t 8e+76)))
   (+ x (* (/ a t) (- z y)))
   (+ x (* a (/ (- z y) (- 1.0 z))))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((t <= -1.25e+45) || !(t <= 8e+76)) {
		tmp = x + ((a / t) * (z - y));
	} else {
		tmp = x + (a * ((z - y) / (1.0 - z)));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if ((t <= (-1.25d+45)) .or. (.not. (t <= 8d+76))) then
        tmp = x + ((a / t) * (z - y))
    else
        tmp = x + (a * ((z - y) / (1.0d0 - z)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((t <= -1.25e+45) || !(t <= 8e+76)) {
		tmp = x + ((a / t) * (z - y));
	} else {
		tmp = x + (a * ((z - y) / (1.0 - z)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if (t <= -1.25e+45) or not (t <= 8e+76):
		tmp = x + ((a / t) * (z - y))
	else:
		tmp = x + (a * ((z - y) / (1.0 - z)))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if ((t <= -1.25e+45) || !(t <= 8e+76))
		tmp = Float64(x + Float64(Float64(a / t) * Float64(z - y)));
	else
		tmp = Float64(x + Float64(a * Float64(Float64(z - y) / Float64(1.0 - z))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if ((t <= -1.25e+45) || ~((t <= 8e+76)))
		tmp = x + ((a / t) * (z - y));
	else
		tmp = x + (a * ((z - y) / (1.0 - z)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[Or[LessEqual[t, -1.25e+45], N[Not[LessEqual[t, 8e+76]], $MachinePrecision]], N[(x + N[(N[(a / t), $MachinePrecision] * N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(a * N[(N[(z - y), $MachinePrecision] / N[(1.0 - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 6: 87.2% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -44000000000 \lor \neg \left(z \leq 3.05 \cdot 10^{+29}\right):\\ \;\;\;\;x + \frac{z - y}{\frac{-z}{a}}\\ \mathbf{else}:\\ \;\;\;\;x - \frac{a}{\frac{t + 1}{y}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (or (<= z -44000000000.0) (not (<= z 3.05e+29)))
   (+ x (/ (- z y) (/ (- z) a)))
   (- x (/ a (/ (+ t 1.0) y)))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((z <= -44000000000.0) || !(z <= 3.05e+29)) {
		tmp = x + ((z - y) / (-z / a));
	} else {
		tmp = x - (a / ((t + 1.0) / y));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if ((z <= (-44000000000.0d0)) .or. (.not. (z <= 3.05d+29))) then
        tmp = x + ((z - y) / (-z / a))
    else
        tmp = x - (a / ((t + 1.0d0) / y))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((z <= -44000000000.0) || !(z <= 3.05e+29)) {
		tmp = x + ((z - y) / (-z / a));
	} else {
		tmp = x - (a / ((t + 1.0) / y));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if (z <= -44000000000.0) or not (z <= 3.05e+29):
		tmp = x + ((z - y) / (-z / a))
	else:
		tmp = x - (a / ((t + 1.0) / y))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if ((z <= -44000000000.0) || !(z <= 3.05e+29))
		tmp = Float64(x + Float64(Float64(z - y) / Float64(Float64(-z) / a)));
	else
		tmp = Float64(x - Float64(a / Float64(Float64(t + 1.0) / y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if ((z <= -44000000000.0) || ~((z <= 3.05e+29)))
		tmp = x + ((z - y) / (-z / a));
	else
		tmp = x - (a / ((t + 1.0) / y));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -44000000000.0], N[Not[LessEqual[z, 3.05e+29]], $MachinePrecision]], N[(x + N[(N[(z - y), $MachinePrecision] / N[((-z) / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - N[(a / N[(N[(t + 1.0), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 7: 76.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -5.2 \cdot 10^{+33} \lor \neg \left(t \leq 3.65 \cdot 10^{+71}\right):\\ \;\;\;\;x - a \cdot \frac{y}{t}\\ \mathbf{else}:\\ \;\;\;\;x - y \cdot \frac{a}{1 - z}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (or (<= t -5.2e+33) (not (<= t 3.65e+71)))
   (- x (* a (/ y t)))
   (- x (* y (/ a (- 1.0 z))))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((t <= -5.2e+33) || !(t <= 3.65e+71)) {
		tmp = x - (a * (y / t));
	} else {
		tmp = x - (y * (a / (1.0 - z)));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if ((t <= (-5.2d+33)) .or. (.not. (t <= 3.65d+71))) then
        tmp = x - (a * (y / t))
    else
        tmp = x - (y * (a / (1.0d0 - z)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((t <= -5.2e+33) || !(t <= 3.65e+71)) {
		tmp = x - (a * (y / t));
	} else {
		tmp = x - (y * (a / (1.0 - z)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if (t <= -5.2e+33) or not (t <= 3.65e+71):
		tmp = x - (a * (y / t))
	else:
		tmp = x - (y * (a / (1.0 - z)))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if ((t <= -5.2e+33) || !(t <= 3.65e+71))
		tmp = Float64(x - Float64(a * Float64(y / t)));
	else
		tmp = Float64(x - Float64(y * Float64(a / Float64(1.0 - z))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if ((t <= -5.2e+33) || ~((t <= 3.65e+71)))
		tmp = x - (a * (y / t));
	else
		tmp = x - (y * (a / (1.0 - z)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[Or[LessEqual[t, -5.2e+33], N[Not[LessEqual[t, 3.65e+71]], $MachinePrecision]], N[(x - N[(a * N[(y / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - N[(y * N[(a / N[(1.0 - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 8: 78.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -1.35 \cdot 10^{+38} \lor \neg \left(t \leq 7.2 \cdot 10^{+76}\right):\\ \;\;\;\;x + \frac{a}{t} \cdot \left(z - y\right)\\ \mathbf{else}:\\ \;\;\;\;x - y \cdot \frac{a}{1 - z}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (or (<= t -1.35e+38) (not (<= t 7.2e+76)))
   (+ x (* (/ a t) (- z y)))
   (- x (* y (/ a (- 1.0 z))))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((t <= -1.35e+38) || !(t <= 7.2e+76)) {
		tmp = x + ((a / t) * (z - y));
	} else {
		tmp = x - (y * (a / (1.0 - z)));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if ((t <= (-1.35d+38)) .or. (.not. (t <= 7.2d+76))) then
        tmp = x + ((a / t) * (z - y))
    else
        tmp = x - (y * (a / (1.0d0 - z)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((t <= -1.35e+38) || !(t <= 7.2e+76)) {
		tmp = x + ((a / t) * (z - y));
	} else {
		tmp = x - (y * (a / (1.0 - z)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if (t <= -1.35e+38) or not (t <= 7.2e+76):
		tmp = x + ((a / t) * (z - y))
	else:
		tmp = x - (y * (a / (1.0 - z)))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if ((t <= -1.35e+38) || !(t <= 7.2e+76))
		tmp = Float64(x + Float64(Float64(a / t) * Float64(z - y)));
	else
		tmp = Float64(x - Float64(y * Float64(a / Float64(1.0 - z))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if ((t <= -1.35e+38) || ~((t <= 7.2e+76)))
		tmp = x + ((a / t) * (z - y));
	else
		tmp = x - (y * (a / (1.0 - z)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[Or[LessEqual[t, -1.35e+38], N[Not[LessEqual[t, 7.2e+76]], $MachinePrecision]], N[(x + N[(N[(a / t), $MachinePrecision] * N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - N[(y * N[(a / N[(1.0 - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 9: 83.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -4.6 \cdot 10^{+163} \lor \neg \left(z \leq 2.65 \cdot 10^{+51}\right):\\ \;\;\;\;x - a\\ \mathbf{else}:\\ \;\;\;\;x - \frac{a}{\frac{t + 1}{y}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (or (<= z -4.6e+163) (not (<= z 2.65e+51)))
   (- x a)
   (- x (/ a (/ (+ t 1.0) y)))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((z <= -4.6e+163) || !(z <= 2.65e+51)) {
		tmp = x - a;
	} else {
		tmp = x - (a / ((t + 1.0) / y));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if ((z <= (-4.6d+163)) .or. (.not. (z <= 2.65d+51))) then
        tmp = x - a
    else
        tmp = x - (a / ((t + 1.0d0) / y))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((z <= -4.6e+163) || !(z <= 2.65e+51)) {
		tmp = x - a;
	} else {
		tmp = x - (a / ((t + 1.0) / y));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if (z <= -4.6e+163) or not (z <= 2.65e+51):
		tmp = x - a
	else:
		tmp = x - (a / ((t + 1.0) / y))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if ((z <= -4.6e+163) || !(z <= 2.65e+51))
		tmp = Float64(x - a);
	else
		tmp = Float64(x - Float64(a / Float64(Float64(t + 1.0) / y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if ((z <= -4.6e+163) || ~((z <= 2.65e+51)))
		tmp = x - a;
	else
		tmp = x - (a / ((t + 1.0) / y));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -4.6e+163], N[Not[LessEqual[z, 2.65e+51]], $MachinePrecision]], N[(x - a), $MachinePrecision], N[(x - N[(a / N[(N[(t + 1.0), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 10: 72.2% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -4 \cdot 10^{+114} \lor \neg \left(z \leq 1.06 \cdot 10^{+28}\right):\\ \;\;\;\;x - a\\ \mathbf{else}:\\ \;\;\;\;x - y \cdot a\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (or (<= z -4e+114) (not (<= z 1.06e+28))) (- x a) (- x (* y a))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((z <= -4e+114) || !(z <= 1.06e+28)) {
		tmp = x - a;
	} else {
		tmp = x - (y * a);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if ((z <= (-4d+114)) .or. (.not. (z <= 1.06d+28))) then
        tmp = x - a
    else
        tmp = x - (y * a)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((z <= -4e+114) || !(z <= 1.06e+28)) {
		tmp = x - a;
	} else {
		tmp = x - (y * a);
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if (z <= -4e+114) or not (z <= 1.06e+28):
		tmp = x - a
	else:
		tmp = x - (y * a)
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if ((z <= -4e+114) || !(z <= 1.06e+28))
		tmp = Float64(x - a);
	else
		tmp = Float64(x - Float64(y * a));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if ((z <= -4e+114) || ~((z <= 1.06e+28)))
		tmp = x - a;
	else
		tmp = x - (y * a);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -4e+114], N[Not[LessEqual[z, 1.06e+28]], $MachinePrecision]], N[(x - a), $MachinePrecision], N[(x - N[(y * a), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 11: 68.8% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -3.6 \cdot 10^{-12}:\\ \;\;\;\;x + a \cdot \frac{y}{z}\\ \mathbf{elif}\;z \leq 3.1 \cdot 10^{+28}:\\ \;\;\;\;x - y \cdot a\\ \mathbf{else}:\\ \;\;\;\;x - a\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= z -3.6e-12)
   (+ x (* a (/ y z)))
   (if (<= z 3.1e+28) (- x (* y a)) (- x a))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -3.6e-12) {
		tmp = x + (a * (y / z));
	} else if (z <= 3.1e+28) {
		tmp = x - (y * a);
	} else {
		tmp = x - a;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if (z <= (-3.6d-12)) then
        tmp = x + (a * (y / z))
    else if (z <= 3.1d+28) then
        tmp = x - (y * a)
    else
        tmp = x - a
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -3.6e-12) {
		tmp = x + (a * (y / z));
	} else if (z <= 3.1e+28) {
		tmp = x - (y * a);
	} else {
		tmp = x - a;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if z <= -3.6e-12:
		tmp = x + (a * (y / z))
	elif z <= 3.1e+28:
		tmp = x - (y * a)
	else:
		tmp = x - a
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (z <= -3.6e-12)
		tmp = Float64(x + Float64(a * Float64(y / z)));
	elseif (z <= 3.1e+28)
		tmp = Float64(x - Float64(y * a));
	else
		tmp = Float64(x - a);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (z <= -3.6e-12)
		tmp = x + (a * (y / z));
	elseif (z <= 3.1e+28)
		tmp = x - (y * a);
	else
		tmp = x - a;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[z, -3.6e-12], N[(x + N[(a * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.1e+28], N[(x - N[(y * a), $MachinePrecision]), $MachinePrecision], N[(x - a), $MachinePrecision]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 12: 66.1% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -3.7 \cdot 10^{+114} \lor \neg \left(z \leq 2.9 \cdot 10^{+60}\right):\\ \;\;\;\;x - a\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (or (<= z -3.7e+114) (not (<= z 2.9e+60))) (- x a) x))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((z <= -3.7e+114) || !(z <= 2.9e+60)) {
		tmp = x - a;
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if ((z <= (-3.7d+114)) .or. (.not. (z <= 2.9d+60))) then
        tmp = x - a
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((z <= -3.7e+114) || !(z <= 2.9e+60)) {
		tmp = x - a;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if (z <= -3.7e+114) or not (z <= 2.9e+60):
		tmp = x - a
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if ((z <= -3.7e+114) || !(z <= 2.9e+60))
		tmp = Float64(x - a);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if ((z <= -3.7e+114) || ~((z <= 2.9e+60)))
		tmp = x - a;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -3.7e+114], N[Not[LessEqual[z, 2.9e+60]], $MachinePrecision]], N[(x - a), $MachinePrecision], x]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 13: 54.4% accurate, 13.0× speedup

Math

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

FPCore

(FPCore (x y z t a) :precision binary64 x)

C

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

Fortran

real(8) function code(x, y, z, t, a)
    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
    code = x
end function

Java

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

Python

def code(x, y, z, t, a):
	return x

Julia

function code(x, y, z, t, a)
	return x
end

MATLAB

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

Wolfram

code[x_, y_, z_, t_, a_] := x

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Developer target: 99.8% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z t a)
 :precision binary64
 (- x (* (/ (- y z) (+ (- t z) 1.0)) a)))

C

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

Fortran

real(8) function code(x, y, z, t, a)
    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
    code = x - (((y - z) / ((t - z) + 1.0d0)) * a)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Reproduce

herbie shell --seed 2023343 
(FPCore (x y z t a)
  :name "Graphics.Rendering.Chart.SparkLine:renderSparkLine from Chart-1.5.3"
  :precision binary64

  :herbie-target
  (- x (* (/ (- y z) (+ (- t z) 1.0)) a))

  (- x (/ (- y z) (/ (+ (- t z) 1.0) a))))