Numeric.Signal.Multichannel:$cput from hsignal-0.2.7.1

Percentage Accurate: 97.0% → 97.7%

Time: 13.6s

Alternatives: 14

Speedup: 0.5×

Specification

Math

\[\begin{array}{l} \\ \frac{x - y}{z - y} \cdot t \end{array} \]

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = ((x - y) / (z - y)) * t
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 97.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{x - y}{z - y} \cdot t \end{array} \]

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = ((x - y) / (z - y)) * t
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 97.7% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{x - y}{z - y}\\ \mathbf{if}\;t_1 \leq 10^{+242}:\\ \;\;\;\;t_1 \cdot t\\ \mathbf{else}:\\ \;\;\;\;\frac{x \cdot t}{z - y}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (/ (- x y) (- z y))))
   (if (<= t_1 1e+242) (* t_1 t) (/ (* x t) (- z y)))))

C

double code(double x, double y, double z, double t) {
	double t_1 = (x - y) / (z - y);
	double tmp;
	if (t_1 <= 1e+242) {
		tmp = t_1 * t;
	} else {
		tmp = (x * t) / (z - y);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (x - y) / (z - y)
    if (t_1 <= 1d+242) then
        tmp = t_1 * t
    else
        tmp = (x * t) / (z - y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = (x - y) / (z - y);
	double tmp;
	if (t_1 <= 1e+242) {
		tmp = t_1 * t;
	} else {
		tmp = (x * t) / (z - y);
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = (x - y) / (z - y)
	tmp = 0
	if t_1 <= 1e+242:
		tmp = t_1 * t
	else:
		tmp = (x * t) / (z - y)
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(Float64(x - y) / Float64(z - y))
	tmp = 0.0
	if (t_1 <= 1e+242)
		tmp = Float64(t_1 * t);
	else
		tmp = Float64(Float64(x * t) / Float64(z - y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = (x - y) / (z - y);
	tmp = 0.0;
	if (t_1 <= 1e+242)
		tmp = t_1 * t;
	else
		tmp = (x * t) / (z - y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(x - y), $MachinePrecision] / N[(z - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 1e+242], N[(t$95$1 * t), $MachinePrecision], N[(N[(x * t), $MachinePrecision] / N[(z - y), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 2: 57.7% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := t \cdot \frac{-x}{y}\\ \mathbf{if}\;y \leq -1.9 \cdot 10^{+161}:\\ \;\;\;\;t\\ \mathbf{elif}\;y \leq -1.4 \cdot 10^{-24}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 8 \cdot 10^{-298}:\\ \;\;\;\;x \cdot \frac{t}{z}\\ \mathbf{elif}\;y \leq 2.6 \cdot 10^{-64}:\\ \;\;\;\;t \cdot \frac{x}{z}\\ \mathbf{elif}\;y \leq 3.7 \cdot 10^{-13}:\\ \;\;\;\;t\\ \mathbf{elif}\;y \leq 6.4 \cdot 10^{+20}:\\ \;\;\;\;\frac{t}{\frac{z}{x}}\\ \mathbf{elif}\;y \leq 2.3 \cdot 10^{+63}:\\ \;\;\;\;t\\ \mathbf{elif}\;y \leq 3.1 \cdot 10^{+100}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (* t (/ (- x) y))))
   (if (<= y -1.9e+161)
     t
     (if (<= y -1.4e-24)
       t_1
       (if (<= y 8e-298)
         (* x (/ t z))
         (if (<= y 2.6e-64)
           (* t (/ x z))
           (if (<= y 3.7e-13)
             t
             (if (<= y 6.4e+20)
               (/ t (/ z x))
               (if (<= y 2.3e+63) t (if (<= y 3.1e+100) t_1 t))))))))))

C

double code(double x, double y, double z, double t) {
	double t_1 = t * (-x / y);
	double tmp;
	if (y <= -1.9e+161) {
		tmp = t;
	} else if (y <= -1.4e-24) {
		tmp = t_1;
	} else if (y <= 8e-298) {
		tmp = x * (t / z);
	} else if (y <= 2.6e-64) {
		tmp = t * (x / z);
	} else if (y <= 3.7e-13) {
		tmp = t;
	} else if (y <= 6.4e+20) {
		tmp = t / (z / x);
	} else if (y <= 2.3e+63) {
		tmp = t;
	} else if (y <= 3.1e+100) {
		tmp = t_1;
	} else {
		tmp = t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: t_1
    real(8) :: tmp
    t_1 = t * (-x / y)
    if (y <= (-1.9d+161)) then
        tmp = t
    else if (y <= (-1.4d-24)) then
        tmp = t_1
    else if (y <= 8d-298) then
        tmp = x * (t / z)
    else if (y <= 2.6d-64) then
        tmp = t * (x / z)
    else if (y <= 3.7d-13) then
        tmp = t
    else if (y <= 6.4d+20) then
        tmp = t / (z / x)
    else if (y <= 2.3d+63) then
        tmp = t
    else if (y <= 3.1d+100) then
        tmp = t_1
    else
        tmp = t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = t * (-x / y);
	double tmp;
	if (y <= -1.9e+161) {
		tmp = t;
	} else if (y <= -1.4e-24) {
		tmp = t_1;
	} else if (y <= 8e-298) {
		tmp = x * (t / z);
	} else if (y <= 2.6e-64) {
		tmp = t * (x / z);
	} else if (y <= 3.7e-13) {
		tmp = t;
	} else if (y <= 6.4e+20) {
		tmp = t / (z / x);
	} else if (y <= 2.3e+63) {
		tmp = t;
	} else if (y <= 3.1e+100) {
		tmp = t_1;
	} else {
		tmp = t;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = t * (-x / y)
	tmp = 0
	if y <= -1.9e+161:
		tmp = t
	elif y <= -1.4e-24:
		tmp = t_1
	elif y <= 8e-298:
		tmp = x * (t / z)
	elif y <= 2.6e-64:
		tmp = t * (x / z)
	elif y <= 3.7e-13:
		tmp = t
	elif y <= 6.4e+20:
		tmp = t / (z / x)
	elif y <= 2.3e+63:
		tmp = t
	elif y <= 3.1e+100:
		tmp = t_1
	else:
		tmp = t
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(t * Float64(Float64(-x) / y))
	tmp = 0.0
	if (y <= -1.9e+161)
		tmp = t;
	elseif (y <= -1.4e-24)
		tmp = t_1;
	elseif (y <= 8e-298)
		tmp = Float64(x * Float64(t / z));
	elseif (y <= 2.6e-64)
		tmp = Float64(t * Float64(x / z));
	elseif (y <= 3.7e-13)
		tmp = t;
	elseif (y <= 6.4e+20)
		tmp = Float64(t / Float64(z / x));
	elseif (y <= 2.3e+63)
		tmp = t;
	elseif (y <= 3.1e+100)
		tmp = t_1;
	else
		tmp = t;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = t * (-x / y);
	tmp = 0.0;
	if (y <= -1.9e+161)
		tmp = t;
	elseif (y <= -1.4e-24)
		tmp = t_1;
	elseif (y <= 8e-298)
		tmp = x * (t / z);
	elseif (y <= 2.6e-64)
		tmp = t * (x / z);
	elseif (y <= 3.7e-13)
		tmp = t;
	elseif (y <= 6.4e+20)
		tmp = t / (z / x);
	elseif (y <= 2.3e+63)
		tmp = t;
	elseif (y <= 3.1e+100)
		tmp = t_1;
	else
		tmp = t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(t * N[((-x) / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.9e+161], t, If[LessEqual[y, -1.4e-24], t$95$1, If[LessEqual[y, 8e-298], N[(x * N[(t / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.6e-64], N[(t * N[(x / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.7e-13], t, If[LessEqual[y, 6.4e+20], N[(t / N[(z / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.3e+63], t, If[LessEqual[y, 3.1e+100], t$95$1, t]]]]]]]]]

Derivation

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

Alternative 3: 74.8% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -155:\\ \;\;\;\;t \cdot \frac{y}{y - z}\\ \mathbf{elif}\;y \leq 2.2 \cdot 10^{-152}:\\ \;\;\;\;x \cdot \frac{t}{z - y}\\ \mathbf{elif}\;y \leq 1.02 \cdot 10^{-64}:\\ \;\;\;\;t \cdot \frac{x - y}{z}\\ \mathbf{elif}\;y \leq 2.3 \cdot 10^{-11} \lor \neg \left(y \leq 6.2 \cdot 10^{+14}\right):\\ \;\;\;\;t - t \cdot \frac{x}{y}\\ \mathbf{else}:\\ \;\;\;\;t \cdot \frac{x}{z - y}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= y -155.0)
   (* t (/ y (- y z)))
   (if (<= y 2.2e-152)
     (* x (/ t (- z y)))
     (if (<= y 1.02e-64)
       (* t (/ (- x y) z))
       (if (or (<= y 2.3e-11) (not (<= y 6.2e+14)))
         (- t (* t (/ x y)))
         (* t (/ x (- z y))))))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -155.0) {
		tmp = t * (y / (y - z));
	} else if (y <= 2.2e-152) {
		tmp = x * (t / (z - y));
	} else if (y <= 1.02e-64) {
		tmp = t * ((x - y) / z);
	} else if ((y <= 2.3e-11) || !(y <= 6.2e+14)) {
		tmp = t - (t * (x / y));
	} else {
		tmp = t * (x / (z - y));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if (y <= (-155.0d0)) then
        tmp = t * (y / (y - z))
    else if (y <= 2.2d-152) then
        tmp = x * (t / (z - y))
    else if (y <= 1.02d-64) then
        tmp = t * ((x - y) / z)
    else if ((y <= 2.3d-11) .or. (.not. (y <= 6.2d+14))) then
        tmp = t - (t * (x / y))
    else
        tmp = t * (x / (z - y))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -155.0) {
		tmp = t * (y / (y - z));
	} else if (y <= 2.2e-152) {
		tmp = x * (t / (z - y));
	} else if (y <= 1.02e-64) {
		tmp = t * ((x - y) / z);
	} else if ((y <= 2.3e-11) || !(y <= 6.2e+14)) {
		tmp = t - (t * (x / y));
	} else {
		tmp = t * (x / (z - y));
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if y <= -155.0:
		tmp = t * (y / (y - z))
	elif y <= 2.2e-152:
		tmp = x * (t / (z - y))
	elif y <= 1.02e-64:
		tmp = t * ((x - y) / z)
	elif (y <= 2.3e-11) or not (y <= 6.2e+14):
		tmp = t - (t * (x / y))
	else:
		tmp = t * (x / (z - y))
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (y <= -155.0)
		tmp = Float64(t * Float64(y / Float64(y - z)));
	elseif (y <= 2.2e-152)
		tmp = Float64(x * Float64(t / Float64(z - y)));
	elseif (y <= 1.02e-64)
		tmp = Float64(t * Float64(Float64(x - y) / z));
	elseif ((y <= 2.3e-11) || !(y <= 6.2e+14))
		tmp = Float64(t - Float64(t * Float64(x / y)));
	else
		tmp = Float64(t * Float64(x / Float64(z - y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (y <= -155.0)
		tmp = t * (y / (y - z));
	elseif (y <= 2.2e-152)
		tmp = x * (t / (z - y));
	elseif (y <= 1.02e-64)
		tmp = t * ((x - y) / z);
	elseif ((y <= 2.3e-11) || ~((y <= 6.2e+14)))
		tmp = t - (t * (x / y));
	else
		tmp = t * (x / (z - y));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[y, -155.0], N[(t * N[(y / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.2e-152], N[(x * N[(t / N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.02e-64], N[(t * N[(N[(x - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[y, 2.3e-11], N[Not[LessEqual[y, 6.2e+14]], $MachinePrecision]], N[(t - N[(t * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t * N[(x / N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

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

Alternative 4: 74.8% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -225:\\ \;\;\;\;t \cdot \frac{y}{y - z}\\ \mathbf{elif}\;y \leq 9.2 \cdot 10^{-153}:\\ \;\;\;\;x \cdot \frac{t}{z - y}\\ \mathbf{elif}\;y \leq 8.5 \cdot 10^{-65}:\\ \;\;\;\;\frac{t}{\frac{z}{x - y}}\\ \mathbf{elif}\;y \leq 3 \cdot 10^{-12} \lor \neg \left(y \leq 2.7 \cdot 10^{+16}\right):\\ \;\;\;\;t - t \cdot \frac{x}{y}\\ \mathbf{else}:\\ \;\;\;\;t \cdot \frac{x}{z - y}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= y -225.0)
   (* t (/ y (- y z)))
   (if (<= y 9.2e-153)
     (* x (/ t (- z y)))
     (if (<= y 8.5e-65)
       (/ t (/ z (- x y)))
       (if (or (<= y 3e-12) (not (<= y 2.7e+16)))
         (- t (* t (/ x y)))
         (* t (/ x (- z y))))))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -225.0) {
		tmp = t * (y / (y - z));
	} else if (y <= 9.2e-153) {
		tmp = x * (t / (z - y));
	} else if (y <= 8.5e-65) {
		tmp = t / (z / (x - y));
	} else if ((y <= 3e-12) || !(y <= 2.7e+16)) {
		tmp = t - (t * (x / y));
	} else {
		tmp = t * (x / (z - y));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if (y <= (-225.0d0)) then
        tmp = t * (y / (y - z))
    else if (y <= 9.2d-153) then
        tmp = x * (t / (z - y))
    else if (y <= 8.5d-65) then
        tmp = t / (z / (x - y))
    else if ((y <= 3d-12) .or. (.not. (y <= 2.7d+16))) then
        tmp = t - (t * (x / y))
    else
        tmp = t * (x / (z - y))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -225.0) {
		tmp = t * (y / (y - z));
	} else if (y <= 9.2e-153) {
		tmp = x * (t / (z - y));
	} else if (y <= 8.5e-65) {
		tmp = t / (z / (x - y));
	} else if ((y <= 3e-12) || !(y <= 2.7e+16)) {
		tmp = t - (t * (x / y));
	} else {
		tmp = t * (x / (z - y));
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if y <= -225.0:
		tmp = t * (y / (y - z))
	elif y <= 9.2e-153:
		tmp = x * (t / (z - y))
	elif y <= 8.5e-65:
		tmp = t / (z / (x - y))
	elif (y <= 3e-12) or not (y <= 2.7e+16):
		tmp = t - (t * (x / y))
	else:
		tmp = t * (x / (z - y))
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (y <= -225.0)
		tmp = Float64(t * Float64(y / Float64(y - z)));
	elseif (y <= 9.2e-153)
		tmp = Float64(x * Float64(t / Float64(z - y)));
	elseif (y <= 8.5e-65)
		tmp = Float64(t / Float64(z / Float64(x - y)));
	elseif ((y <= 3e-12) || !(y <= 2.7e+16))
		tmp = Float64(t - Float64(t * Float64(x / y)));
	else
		tmp = Float64(t * Float64(x / Float64(z - y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (y <= -225.0)
		tmp = t * (y / (y - z));
	elseif (y <= 9.2e-153)
		tmp = x * (t / (z - y));
	elseif (y <= 8.5e-65)
		tmp = t / (z / (x - y));
	elseif ((y <= 3e-12) || ~((y <= 2.7e+16)))
		tmp = t - (t * (x / y));
	else
		tmp = t * (x / (z - y));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[y, -225.0], N[(t * N[(y / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 9.2e-153], N[(x * N[(t / N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 8.5e-65], N[(t / N[(z / N[(x - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[y, 3e-12], N[Not[LessEqual[y, 2.7e+16]], $MachinePrecision]], N[(t - N[(t * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t * N[(x / N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

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

Alternative 5: 73.1% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -5 \cdot 10^{+52}:\\ \;\;\;\;x \cdot \frac{t}{z - y}\\ \mathbf{elif}\;x \leq 7.6 \cdot 10^{-51} \lor \neg \left(x \leq 1.16 \cdot 10^{+17}\right) \land x \leq 2.5 \cdot 10^{+60}:\\ \;\;\;\;t \cdot \frac{y}{y - z}\\ \mathbf{else}:\\ \;\;\;\;t \cdot \frac{x}{z - y}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= x -5e+52)
   (* x (/ t (- z y)))
   (if (or (<= x 7.6e-51) (and (not (<= x 1.16e+17)) (<= x 2.5e+60)))
     (* t (/ y (- y z)))
     (* t (/ x (- z y))))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (x <= -5e+52) {
		tmp = x * (t / (z - y));
	} else if ((x <= 7.6e-51) || (!(x <= 1.16e+17) && (x <= 2.5e+60))) {
		tmp = t * (y / (y - z));
	} else {
		tmp = t * (x / (z - y));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if (x <= (-5d+52)) then
        tmp = x * (t / (z - y))
    else if ((x <= 7.6d-51) .or. (.not. (x <= 1.16d+17)) .and. (x <= 2.5d+60)) then
        tmp = t * (y / (y - z))
    else
        tmp = t * (x / (z - y))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (x <= -5e+52) {
		tmp = x * (t / (z - y));
	} else if ((x <= 7.6e-51) || (!(x <= 1.16e+17) && (x <= 2.5e+60))) {
		tmp = t * (y / (y - z));
	} else {
		tmp = t * (x / (z - y));
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if x <= -5e+52:
		tmp = x * (t / (z - y))
	elif (x <= 7.6e-51) or (not (x <= 1.16e+17) and (x <= 2.5e+60)):
		tmp = t * (y / (y - z))
	else:
		tmp = t * (x / (z - y))
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (x <= -5e+52)
		tmp = Float64(x * Float64(t / Float64(z - y)));
	elseif ((x <= 7.6e-51) || (!(x <= 1.16e+17) && (x <= 2.5e+60)))
		tmp = Float64(t * Float64(y / Float64(y - z)));
	else
		tmp = Float64(t * Float64(x / Float64(z - y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (x <= -5e+52)
		tmp = x * (t / (z - y));
	elseif ((x <= 7.6e-51) || (~((x <= 1.16e+17)) && (x <= 2.5e+60)))
		tmp = t * (y / (y - z));
	else
		tmp = t * (x / (z - y));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[x, -5e+52], N[(x * N[(t / N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[x, 7.6e-51], And[N[Not[LessEqual[x, 1.16e+17]], $MachinePrecision], LessEqual[x, 2.5e+60]]], N[(t * N[(y / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t * N[(x / N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 6: 66.6% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -1.26 \cdot 10^{+167}:\\ \;\;\;\;t\\ \mathbf{elif}\;y \leq 1.8 \cdot 10^{+45}:\\ \;\;\;\;x \cdot \frac{t}{z - y}\\ \mathbf{elif}\;y \leq 5.5 \cdot 10^{+63}:\\ \;\;\;\;t\\ \mathbf{elif}\;y \leq 2.3 \cdot 10^{+101}:\\ \;\;\;\;t \cdot \frac{x}{z - y}\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= y -1.26e+167)
   t
   (if (<= y 1.8e+45)
     (* x (/ t (- z y)))
     (if (<= y 5.5e+63) t (if (<= y 2.3e+101) (* t (/ x (- z y))) t)))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -1.26e+167) {
		tmp = t;
	} else if (y <= 1.8e+45) {
		tmp = x * (t / (z - y));
	} else if (y <= 5.5e+63) {
		tmp = t;
	} else if (y <= 2.3e+101) {
		tmp = t * (x / (z - y));
	} else {
		tmp = t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if (y <= (-1.26d+167)) then
        tmp = t
    else if (y <= 1.8d+45) then
        tmp = x * (t / (z - y))
    else if (y <= 5.5d+63) then
        tmp = t
    else if (y <= 2.3d+101) then
        tmp = t * (x / (z - y))
    else
        tmp = t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -1.26e+167) {
		tmp = t;
	} else if (y <= 1.8e+45) {
		tmp = x * (t / (z - y));
	} else if (y <= 5.5e+63) {
		tmp = t;
	} else if (y <= 2.3e+101) {
		tmp = t * (x / (z - y));
	} else {
		tmp = t;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if y <= -1.26e+167:
		tmp = t
	elif y <= 1.8e+45:
		tmp = x * (t / (z - y))
	elif y <= 5.5e+63:
		tmp = t
	elif y <= 2.3e+101:
		tmp = t * (x / (z - y))
	else:
		tmp = t
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (y <= -1.26e+167)
		tmp = t;
	elseif (y <= 1.8e+45)
		tmp = Float64(x * Float64(t / Float64(z - y)));
	elseif (y <= 5.5e+63)
		tmp = t;
	elseif (y <= 2.3e+101)
		tmp = Float64(t * Float64(x / Float64(z - y)));
	else
		tmp = t;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (y <= -1.26e+167)
		tmp = t;
	elseif (y <= 1.8e+45)
		tmp = x * (t / (z - y));
	elseif (y <= 5.5e+63)
		tmp = t;
	elseif (y <= 2.3e+101)
		tmp = t * (x / (z - y));
	else
		tmp = t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[y, -1.26e+167], t, If[LessEqual[y, 1.8e+45], N[(x * N[(t / N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.5e+63], t, If[LessEqual[y, 2.3e+101], N[(t * N[(x / N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t]]]]

Derivation

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

Alternative 7: 57.4% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := t \cdot \frac{-y}{z}\\ \mathbf{if}\;y \leq -1.7 \cdot 10^{+73}:\\ \;\;\;\;t\\ \mathbf{elif}\;y \leq -7 \cdot 10^{-8}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 1.15 \cdot 10^{-156}:\\ \;\;\;\;\frac{x}{\frac{z}{t}}\\ \mathbf{elif}\;y \leq 2.6 \cdot 10^{-64}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (* t (/ (- y) z))))
   (if (<= y -1.7e+73)
     t
     (if (<= y -7e-8)
       t_1
       (if (<= y 1.15e-156) (/ x (/ z t)) (if (<= y 2.6e-64) t_1 t))))))

C

double code(double x, double y, double z, double t) {
	double t_1 = t * (-y / z);
	double tmp;
	if (y <= -1.7e+73) {
		tmp = t;
	} else if (y <= -7e-8) {
		tmp = t_1;
	} else if (y <= 1.15e-156) {
		tmp = x / (z / t);
	} else if (y <= 2.6e-64) {
		tmp = t_1;
	} else {
		tmp = t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: t_1
    real(8) :: tmp
    t_1 = t * (-y / z)
    if (y <= (-1.7d+73)) then
        tmp = t
    else if (y <= (-7d-8)) then
        tmp = t_1
    else if (y <= 1.15d-156) then
        tmp = x / (z / t)
    else if (y <= 2.6d-64) then
        tmp = t_1
    else
        tmp = t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = t * (-y / z);
	double tmp;
	if (y <= -1.7e+73) {
		tmp = t;
	} else if (y <= -7e-8) {
		tmp = t_1;
	} else if (y <= 1.15e-156) {
		tmp = x / (z / t);
	} else if (y <= 2.6e-64) {
		tmp = t_1;
	} else {
		tmp = t;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = t * (-y / z)
	tmp = 0
	if y <= -1.7e+73:
		tmp = t
	elif y <= -7e-8:
		tmp = t_1
	elif y <= 1.15e-156:
		tmp = x / (z / t)
	elif y <= 2.6e-64:
		tmp = t_1
	else:
		tmp = t
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(t * Float64(Float64(-y) / z))
	tmp = 0.0
	if (y <= -1.7e+73)
		tmp = t;
	elseif (y <= -7e-8)
		tmp = t_1;
	elseif (y <= 1.15e-156)
		tmp = Float64(x / Float64(z / t));
	elseif (y <= 2.6e-64)
		tmp = t_1;
	else
		tmp = t;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = t * (-y / z);
	tmp = 0.0;
	if (y <= -1.7e+73)
		tmp = t;
	elseif (y <= -7e-8)
		tmp = t_1;
	elseif (y <= 1.15e-156)
		tmp = x / (z / t);
	elseif (y <= 2.6e-64)
		tmp = t_1;
	else
		tmp = t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(t * N[((-y) / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.7e+73], t, If[LessEqual[y, -7e-8], t$95$1, If[LessEqual[y, 1.15e-156], N[(x / N[(z / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.6e-64], t$95$1, t]]]]]

Derivation

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

Alternative 8: 57.4% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{-t}{\frac{z}{y}}\\ \mathbf{if}\;y \leq -1.42 \cdot 10^{+73}:\\ \;\;\;\;t\\ \mathbf{elif}\;y \leq -6.5 \cdot 10^{-6}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 1.15 \cdot 10^{-156}:\\ \;\;\;\;\frac{x}{\frac{z}{t}}\\ \mathbf{elif}\;y \leq 1.8 \cdot 10^{-64}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (/ (- t) (/ z y))))
   (if (<= y -1.42e+73)
     t
     (if (<= y -6.5e-6)
       t_1
       (if (<= y 1.15e-156) (/ x (/ z t)) (if (<= y 1.8e-64) t_1 t))))))

C

double code(double x, double y, double z, double t) {
	double t_1 = -t / (z / y);
	double tmp;
	if (y <= -1.42e+73) {
		tmp = t;
	} else if (y <= -6.5e-6) {
		tmp = t_1;
	} else if (y <= 1.15e-156) {
		tmp = x / (z / t);
	} else if (y <= 1.8e-64) {
		tmp = t_1;
	} else {
		tmp = t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: t_1
    real(8) :: tmp
    t_1 = -t / (z / y)
    if (y <= (-1.42d+73)) then
        tmp = t
    else if (y <= (-6.5d-6)) then
        tmp = t_1
    else if (y <= 1.15d-156) then
        tmp = x / (z / t)
    else if (y <= 1.8d-64) then
        tmp = t_1
    else
        tmp = t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = -t / (z / y);
	double tmp;
	if (y <= -1.42e+73) {
		tmp = t;
	} else if (y <= -6.5e-6) {
		tmp = t_1;
	} else if (y <= 1.15e-156) {
		tmp = x / (z / t);
	} else if (y <= 1.8e-64) {
		tmp = t_1;
	} else {
		tmp = t;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = -t / (z / y)
	tmp = 0
	if y <= -1.42e+73:
		tmp = t
	elif y <= -6.5e-6:
		tmp = t_1
	elif y <= 1.15e-156:
		tmp = x / (z / t)
	elif y <= 1.8e-64:
		tmp = t_1
	else:
		tmp = t
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(Float64(-t) / Float64(z / y))
	tmp = 0.0
	if (y <= -1.42e+73)
		tmp = t;
	elseif (y <= -6.5e-6)
		tmp = t_1;
	elseif (y <= 1.15e-156)
		tmp = Float64(x / Float64(z / t));
	elseif (y <= 1.8e-64)
		tmp = t_1;
	else
		tmp = t;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = -t / (z / y);
	tmp = 0.0;
	if (y <= -1.42e+73)
		tmp = t;
	elseif (y <= -6.5e-6)
		tmp = t_1;
	elseif (y <= 1.15e-156)
		tmp = x / (z / t);
	elseif (y <= 1.8e-64)
		tmp = t_1;
	else
		tmp = t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[((-t) / N[(z / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.42e+73], t, If[LessEqual[y, -6.5e-6], t$95$1, If[LessEqual[y, 1.15e-156], N[(x / N[(z / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.8e-64], t$95$1, t]]]]]

Derivation

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

Alternative 9: 66.2% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -1.26 \cdot 10^{+167}:\\ \;\;\;\;t\\ \mathbf{elif}\;y \leq 2.6 \cdot 10^{+44}:\\ \;\;\;\;x \cdot \frac{t}{z - y}\\ \mathbf{elif}\;y \leq 2.7 \cdot 10^{+63}:\\ \;\;\;\;t\\ \mathbf{elif}\;y \leq 2.2 \cdot 10^{+102}:\\ \;\;\;\;t \cdot \frac{-x}{y}\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= y -1.26e+167)
   t
   (if (<= y 2.6e+44)
     (* x (/ t (- z y)))
     (if (<= y 2.7e+63) t (if (<= y 2.2e+102) (* t (/ (- x) y)) t)))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -1.26e+167) {
		tmp = t;
	} else if (y <= 2.6e+44) {
		tmp = x * (t / (z - y));
	} else if (y <= 2.7e+63) {
		tmp = t;
	} else if (y <= 2.2e+102) {
		tmp = t * (-x / y);
	} else {
		tmp = t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if (y <= (-1.26d+167)) then
        tmp = t
    else if (y <= 2.6d+44) then
        tmp = x * (t / (z - y))
    else if (y <= 2.7d+63) then
        tmp = t
    else if (y <= 2.2d+102) then
        tmp = t * (-x / y)
    else
        tmp = t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -1.26e+167) {
		tmp = t;
	} else if (y <= 2.6e+44) {
		tmp = x * (t / (z - y));
	} else if (y <= 2.7e+63) {
		tmp = t;
	} else if (y <= 2.2e+102) {
		tmp = t * (-x / y);
	} else {
		tmp = t;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if y <= -1.26e+167:
		tmp = t
	elif y <= 2.6e+44:
		tmp = x * (t / (z - y))
	elif y <= 2.7e+63:
		tmp = t
	elif y <= 2.2e+102:
		tmp = t * (-x / y)
	else:
		tmp = t
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (y <= -1.26e+167)
		tmp = t;
	elseif (y <= 2.6e+44)
		tmp = Float64(x * Float64(t / Float64(z - y)));
	elseif (y <= 2.7e+63)
		tmp = t;
	elseif (y <= 2.2e+102)
		tmp = Float64(t * Float64(Float64(-x) / y));
	else
		tmp = t;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (y <= -1.26e+167)
		tmp = t;
	elseif (y <= 2.6e+44)
		tmp = x * (t / (z - y));
	elseif (y <= 2.7e+63)
		tmp = t;
	elseif (y <= 2.2e+102)
		tmp = t * (-x / y);
	else
		tmp = t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[y, -1.26e+167], t, If[LessEqual[y, 2.6e+44], N[(x * N[(t / N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.7e+63], t, If[LessEqual[y, 2.2e+102], N[(t * N[((-x) / y), $MachinePrecision]), $MachinePrecision], t]]]]

Derivation

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

Alternative 10: 60.0% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -1.85 \cdot 10^{+97}:\\ \;\;\;\;t\\ \mathbf{elif}\;y \leq 2.6 \cdot 10^{-64} \lor \neg \left(y \leq 10^{-13}\right) \land y \leq 2.8 \cdot 10^{+24}:\\ \;\;\;\;t \cdot \frac{x}{z}\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= y -1.85e+97)
   t
   (if (or (<= y 2.6e-64) (and (not (<= y 1e-13)) (<= y 2.8e+24)))
     (* t (/ x z))
     t)))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -1.85e+97) {
		tmp = t;
	} else if ((y <= 2.6e-64) || (!(y <= 1e-13) && (y <= 2.8e+24))) {
		tmp = t * (x / z);
	} else {
		tmp = t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if (y <= (-1.85d+97)) then
        tmp = t
    else if ((y <= 2.6d-64) .or. (.not. (y <= 1d-13)) .and. (y <= 2.8d+24)) then
        tmp = t * (x / z)
    else
        tmp = t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -1.85e+97) {
		tmp = t;
	} else if ((y <= 2.6e-64) || (!(y <= 1e-13) && (y <= 2.8e+24))) {
		tmp = t * (x / z);
	} else {
		tmp = t;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if y <= -1.85e+97:
		tmp = t
	elif (y <= 2.6e-64) or (not (y <= 1e-13) and (y <= 2.8e+24)):
		tmp = t * (x / z)
	else:
		tmp = t
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (y <= -1.85e+97)
		tmp = t;
	elseif ((y <= 2.6e-64) || (!(y <= 1e-13) && (y <= 2.8e+24)))
		tmp = Float64(t * Float64(x / z));
	else
		tmp = t;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (y <= -1.85e+97)
		tmp = t;
	elseif ((y <= 2.6e-64) || (~((y <= 1e-13)) && (y <= 2.8e+24)))
		tmp = t * (x / z);
	else
		tmp = t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[y, -1.85e+97], t, If[Or[LessEqual[y, 2.6e-64], And[N[Not[LessEqual[y, 1e-13]], $MachinePrecision], LessEqual[y, 2.8e+24]]], N[(t * N[(x / z), $MachinePrecision]), $MachinePrecision], t]]

Derivation

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

Alternative 11: 60.0% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -1.85 \cdot 10^{+97}:\\ \;\;\;\;t\\ \mathbf{elif}\;y \leq 2.6 \cdot 10^{-64}:\\ \;\;\;\;t \cdot \frac{x}{z}\\ \mathbf{elif}\;y \leq 3.2 \cdot 10^{-13}:\\ \;\;\;\;t\\ \mathbf{elif}\;y \leq 2.7 \cdot 10^{+22}:\\ \;\;\;\;\frac{t}{\frac{z}{x}}\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= y -1.85e+97)
   t
   (if (<= y 2.6e-64)
     (* t (/ x z))
     (if (<= y 3.2e-13) t (if (<= y 2.7e+22) (/ t (/ z x)) t)))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -1.85e+97) {
		tmp = t;
	} else if (y <= 2.6e-64) {
		tmp = t * (x / z);
	} else if (y <= 3.2e-13) {
		tmp = t;
	} else if (y <= 2.7e+22) {
		tmp = t / (z / x);
	} else {
		tmp = t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if (y <= (-1.85d+97)) then
        tmp = t
    else if (y <= 2.6d-64) then
        tmp = t * (x / z)
    else if (y <= 3.2d-13) then
        tmp = t
    else if (y <= 2.7d+22) then
        tmp = t / (z / x)
    else
        tmp = t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -1.85e+97) {
		tmp = t;
	} else if (y <= 2.6e-64) {
		tmp = t * (x / z);
	} else if (y <= 3.2e-13) {
		tmp = t;
	} else if (y <= 2.7e+22) {
		tmp = t / (z / x);
	} else {
		tmp = t;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if y <= -1.85e+97:
		tmp = t
	elif y <= 2.6e-64:
		tmp = t * (x / z)
	elif y <= 3.2e-13:
		tmp = t
	elif y <= 2.7e+22:
		tmp = t / (z / x)
	else:
		tmp = t
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (y <= -1.85e+97)
		tmp = t;
	elseif (y <= 2.6e-64)
		tmp = Float64(t * Float64(x / z));
	elseif (y <= 3.2e-13)
		tmp = t;
	elseif (y <= 2.7e+22)
		tmp = Float64(t / Float64(z / x));
	else
		tmp = t;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (y <= -1.85e+97)
		tmp = t;
	elseif (y <= 2.6e-64)
		tmp = t * (x / z);
	elseif (y <= 3.2e-13)
		tmp = t;
	elseif (y <= 2.7e+22)
		tmp = t / (z / x);
	else
		tmp = t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[y, -1.85e+97], t, If[LessEqual[y, 2.6e-64], N[(t * N[(x / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.2e-13], t, If[LessEqual[y, 2.7e+22], N[(t / N[(z / x), $MachinePrecision]), $MachinePrecision], t]]]]

Derivation

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

Alternative 12: 37.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -1.75 \cdot 10^{-162}:\\ \;\;\;\;t\\ \mathbf{elif}\;y \leq 5.2 \cdot 10^{-62}:\\ \;\;\;\;t \cdot \frac{y}{z}\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= y -1.75e-162) t (if (<= y 5.2e-62) (* t (/ y z)) t)))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -1.75e-162) {
		tmp = t;
	} else if (y <= 5.2e-62) {
		tmp = t * (y / z);
	} else {
		tmp = t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if (y <= (-1.75d-162)) then
        tmp = t
    else if (y <= 5.2d-62) then
        tmp = t * (y / z)
    else
        tmp = t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -1.75e-162) {
		tmp = t;
	} else if (y <= 5.2e-62) {
		tmp = t * (y / z);
	} else {
		tmp = t;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if y <= -1.75e-162:
		tmp = t
	elif y <= 5.2e-62:
		tmp = t * (y / z)
	else:
		tmp = t
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (y <= -1.75e-162)
		tmp = t;
	elseif (y <= 5.2e-62)
		tmp = Float64(t * Float64(y / z));
	else
		tmp = t;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (y <= -1.75e-162)
		tmp = t;
	elseif (y <= 5.2e-62)
		tmp = t * (y / z);
	else
		tmp = t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[y, -1.75e-162], t, If[LessEqual[y, 5.2e-62], N[(t * N[(y / z), $MachinePrecision]), $MachinePrecision], t]]

Derivation

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

Alternative 13: 58.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -1.85 \cdot 10^{+97}:\\ \;\;\;\;t\\ \mathbf{elif}\;y \leq 2.6 \cdot 10^{-64}:\\ \;\;\;\;x \cdot \frac{t}{z}\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= y -1.85e+97) t (if (<= y 2.6e-64) (* x (/ t z)) t)))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -1.85e+97) {
		tmp = t;
	} else if (y <= 2.6e-64) {
		tmp = x * (t / z);
	} else {
		tmp = t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if (y <= (-1.85d+97)) then
        tmp = t
    else if (y <= 2.6d-64) then
        tmp = x * (t / z)
    else
        tmp = t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -1.85e+97) {
		tmp = t;
	} else if (y <= 2.6e-64) {
		tmp = x * (t / z);
	} else {
		tmp = t;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if y <= -1.85e+97:
		tmp = t
	elif y <= 2.6e-64:
		tmp = x * (t / z)
	else:
		tmp = t
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (y <= -1.85e+97)
		tmp = t;
	elseif (y <= 2.6e-64)
		tmp = Float64(x * Float64(t / z));
	else
		tmp = t;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (y <= -1.85e+97)
		tmp = t;
	elseif (y <= 2.6e-64)
		tmp = x * (t / z);
	else
		tmp = t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[y, -1.85e+97], t, If[LessEqual[y, 2.6e-64], N[(x * N[(t / z), $MachinePrecision]), $MachinePrecision], t]]

Derivation

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

Alternative 14: 34.8% accurate, 9.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_, t_] := t

Derivation

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

Developer target: 97.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{t}{\frac{z - y}{x - y}} \end{array} \]

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = t / ((z - y) / (x - y))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Reproduce

herbie shell --seed 2024008 
(FPCore (x y z t)
  :name "Numeric.Signal.Multichannel:$cput from hsignal-0.2.7.1"
  :precision binary64

  :herbie-target
  (/ t (/ (- z y) (- x y)))

  (* (/ (- x y) (- z y)) t))