
(FPCore (x y z t a) :precision binary64 (+ x (/ (* (- y z) (- t x)) (- a z))))
double code(double x, double y, double z, double t, double a) {
return x + (((y - z) * (t - x)) / (a - z));
}
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 - x)) / (a - z))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + (((y - z) * (t - x)) / (a - z));
}
def code(x, y, z, t, a): return x + (((y - z) * (t - x)) / (a - z))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(Float64(y - z) * Float64(t - x)) / Float64(a - z))) end
function tmp = code(x, y, z, t, a) tmp = x + (((y - z) * (t - x)) / (a - z)); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{\left(y - z\right) \cdot \left(t - x\right)}{a - z}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 23 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (+ x (/ (* (- y z) (- t x)) (- a z))))
double code(double x, double y, double z, double t, double a) {
return x + (((y - z) * (t - x)) / (a - z));
}
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 - x)) / (a - z))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + (((y - z) * (t - x)) / (a - z));
}
def code(x, y, z, t, a): return x + (((y - z) * (t - x)) / (a - z))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(Float64(y - z) * Float64(t - x)) / Float64(a - z))) end
function tmp = code(x, y, z, t, a) tmp = x + (((y - z) * (t - x)) / (a - z)); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{\left(y - z\right) \cdot \left(t - x\right)}{a - z}
\end{array}
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* (/ (- t x) (- z a)) (- z y))))
(t_2 (- x (/ (* (- y z) (- t x)) (- z a)))))
(if (<= t_2 (- INFINITY))
t_1
(if (<= t_2 -2e-274)
t_2
(if (<= t_2 0.0)
(+ t (/ (* (- t x) (- a y)) z))
(if (<= t_2 5e+304) t_2 t_1))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (((t - x) / (z - a)) * (z - y));
double t_2 = x - (((y - z) * (t - x)) / (z - a));
double tmp;
if (t_2 <= -((double) INFINITY)) {
tmp = t_1;
} else if (t_2 <= -2e-274) {
tmp = t_2;
} else if (t_2 <= 0.0) {
tmp = t + (((t - x) * (a - y)) / z);
} else if (t_2 <= 5e+304) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + (((t - x) / (z - a)) * (z - y));
double t_2 = x - (((y - z) * (t - x)) / (z - a));
double tmp;
if (t_2 <= -Double.POSITIVE_INFINITY) {
tmp = t_1;
} else if (t_2 <= -2e-274) {
tmp = t_2;
} else if (t_2 <= 0.0) {
tmp = t + (((t - x) * (a - y)) / z);
} else if (t_2 <= 5e+304) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (((t - x) / (z - a)) * (z - y)) t_2 = x - (((y - z) * (t - x)) / (z - a)) tmp = 0 if t_2 <= -math.inf: tmp = t_1 elif t_2 <= -2e-274: tmp = t_2 elif t_2 <= 0.0: tmp = t + (((t - x) * (a - y)) / z) elif t_2 <= 5e+304: tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(Float64(t - x) / Float64(z - a)) * Float64(z - y))) t_2 = Float64(x - Float64(Float64(Float64(y - z) * Float64(t - x)) / Float64(z - a))) tmp = 0.0 if (t_2 <= Float64(-Inf)) tmp = t_1; elseif (t_2 <= -2e-274) tmp = t_2; elseif (t_2 <= 0.0) tmp = Float64(t + Float64(Float64(Float64(t - x) * Float64(a - y)) / z)); elseif (t_2 <= 5e+304) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (((t - x) / (z - a)) * (z - y)); t_2 = x - (((y - z) * (t - x)) / (z - a)); tmp = 0.0; if (t_2 <= -Inf) tmp = t_1; elseif (t_2 <= -2e-274) tmp = t_2; elseif (t_2 <= 0.0) tmp = t + (((t - x) * (a - y)) / z); elseif (t_2 <= 5e+304) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(N[(t - x), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision] * N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(N[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, (-Infinity)], t$95$1, If[LessEqual[t$95$2, -2e-274], t$95$2, If[LessEqual[t$95$2, 0.0], N[(t + N[(N[(N[(t - x), $MachinePrecision] * N[(a - y), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 5e+304], t$95$2, t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{t - x}{z - a} \cdot \left(z - y\right)\\
t_2 := x - \frac{\left(y - z\right) \cdot \left(t - x\right)}{z - a}\\
\mathbf{if}\;t\_2 \leq -\infty:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq -2 \cdot 10^{-274}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_2 \leq 0:\\
\;\;\;\;t + \frac{\left(t - x\right) \cdot \left(a - y\right)}{z}\\
\mathbf{elif}\;t\_2 \leq 5 \cdot 10^{+304}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -inf.0 or 4.9999999999999997e304 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) Initial program 41.3%
associate-/l*82.9%
Simplified82.9%
if -inf.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -1.99999999999999993e-274 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 4.9999999999999997e304Initial program 97.1%
if -1.99999999999999993e-274 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 0.0Initial program 3.8%
+-commutative3.8%
*-commutative3.8%
associate-/l*3.8%
fma-define3.8%
Simplified3.8%
Taylor expanded in z around inf 99.8%
associate--l+99.8%
associate-*r/99.8%
associate-*r/99.8%
mul-1-neg99.8%
div-sub99.8%
mul-1-neg99.8%
distribute-lft-out--99.8%
associate-*r/99.8%
mul-1-neg99.8%
unsub-neg99.8%
distribute-rgt-out--99.8%
Simplified99.8%
Final simplification92.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- x (/ (* (- y z) (- t x)) (- z a)))))
(if (<= t_1 -2e-274)
(fma (- t x) (/ (- y z) (- a z)) x)
(if (<= t_1 0.0)
(+ t (/ (* (- t x) (- a y)) z))
(- x (/ (- t x) (/ (- a z) (- z y))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x - (((y - z) * (t - x)) / (z - a));
double tmp;
if (t_1 <= -2e-274) {
tmp = fma((t - x), ((y - z) / (a - z)), x);
} else if (t_1 <= 0.0) {
tmp = t + (((t - x) * (a - y)) / z);
} else {
tmp = x - ((t - x) / ((a - z) / (z - y)));
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(x - Float64(Float64(Float64(y - z) * Float64(t - x)) / Float64(z - a))) tmp = 0.0 if (t_1 <= -2e-274) tmp = fma(Float64(t - x), Float64(Float64(y - z) / Float64(a - z)), x); elseif (t_1 <= 0.0) tmp = Float64(t + Float64(Float64(Float64(t - x) * Float64(a - y)) / z)); else tmp = Float64(x - Float64(Float64(t - x) / Float64(Float64(a - z) / Float64(z - y)))); end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(N[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -2e-274], N[(N[(t - x), $MachinePrecision] * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[t$95$1, 0.0], N[(t + N[(N[(N[(t - x), $MachinePrecision] * N[(a - y), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], N[(x - N[(N[(t - x), $MachinePrecision] / N[(N[(a - z), $MachinePrecision] / N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - \frac{\left(y - z\right) \cdot \left(t - x\right)}{z - a}\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{-274}:\\
\;\;\;\;\mathsf{fma}\left(t - x, \frac{y - z}{a - z}, x\right)\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;t + \frac{\left(t - x\right) \cdot \left(a - y\right)}{z}\\
\mathbf{else}:\\
\;\;\;\;x - \frac{t - x}{\frac{a - z}{z - y}}\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -1.99999999999999993e-274Initial program 80.1%
+-commutative80.1%
*-commutative80.1%
associate-/l*91.9%
fma-define91.9%
Simplified91.9%
if -1.99999999999999993e-274 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 0.0Initial program 3.8%
+-commutative3.8%
*-commutative3.8%
associate-/l*3.8%
fma-define3.8%
Simplified3.8%
Taylor expanded in z around inf 99.8%
associate--l+99.8%
associate-*r/99.8%
associate-*r/99.8%
mul-1-neg99.8%
div-sub99.8%
mul-1-neg99.8%
distribute-lft-out--99.8%
associate-*r/99.8%
mul-1-neg99.8%
unsub-neg99.8%
distribute-rgt-out--99.8%
Simplified99.8%
if 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) Initial program 76.2%
associate-/l*83.6%
Simplified83.6%
Taylor expanded in y around 0 74.7%
mul-1-neg74.7%
associate-/l*77.5%
distribute-lft-neg-out77.5%
+-commutative77.5%
div-sub77.5%
distribute-rgt-out83.6%
sub-neg83.6%
associate-/r/89.9%
Simplified89.9%
Final simplification91.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- x (/ (* (- y z) (- t x)) (- z a)))))
(if (or (<= t_1 -2e-274) (not (<= t_1 0.0)))
(- x (/ (- t x) (/ (- a z) (- z y))))
(+ t (/ (* (- t x) (- a y)) z)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x - (((y - z) * (t - x)) / (z - a));
double tmp;
if ((t_1 <= -2e-274) || !(t_1 <= 0.0)) {
tmp = x - ((t - x) / ((a - z) / (z - y)));
} else {
tmp = t + (((t - x) * (a - y)) / z);
}
return tmp;
}
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) :: tmp
t_1 = x - (((y - z) * (t - x)) / (z - a))
if ((t_1 <= (-2d-274)) .or. (.not. (t_1 <= 0.0d0))) then
tmp = x - ((t - x) / ((a - z) / (z - y)))
else
tmp = t + (((t - x) * (a - y)) / z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x - (((y - z) * (t - x)) / (z - a));
double tmp;
if ((t_1 <= -2e-274) || !(t_1 <= 0.0)) {
tmp = x - ((t - x) / ((a - z) / (z - y)));
} else {
tmp = t + (((t - x) * (a - y)) / z);
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x - (((y - z) * (t - x)) / (z - a)) tmp = 0 if (t_1 <= -2e-274) or not (t_1 <= 0.0): tmp = x - ((t - x) / ((a - z) / (z - y))) else: tmp = t + (((t - x) * (a - y)) / z) return tmp
function code(x, y, z, t, a) t_1 = Float64(x - Float64(Float64(Float64(y - z) * Float64(t - x)) / Float64(z - a))) tmp = 0.0 if ((t_1 <= -2e-274) || !(t_1 <= 0.0)) tmp = Float64(x - Float64(Float64(t - x) / Float64(Float64(a - z) / Float64(z - y)))); else tmp = Float64(t + Float64(Float64(Float64(t - x) * Float64(a - y)) / z)); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x - (((y - z) * (t - x)) / (z - a)); tmp = 0.0; if ((t_1 <= -2e-274) || ~((t_1 <= 0.0))) tmp = x - ((t - x) / ((a - z) / (z - y))); else tmp = t + (((t - x) * (a - y)) / z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(N[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, -2e-274], N[Not[LessEqual[t$95$1, 0.0]], $MachinePrecision]], N[(x - N[(N[(t - x), $MachinePrecision] / N[(N[(a - z), $MachinePrecision] / N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(N[(N[(t - x), $MachinePrecision] * N[(a - y), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - \frac{\left(y - z\right) \cdot \left(t - x\right)}{z - a}\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{-274} \lor \neg \left(t\_1 \leq 0\right):\\
\;\;\;\;x - \frac{t - x}{\frac{a - z}{z - y}}\\
\mathbf{else}:\\
\;\;\;\;t + \frac{\left(t - x\right) \cdot \left(a - y\right)}{z}\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -1.99999999999999993e-274 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) Initial program 78.2%
associate-/l*86.3%
Simplified86.3%
Taylor expanded in y around 0 78.2%
mul-1-neg78.2%
associate-/l*83.2%
distribute-lft-neg-out83.2%
+-commutative83.2%
div-sub83.3%
distribute-rgt-out86.3%
sub-neg86.3%
associate-/r/90.3%
Simplified90.3%
if -1.99999999999999993e-274 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 0.0Initial program 3.8%
+-commutative3.8%
*-commutative3.8%
associate-/l*3.8%
fma-define3.8%
Simplified3.8%
Taylor expanded in z around inf 99.8%
associate--l+99.8%
associate-*r/99.8%
associate-*r/99.8%
mul-1-neg99.8%
div-sub99.8%
mul-1-neg99.8%
distribute-lft-out--99.8%
associate-*r/99.8%
mul-1-neg99.8%
unsub-neg99.8%
distribute-rgt-out--99.8%
Simplified99.8%
Final simplification91.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* x (/ (- y a) z))))
(if (<= z -8.5e+63)
t
(if (<= z -3.3e-12)
t_1
(if (<= z -1.85e-172)
(+ x (/ (* y t) a))
(if (<= z 8e-16)
(* x (- 1.0 (/ y a)))
(if (<= z 3.9e+64) (+ x t) (if (<= z 6e+148) t_1 t))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x * ((y - a) / z);
double tmp;
if (z <= -8.5e+63) {
tmp = t;
} else if (z <= -3.3e-12) {
tmp = t_1;
} else if (z <= -1.85e-172) {
tmp = x + ((y * t) / a);
} else if (z <= 8e-16) {
tmp = x * (1.0 - (y / a));
} else if (z <= 3.9e+64) {
tmp = x + t;
} else if (z <= 6e+148) {
tmp = t_1;
} else {
tmp = t;
}
return tmp;
}
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) :: tmp
t_1 = x * ((y - a) / z)
if (z <= (-8.5d+63)) then
tmp = t
else if (z <= (-3.3d-12)) then
tmp = t_1
else if (z <= (-1.85d-172)) then
tmp = x + ((y * t) / a)
else if (z <= 8d-16) then
tmp = x * (1.0d0 - (y / a))
else if (z <= 3.9d+64) then
tmp = x + t
else if (z <= 6d+148) then
tmp = t_1
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x * ((y - a) / z);
double tmp;
if (z <= -8.5e+63) {
tmp = t;
} else if (z <= -3.3e-12) {
tmp = t_1;
} else if (z <= -1.85e-172) {
tmp = x + ((y * t) / a);
} else if (z <= 8e-16) {
tmp = x * (1.0 - (y / a));
} else if (z <= 3.9e+64) {
tmp = x + t;
} else if (z <= 6e+148) {
tmp = t_1;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x * ((y - a) / z) tmp = 0 if z <= -8.5e+63: tmp = t elif z <= -3.3e-12: tmp = t_1 elif z <= -1.85e-172: tmp = x + ((y * t) / a) elif z <= 8e-16: tmp = x * (1.0 - (y / a)) elif z <= 3.9e+64: tmp = x + t elif z <= 6e+148: tmp = t_1 else: tmp = t return tmp
function code(x, y, z, t, a) t_1 = Float64(x * Float64(Float64(y - a) / z)) tmp = 0.0 if (z <= -8.5e+63) tmp = t; elseif (z <= -3.3e-12) tmp = t_1; elseif (z <= -1.85e-172) tmp = Float64(x + Float64(Float64(y * t) / a)); elseif (z <= 8e-16) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (z <= 3.9e+64) tmp = Float64(x + t); elseif (z <= 6e+148) tmp = t_1; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x * ((y - a) / z); tmp = 0.0; if (z <= -8.5e+63) tmp = t; elseif (z <= -3.3e-12) tmp = t_1; elseif (z <= -1.85e-172) tmp = x + ((y * t) / a); elseif (z <= 8e-16) tmp = x * (1.0 - (y / a)); elseif (z <= 3.9e+64) tmp = x + t; elseif (z <= 6e+148) tmp = t_1; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -8.5e+63], t, If[LessEqual[z, -3.3e-12], t$95$1, If[LessEqual[z, -1.85e-172], N[(x + N[(N[(y * t), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 8e-16], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.9e+64], N[(x + t), $MachinePrecision], If[LessEqual[z, 6e+148], t$95$1, t]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{y - a}{z}\\
\mathbf{if}\;z \leq -8.5 \cdot 10^{+63}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -3.3 \cdot 10^{-12}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -1.85 \cdot 10^{-172}:\\
\;\;\;\;x + \frac{y \cdot t}{a}\\
\mathbf{elif}\;z \leq 8 \cdot 10^{-16}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;z \leq 3.9 \cdot 10^{+64}:\\
\;\;\;\;x + t\\
\mathbf{elif}\;z \leq 6 \cdot 10^{+148}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -8.5000000000000004e63 or 6.00000000000000029e148 < z Initial program 41.6%
associate-/l*57.7%
Simplified57.7%
Taylor expanded in y around 0 42.8%
mul-1-neg42.8%
associate-/l*57.7%
distribute-lft-neg-out57.7%
+-commutative57.7%
div-sub57.7%
distribute-rgt-out57.7%
sub-neg57.7%
associate-/r/67.2%
Simplified67.2%
Taylor expanded in z around inf 60.4%
if -8.5000000000000004e63 < z < -3.3000000000000001e-12 or 3.8999999999999998e64 < z < 6.00000000000000029e148Initial program 71.9%
+-commutative71.9%
*-commutative71.9%
associate-/l*85.6%
fma-define85.6%
Simplified85.6%
Taylor expanded in z around inf 65.4%
associate--l+65.4%
associate-*r/65.4%
associate-*r/65.4%
mul-1-neg65.4%
div-sub65.4%
mul-1-neg65.4%
distribute-lft-out--65.4%
associate-*r/65.4%
mul-1-neg65.4%
unsub-neg65.4%
distribute-rgt-out--65.4%
Simplified65.4%
Taylor expanded in t around 0 51.4%
associate-/l*51.3%
Simplified51.3%
if -3.3000000000000001e-12 < z < -1.85e-172Initial program 86.3%
associate-/l*87.5%
Simplified87.5%
Taylor expanded in t around inf 83.7%
associate-/l*81.3%
Simplified81.3%
Taylor expanded in z around 0 46.4%
if -1.85e-172 < z < 7.9999999999999998e-16Initial program 89.4%
+-commutative89.4%
*-commutative89.4%
associate-/l*96.2%
fma-define96.2%
Simplified96.2%
Taylor expanded in t around 0 61.4%
*-rgt-identity61.4%
mul-1-neg61.4%
associate-/l*69.6%
distribute-rgt-neg-in69.6%
mul-1-neg69.6%
distribute-lft-in69.6%
mul-1-neg69.6%
unsub-neg69.6%
Simplified69.6%
Taylor expanded in z around 0 66.5%
if 7.9999999999999998e-16 < z < 3.8999999999999998e64Initial program 86.4%
associate-/l*90.7%
Simplified90.7%
Taylor expanded in t around inf 68.9%
associate-/l*73.2%
Simplified73.2%
Taylor expanded in z around inf 49.7%
Final simplification58.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (+ (/ (- a y) z) 1.0))))
(if (<= z -1.05e+51)
t_1
(if (<= z -0.024)
(/ (* x (- y a)) z)
(if (<= z -1.18e-94)
(+ x (/ (* (- y z) t) a))
(if (<= z -9.2e-243)
(- x (/ (* y t) (- z a)))
(if (<= z 2.3e-9) (+ x (* y (/ (- t x) a))) t_1)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * (((a - y) / z) + 1.0);
double tmp;
if (z <= -1.05e+51) {
tmp = t_1;
} else if (z <= -0.024) {
tmp = (x * (y - a)) / z;
} else if (z <= -1.18e-94) {
tmp = x + (((y - z) * t) / a);
} else if (z <= -9.2e-243) {
tmp = x - ((y * t) / (z - a));
} else if (z <= 2.3e-9) {
tmp = x + (y * ((t - x) / a));
} else {
tmp = t_1;
}
return tmp;
}
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) :: tmp
t_1 = t * (((a - y) / z) + 1.0d0)
if (z <= (-1.05d+51)) then
tmp = t_1
else if (z <= (-0.024d0)) then
tmp = (x * (y - a)) / z
else if (z <= (-1.18d-94)) then
tmp = x + (((y - z) * t) / a)
else if (z <= (-9.2d-243)) then
tmp = x - ((y * t) / (z - a))
else if (z <= 2.3d-9) then
tmp = x + (y * ((t - x) / a))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * (((a - y) / z) + 1.0);
double tmp;
if (z <= -1.05e+51) {
tmp = t_1;
} else if (z <= -0.024) {
tmp = (x * (y - a)) / z;
} else if (z <= -1.18e-94) {
tmp = x + (((y - z) * t) / a);
} else if (z <= -9.2e-243) {
tmp = x - ((y * t) / (z - a));
} else if (z <= 2.3e-9) {
tmp = x + (y * ((t - x) / a));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * (((a - y) / z) + 1.0) tmp = 0 if z <= -1.05e+51: tmp = t_1 elif z <= -0.024: tmp = (x * (y - a)) / z elif z <= -1.18e-94: tmp = x + (((y - z) * t) / a) elif z <= -9.2e-243: tmp = x - ((y * t) / (z - a)) elif z <= 2.3e-9: tmp = x + (y * ((t - x) / a)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(Float64(Float64(a - y) / z) + 1.0)) tmp = 0.0 if (z <= -1.05e+51) tmp = t_1; elseif (z <= -0.024) tmp = Float64(Float64(x * Float64(y - a)) / z); elseif (z <= -1.18e-94) tmp = Float64(x + Float64(Float64(Float64(y - z) * t) / a)); elseif (z <= -9.2e-243) tmp = Float64(x - Float64(Float64(y * t) / Float64(z - a))); elseif (z <= 2.3e-9) tmp = Float64(x + Float64(y * Float64(Float64(t - x) / a))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * (((a - y) / z) + 1.0); tmp = 0.0; if (z <= -1.05e+51) tmp = t_1; elseif (z <= -0.024) tmp = (x * (y - a)) / z; elseif (z <= -1.18e-94) tmp = x + (((y - z) * t) / a); elseif (z <= -9.2e-243) tmp = x - ((y * t) / (z - a)); elseif (z <= 2.3e-9) tmp = x + (y * ((t - x) / a)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(N[(a - y), $MachinePrecision] / z), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.05e+51], t$95$1, If[LessEqual[z, -0.024], N[(N[(x * N[(y - a), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, -1.18e-94], N[(x + N[(N[(N[(y - z), $MachinePrecision] * t), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -9.2e-243], N[(x - N[(N[(y * t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.3e-9], N[(x + N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(\frac{a - y}{z} + 1\right)\\
\mathbf{if}\;z \leq -1.05 \cdot 10^{+51}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -0.024:\\
\;\;\;\;\frac{x \cdot \left(y - a\right)}{z}\\
\mathbf{elif}\;z \leq -1.18 \cdot 10^{-94}:\\
\;\;\;\;x + \frac{\left(y - z\right) \cdot t}{a}\\
\mathbf{elif}\;z \leq -9.2 \cdot 10^{-243}:\\
\;\;\;\;x - \frac{y \cdot t}{z - a}\\
\mathbf{elif}\;z \leq 2.3 \cdot 10^{-9}:\\
\;\;\;\;x + y \cdot \frac{t - x}{a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.0500000000000001e51 or 2.2999999999999999e-9 < z Initial program 54.8%
+-commutative54.8%
*-commutative54.8%
associate-/l*75.4%
fma-define75.4%
Simplified75.4%
Taylor expanded in z around inf 75.4%
associate--l+75.4%
associate-*r/75.4%
associate-*r/75.4%
mul-1-neg75.4%
div-sub75.4%
mul-1-neg75.4%
distribute-lft-out--75.4%
associate-*r/75.4%
mul-1-neg75.4%
unsub-neg75.4%
distribute-rgt-out--75.5%
Simplified75.5%
Taylor expanded in t around -inf 55.7%
neg-mul-155.7%
unsub-neg55.7%
Simplified55.7%
if -1.0500000000000001e51 < z < -0.024Initial program 68.8%
+-commutative68.8%
*-commutative68.8%
associate-/l*68.1%
fma-define68.1%
Simplified68.1%
Taylor expanded in z around inf 83.3%
associate--l+83.3%
associate-*r/83.3%
associate-*r/83.3%
mul-1-neg83.3%
div-sub83.3%
mul-1-neg83.3%
distribute-lft-out--83.3%
associate-*r/83.3%
mul-1-neg83.3%
unsub-neg83.3%
distribute-rgt-out--83.3%
Simplified83.3%
Taylor expanded in t around 0 83.3%
if -0.024 < z < -1.18e-94Initial program 90.4%
associate-/l*92.6%
Simplified92.6%
Taylor expanded in t around inf 85.4%
associate-/l*90.2%
Simplified90.2%
Taylor expanded in a around inf 67.4%
+-commutative67.4%
Simplified67.4%
if -1.18e-94 < z < -9.20000000000000001e-243Initial program 88.7%
associate-/l*85.7%
Simplified85.7%
Taylor expanded in t around inf 85.7%
associate-/l*80.2%
Simplified80.2%
Taylor expanded in y around inf 77.1%
if -9.20000000000000001e-243 < z < 2.2999999999999999e-9Initial program 88.5%
associate-/l*94.8%
Simplified94.8%
Taylor expanded in z around 0 75.8%
associate-/l*81.9%
Simplified81.9%
Final simplification67.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* x (/ (- y a) z))))
(if (<= z -2.8e+56)
t
(if (<= z -5.2e-16)
t_1
(if (<= z 1.1e-9)
(+ x (* t (/ y a)))
(if (<= z 7.3e+65) (+ x t) (if (<= z 2.8e+148) t_1 t)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x * ((y - a) / z);
double tmp;
if (z <= -2.8e+56) {
tmp = t;
} else if (z <= -5.2e-16) {
tmp = t_1;
} else if (z <= 1.1e-9) {
tmp = x + (t * (y / a));
} else if (z <= 7.3e+65) {
tmp = x + t;
} else if (z <= 2.8e+148) {
tmp = t_1;
} else {
tmp = t;
}
return tmp;
}
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) :: tmp
t_1 = x * ((y - a) / z)
if (z <= (-2.8d+56)) then
tmp = t
else if (z <= (-5.2d-16)) then
tmp = t_1
else if (z <= 1.1d-9) then
tmp = x + (t * (y / a))
else if (z <= 7.3d+65) then
tmp = x + t
else if (z <= 2.8d+148) then
tmp = t_1
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x * ((y - a) / z);
double tmp;
if (z <= -2.8e+56) {
tmp = t;
} else if (z <= -5.2e-16) {
tmp = t_1;
} else if (z <= 1.1e-9) {
tmp = x + (t * (y / a));
} else if (z <= 7.3e+65) {
tmp = x + t;
} else if (z <= 2.8e+148) {
tmp = t_1;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x * ((y - a) / z) tmp = 0 if z <= -2.8e+56: tmp = t elif z <= -5.2e-16: tmp = t_1 elif z <= 1.1e-9: tmp = x + (t * (y / a)) elif z <= 7.3e+65: tmp = x + t elif z <= 2.8e+148: tmp = t_1 else: tmp = t return tmp
function code(x, y, z, t, a) t_1 = Float64(x * Float64(Float64(y - a) / z)) tmp = 0.0 if (z <= -2.8e+56) tmp = t; elseif (z <= -5.2e-16) tmp = t_1; elseif (z <= 1.1e-9) tmp = Float64(x + Float64(t * Float64(y / a))); elseif (z <= 7.3e+65) tmp = Float64(x + t); elseif (z <= 2.8e+148) tmp = t_1; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x * ((y - a) / z); tmp = 0.0; if (z <= -2.8e+56) tmp = t; elseif (z <= -5.2e-16) tmp = t_1; elseif (z <= 1.1e-9) tmp = x + (t * (y / a)); elseif (z <= 7.3e+65) tmp = x + t; elseif (z <= 2.8e+148) tmp = t_1; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.8e+56], t, If[LessEqual[z, -5.2e-16], t$95$1, If[LessEqual[z, 1.1e-9], N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 7.3e+65], N[(x + t), $MachinePrecision], If[LessEqual[z, 2.8e+148], t$95$1, t]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{y - a}{z}\\
\mathbf{if}\;z \leq -2.8 \cdot 10^{+56}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -5.2 \cdot 10^{-16}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.1 \cdot 10^{-9}:\\
\;\;\;\;x + t \cdot \frac{y}{a}\\
\mathbf{elif}\;z \leq 7.3 \cdot 10^{+65}:\\
\;\;\;\;x + t\\
\mathbf{elif}\;z \leq 2.8 \cdot 10^{+148}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -2.80000000000000008e56 or 2.7999999999999998e148 < z Initial program 41.6%
associate-/l*57.7%
Simplified57.7%
Taylor expanded in y around 0 42.8%
mul-1-neg42.8%
associate-/l*57.7%
distribute-lft-neg-out57.7%
+-commutative57.7%
div-sub57.7%
distribute-rgt-out57.7%
sub-neg57.7%
associate-/r/67.2%
Simplified67.2%
Taylor expanded in z around inf 60.4%
if -2.80000000000000008e56 < z < -5.1999999999999997e-16 or 7.29999999999999973e65 < z < 2.7999999999999998e148Initial program 71.9%
+-commutative71.9%
*-commutative71.9%
associate-/l*85.6%
fma-define85.6%
Simplified85.6%
Taylor expanded in z around inf 65.4%
associate--l+65.4%
associate-*r/65.4%
associate-*r/65.4%
mul-1-neg65.4%
div-sub65.4%
mul-1-neg65.4%
distribute-lft-out--65.4%
associate-*r/65.4%
mul-1-neg65.4%
unsub-neg65.4%
distribute-rgt-out--65.4%
Simplified65.4%
Taylor expanded in t around 0 51.4%
associate-/l*51.3%
Simplified51.3%
if -5.1999999999999997e-16 < z < 1.0999999999999999e-9Initial program 88.6%
associate-/l*91.9%
Simplified91.9%
Taylor expanded in t around inf 77.0%
associate-/l*77.5%
Simplified77.5%
Taylor expanded in z around 0 56.8%
+-commutative56.8%
associate-/l*59.8%
Simplified59.8%
if 1.0999999999999999e-9 < z < 7.29999999999999973e65Initial program 85.8%
associate-/l*90.3%
Simplified90.3%
Taylor expanded in t around inf 67.4%
associate-/l*71.9%
Simplified71.9%
Taylor expanded in z around inf 51.7%
Final simplification58.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* x (/ (- y a) z))))
(if (<= z -2.6e+60)
t
(if (<= z -6e-132)
t_1
(if (<= z 1.1e-14)
(* x (- 1.0 (/ y a)))
(if (<= z 1.4e+65) (+ x t) (if (<= z 3e+148) t_1 t)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x * ((y - a) / z);
double tmp;
if (z <= -2.6e+60) {
tmp = t;
} else if (z <= -6e-132) {
tmp = t_1;
} else if (z <= 1.1e-14) {
tmp = x * (1.0 - (y / a));
} else if (z <= 1.4e+65) {
tmp = x + t;
} else if (z <= 3e+148) {
tmp = t_1;
} else {
tmp = t;
}
return tmp;
}
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) :: tmp
t_1 = x * ((y - a) / z)
if (z <= (-2.6d+60)) then
tmp = t
else if (z <= (-6d-132)) then
tmp = t_1
else if (z <= 1.1d-14) then
tmp = x * (1.0d0 - (y / a))
else if (z <= 1.4d+65) then
tmp = x + t
else if (z <= 3d+148) then
tmp = t_1
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x * ((y - a) / z);
double tmp;
if (z <= -2.6e+60) {
tmp = t;
} else if (z <= -6e-132) {
tmp = t_1;
} else if (z <= 1.1e-14) {
tmp = x * (1.0 - (y / a));
} else if (z <= 1.4e+65) {
tmp = x + t;
} else if (z <= 3e+148) {
tmp = t_1;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x * ((y - a) / z) tmp = 0 if z <= -2.6e+60: tmp = t elif z <= -6e-132: tmp = t_1 elif z <= 1.1e-14: tmp = x * (1.0 - (y / a)) elif z <= 1.4e+65: tmp = x + t elif z <= 3e+148: tmp = t_1 else: tmp = t return tmp
function code(x, y, z, t, a) t_1 = Float64(x * Float64(Float64(y - a) / z)) tmp = 0.0 if (z <= -2.6e+60) tmp = t; elseif (z <= -6e-132) tmp = t_1; elseif (z <= 1.1e-14) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (z <= 1.4e+65) tmp = Float64(x + t); elseif (z <= 3e+148) tmp = t_1; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x * ((y - a) / z); tmp = 0.0; if (z <= -2.6e+60) tmp = t; elseif (z <= -6e-132) tmp = t_1; elseif (z <= 1.1e-14) tmp = x * (1.0 - (y / a)); elseif (z <= 1.4e+65) tmp = x + t; elseif (z <= 3e+148) tmp = t_1; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.6e+60], t, If[LessEqual[z, -6e-132], t$95$1, If[LessEqual[z, 1.1e-14], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.4e+65], N[(x + t), $MachinePrecision], If[LessEqual[z, 3e+148], t$95$1, t]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{y - a}{z}\\
\mathbf{if}\;z \leq -2.6 \cdot 10^{+60}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -6 \cdot 10^{-132}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.1 \cdot 10^{-14}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;z \leq 1.4 \cdot 10^{+65}:\\
\;\;\;\;x + t\\
\mathbf{elif}\;z \leq 3 \cdot 10^{+148}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -2.60000000000000008e60 or 3.00000000000000015e148 < z Initial program 41.6%
associate-/l*57.7%
Simplified57.7%
Taylor expanded in y around 0 42.8%
mul-1-neg42.8%
associate-/l*57.7%
distribute-lft-neg-out57.7%
+-commutative57.7%
div-sub57.7%
distribute-rgt-out57.7%
sub-neg57.7%
associate-/r/67.2%
Simplified67.2%
Taylor expanded in z around inf 60.4%
if -2.60000000000000008e60 < z < -5.9999999999999999e-132 or 1.3999999999999999e65 < z < 3.00000000000000015e148Initial program 75.9%
+-commutative75.9%
*-commutative75.9%
associate-/l*85.3%
fma-define85.2%
Simplified85.2%
Taylor expanded in z around inf 57.5%
associate--l+57.5%
associate-*r/57.5%
associate-*r/57.5%
mul-1-neg57.5%
div-sub57.5%
mul-1-neg57.5%
distribute-lft-out--57.5%
associate-*r/57.5%
mul-1-neg57.5%
unsub-neg57.5%
distribute-rgt-out--57.6%
Simplified57.6%
Taylor expanded in t around 0 38.8%
associate-/l*41.7%
Simplified41.7%
if -5.9999999999999999e-132 < z < 1.1e-14Initial program 90.4%
+-commutative90.4%
*-commutative90.4%
associate-/l*94.7%
fma-define94.7%
Simplified94.7%
Taylor expanded in t around 0 61.4%
*-rgt-identity61.4%
mul-1-neg61.4%
associate-/l*68.8%
distribute-rgt-neg-in68.8%
mul-1-neg68.8%
distribute-lft-in68.8%
mul-1-neg68.8%
unsub-neg68.8%
Simplified68.8%
Taylor expanded in z around 0 64.9%
if 1.1e-14 < z < 1.3999999999999999e65Initial program 86.4%
associate-/l*90.7%
Simplified90.7%
Taylor expanded in t around inf 68.9%
associate-/l*73.2%
Simplified73.2%
Taylor expanded in z around inf 49.7%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ t (* y (/ (- x t) z)))))
(if (<= z -3350.0)
t_1
(if (<= z -2.6e-66)
(- x (* t (/ z (- a z))))
(if (<= z -4.8e-244)
(- x (/ (* y t) (- z a)))
(if (<= z 4.5e-11) (+ x (* y (/ (- t x) a))) t_1))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t + (y * ((x - t) / z));
double tmp;
if (z <= -3350.0) {
tmp = t_1;
} else if (z <= -2.6e-66) {
tmp = x - (t * (z / (a - z)));
} else if (z <= -4.8e-244) {
tmp = x - ((y * t) / (z - a));
} else if (z <= 4.5e-11) {
tmp = x + (y * ((t - x) / a));
} else {
tmp = t_1;
}
return tmp;
}
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) :: tmp
t_1 = t + (y * ((x - t) / z))
if (z <= (-3350.0d0)) then
tmp = t_1
else if (z <= (-2.6d-66)) then
tmp = x - (t * (z / (a - z)))
else if (z <= (-4.8d-244)) then
tmp = x - ((y * t) / (z - a))
else if (z <= 4.5d-11) then
tmp = x + (y * ((t - x) / a))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t + (y * ((x - t) / z));
double tmp;
if (z <= -3350.0) {
tmp = t_1;
} else if (z <= -2.6e-66) {
tmp = x - (t * (z / (a - z)));
} else if (z <= -4.8e-244) {
tmp = x - ((y * t) / (z - a));
} else if (z <= 4.5e-11) {
tmp = x + (y * ((t - x) / a));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t + (y * ((x - t) / z)) tmp = 0 if z <= -3350.0: tmp = t_1 elif z <= -2.6e-66: tmp = x - (t * (z / (a - z))) elif z <= -4.8e-244: tmp = x - ((y * t) / (z - a)) elif z <= 4.5e-11: tmp = x + (y * ((t - x) / a)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t + Float64(y * Float64(Float64(x - t) / z))) tmp = 0.0 if (z <= -3350.0) tmp = t_1; elseif (z <= -2.6e-66) tmp = Float64(x - Float64(t * Float64(z / Float64(a - z)))); elseif (z <= -4.8e-244) tmp = Float64(x - Float64(Float64(y * t) / Float64(z - a))); elseif (z <= 4.5e-11) tmp = Float64(x + Float64(y * Float64(Float64(t - x) / a))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t + (y * ((x - t) / z)); tmp = 0.0; if (z <= -3350.0) tmp = t_1; elseif (z <= -2.6e-66) tmp = x - (t * (z / (a - z))); elseif (z <= -4.8e-244) tmp = x - ((y * t) / (z - a)); elseif (z <= 4.5e-11) tmp = x + (y * ((t - x) / a)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t + N[(y * N[(N[(x - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -3350.0], t$95$1, If[LessEqual[z, -2.6e-66], N[(x - N[(t * N[(z / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -4.8e-244], N[(x - N[(N[(y * t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.5e-11], N[(x + N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + y \cdot \frac{x - t}{z}\\
\mathbf{if}\;z \leq -3350:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -2.6 \cdot 10^{-66}:\\
\;\;\;\;x - t \cdot \frac{z}{a - z}\\
\mathbf{elif}\;z \leq -4.8 \cdot 10^{-244}:\\
\;\;\;\;x - \frac{y \cdot t}{z - a}\\
\mathbf{elif}\;z \leq 4.5 \cdot 10^{-11}:\\
\;\;\;\;x + y \cdot \frac{t - x}{a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -3350 or 4.5e-11 < z Initial program 55.4%
+-commutative55.4%
*-commutative55.4%
associate-/l*75.1%
fma-define75.0%
Simplified75.0%
Taylor expanded in z around inf 75.8%
associate--l+75.8%
associate-*r/75.8%
associate-*r/75.8%
mul-1-neg75.8%
div-sub75.8%
mul-1-neg75.8%
distribute-lft-out--75.8%
associate-*r/75.8%
mul-1-neg75.8%
unsub-neg75.8%
distribute-rgt-out--75.9%
Simplified75.9%
Taylor expanded in y around inf 68.2%
associate-/l*68.9%
Simplified68.9%
if -3350 < z < -2.5999999999999999e-66Initial program 88.1%
associate-/l*90.8%
Simplified90.8%
Taylor expanded in t around inf 82.0%
associate-/l*88.0%
Simplified88.0%
Taylor expanded in y around 0 71.0%
mul-1-neg71.0%
unsub-neg71.0%
associate-/l*71.2%
Simplified71.2%
if -2.5999999999999999e-66 < z < -4.80000000000000032e-244Initial program 89.9%
associate-/l*87.2%
Simplified87.2%
Taylor expanded in t around inf 87.2%
associate-/l*82.2%
Simplified82.2%
Taylor expanded in y around inf 76.9%
if -4.80000000000000032e-244 < z < 4.5e-11Initial program 88.5%
associate-/l*94.8%
Simplified94.8%
Taylor expanded in z around 0 75.8%
associate-/l*81.9%
Simplified81.9%
Final simplification74.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ t (* y (/ (- x t) z)))))
(if (<= z -0.000125)
t_1
(if (<= z -5e-94)
(+ x (/ (* (- y z) t) a))
(if (<= z -1.2e-242)
(- x (/ (* y t) (- z a)))
(if (<= z 2.9e-12) (+ x (* y (/ (- t x) a))) t_1))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t + (y * ((x - t) / z));
double tmp;
if (z <= -0.000125) {
tmp = t_1;
} else if (z <= -5e-94) {
tmp = x + (((y - z) * t) / a);
} else if (z <= -1.2e-242) {
tmp = x - ((y * t) / (z - a));
} else if (z <= 2.9e-12) {
tmp = x + (y * ((t - x) / a));
} else {
tmp = t_1;
}
return tmp;
}
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) :: tmp
t_1 = t + (y * ((x - t) / z))
if (z <= (-0.000125d0)) then
tmp = t_1
else if (z <= (-5d-94)) then
tmp = x + (((y - z) * t) / a)
else if (z <= (-1.2d-242)) then
tmp = x - ((y * t) / (z - a))
else if (z <= 2.9d-12) then
tmp = x + (y * ((t - x) / a))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t + (y * ((x - t) / z));
double tmp;
if (z <= -0.000125) {
tmp = t_1;
} else if (z <= -5e-94) {
tmp = x + (((y - z) * t) / a);
} else if (z <= -1.2e-242) {
tmp = x - ((y * t) / (z - a));
} else if (z <= 2.9e-12) {
tmp = x + (y * ((t - x) / a));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t + (y * ((x - t) / z)) tmp = 0 if z <= -0.000125: tmp = t_1 elif z <= -5e-94: tmp = x + (((y - z) * t) / a) elif z <= -1.2e-242: tmp = x - ((y * t) / (z - a)) elif z <= 2.9e-12: tmp = x + (y * ((t - x) / a)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t + Float64(y * Float64(Float64(x - t) / z))) tmp = 0.0 if (z <= -0.000125) tmp = t_1; elseif (z <= -5e-94) tmp = Float64(x + Float64(Float64(Float64(y - z) * t) / a)); elseif (z <= -1.2e-242) tmp = Float64(x - Float64(Float64(y * t) / Float64(z - a))); elseif (z <= 2.9e-12) tmp = Float64(x + Float64(y * Float64(Float64(t - x) / a))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t + (y * ((x - t) / z)); tmp = 0.0; if (z <= -0.000125) tmp = t_1; elseif (z <= -5e-94) tmp = x + (((y - z) * t) / a); elseif (z <= -1.2e-242) tmp = x - ((y * t) / (z - a)); elseif (z <= 2.9e-12) tmp = x + (y * ((t - x) / a)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t + N[(y * N[(N[(x - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -0.000125], t$95$1, If[LessEqual[z, -5e-94], N[(x + N[(N[(N[(y - z), $MachinePrecision] * t), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.2e-242], N[(x - N[(N[(y * t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.9e-12], N[(x + N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + y \cdot \frac{x - t}{z}\\
\mathbf{if}\;z \leq -0.000125:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -5 \cdot 10^{-94}:\\
\;\;\;\;x + \frac{\left(y - z\right) \cdot t}{a}\\
\mathbf{elif}\;z \leq -1.2 \cdot 10^{-242}:\\
\;\;\;\;x - \frac{y \cdot t}{z - a}\\
\mathbf{elif}\;z \leq 2.9 \cdot 10^{-12}:\\
\;\;\;\;x + y \cdot \frac{t - x}{a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.25e-4 or 2.9000000000000002e-12 < z Initial program 55.4%
+-commutative55.4%
*-commutative55.4%
associate-/l*75.1%
fma-define75.0%
Simplified75.0%
Taylor expanded in z around inf 75.8%
associate--l+75.8%
associate-*r/75.8%
associate-*r/75.8%
mul-1-neg75.8%
div-sub75.8%
mul-1-neg75.8%
distribute-lft-out--75.8%
associate-*r/75.8%
mul-1-neg75.8%
unsub-neg75.8%
distribute-rgt-out--75.9%
Simplified75.9%
Taylor expanded in y around inf 68.2%
associate-/l*68.9%
Simplified68.9%
if -1.25e-4 < z < -4.9999999999999995e-94Initial program 90.4%
associate-/l*92.6%
Simplified92.6%
Taylor expanded in t around inf 85.4%
associate-/l*90.2%
Simplified90.2%
Taylor expanded in a around inf 67.4%
+-commutative67.4%
Simplified67.4%
if -4.9999999999999995e-94 < z < -1.2e-242Initial program 88.7%
associate-/l*85.7%
Simplified85.7%
Taylor expanded in t around inf 85.7%
associate-/l*80.2%
Simplified80.2%
Taylor expanded in y around inf 77.1%
if -1.2e-242 < z < 2.9000000000000002e-12Initial program 88.5%
associate-/l*94.8%
Simplified94.8%
Taylor expanded in z around 0 75.8%
associate-/l*81.9%
Simplified81.9%
Final simplification73.7%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (+ (/ (- a y) z) 1.0))))
(if (<= z -7.8e+52)
t_1
(if (<= z -1.02e-14)
(/ (* x (- y a)) z)
(if (<= z -4.6e-243)
(- x (/ (* y t) (- z a)))
(if (<= z 1.18e-11) (+ x (* y (/ (- t x) a))) t_1))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * (((a - y) / z) + 1.0);
double tmp;
if (z <= -7.8e+52) {
tmp = t_1;
} else if (z <= -1.02e-14) {
tmp = (x * (y - a)) / z;
} else if (z <= -4.6e-243) {
tmp = x - ((y * t) / (z - a));
} else if (z <= 1.18e-11) {
tmp = x + (y * ((t - x) / a));
} else {
tmp = t_1;
}
return tmp;
}
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) :: tmp
t_1 = t * (((a - y) / z) + 1.0d0)
if (z <= (-7.8d+52)) then
tmp = t_1
else if (z <= (-1.02d-14)) then
tmp = (x * (y - a)) / z
else if (z <= (-4.6d-243)) then
tmp = x - ((y * t) / (z - a))
else if (z <= 1.18d-11) then
tmp = x + (y * ((t - x) / a))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * (((a - y) / z) + 1.0);
double tmp;
if (z <= -7.8e+52) {
tmp = t_1;
} else if (z <= -1.02e-14) {
tmp = (x * (y - a)) / z;
} else if (z <= -4.6e-243) {
tmp = x - ((y * t) / (z - a));
} else if (z <= 1.18e-11) {
tmp = x + (y * ((t - x) / a));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * (((a - y) / z) + 1.0) tmp = 0 if z <= -7.8e+52: tmp = t_1 elif z <= -1.02e-14: tmp = (x * (y - a)) / z elif z <= -4.6e-243: tmp = x - ((y * t) / (z - a)) elif z <= 1.18e-11: tmp = x + (y * ((t - x) / a)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(Float64(Float64(a - y) / z) + 1.0)) tmp = 0.0 if (z <= -7.8e+52) tmp = t_1; elseif (z <= -1.02e-14) tmp = Float64(Float64(x * Float64(y - a)) / z); elseif (z <= -4.6e-243) tmp = Float64(x - Float64(Float64(y * t) / Float64(z - a))); elseif (z <= 1.18e-11) tmp = Float64(x + Float64(y * Float64(Float64(t - x) / a))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * (((a - y) / z) + 1.0); tmp = 0.0; if (z <= -7.8e+52) tmp = t_1; elseif (z <= -1.02e-14) tmp = (x * (y - a)) / z; elseif (z <= -4.6e-243) tmp = x - ((y * t) / (z - a)); elseif (z <= 1.18e-11) tmp = x + (y * ((t - x) / a)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(N[(a - y), $MachinePrecision] / z), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -7.8e+52], t$95$1, If[LessEqual[z, -1.02e-14], N[(N[(x * N[(y - a), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, -4.6e-243], N[(x - N[(N[(y * t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.18e-11], N[(x + N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(\frac{a - y}{z} + 1\right)\\
\mathbf{if}\;z \leq -7.8 \cdot 10^{+52}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -1.02 \cdot 10^{-14}:\\
\;\;\;\;\frac{x \cdot \left(y - a\right)}{z}\\
\mathbf{elif}\;z \leq -4.6 \cdot 10^{-243}:\\
\;\;\;\;x - \frac{y \cdot t}{z - a}\\
\mathbf{elif}\;z \leq 1.18 \cdot 10^{-11}:\\
\;\;\;\;x + y \cdot \frac{t - x}{a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -7.7999999999999999e52 or 1.18e-11 < z Initial program 54.8%
+-commutative54.8%
*-commutative54.8%
associate-/l*75.4%
fma-define75.4%
Simplified75.4%
Taylor expanded in z around inf 75.4%
associate--l+75.4%
associate-*r/75.4%
associate-*r/75.4%
mul-1-neg75.4%
div-sub75.4%
mul-1-neg75.4%
distribute-lft-out--75.4%
associate-*r/75.4%
mul-1-neg75.4%
unsub-neg75.4%
distribute-rgt-out--75.5%
Simplified75.5%
Taylor expanded in t around -inf 55.7%
neg-mul-155.7%
unsub-neg55.7%
Simplified55.7%
if -7.7999999999999999e52 < z < -1.02e-14Initial program 79.0%
+-commutative79.0%
*-commutative79.0%
associate-/l*78.5%
fma-define78.5%
Simplified78.5%
Taylor expanded in z around inf 67.8%
associate--l+67.8%
associate-*r/67.8%
associate-*r/67.8%
mul-1-neg67.8%
div-sub67.8%
mul-1-neg67.8%
distribute-lft-out--67.8%
associate-*r/67.8%
mul-1-neg67.8%
unsub-neg67.8%
distribute-rgt-out--67.8%
Simplified67.8%
Taylor expanded in t around 0 67.8%
if -1.02e-14 < z < -4.6e-243Initial program 88.8%
associate-/l*87.6%
Simplified87.6%
Taylor expanded in t around inf 86.8%
associate-/l*85.1%
Simplified85.1%
Taylor expanded in y around inf 66.4%
if -4.6e-243 < z < 1.18e-11Initial program 88.5%
associate-/l*94.8%
Simplified94.8%
Taylor expanded in z around 0 75.8%
associate-/l*81.9%
Simplified81.9%
Final simplification66.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ t (/ (* (- t x) (- a y)) z))))
(if (<= z -0.025)
t_1
(if (<= z -3.4e-154)
(+ x (* (- y z) (/ t (- a z))))
(if (<= z 5.2e-11) (+ x (/ (- t x) (/ (- a z) y))) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t + (((t - x) * (a - y)) / z);
double tmp;
if (z <= -0.025) {
tmp = t_1;
} else if (z <= -3.4e-154) {
tmp = x + ((y - z) * (t / (a - z)));
} else if (z <= 5.2e-11) {
tmp = x + ((t - x) / ((a - z) / y));
} else {
tmp = t_1;
}
return tmp;
}
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) :: tmp
t_1 = t + (((t - x) * (a - y)) / z)
if (z <= (-0.025d0)) then
tmp = t_1
else if (z <= (-3.4d-154)) then
tmp = x + ((y - z) * (t / (a - z)))
else if (z <= 5.2d-11) then
tmp = x + ((t - x) / ((a - z) / y))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t + (((t - x) * (a - y)) / z);
double tmp;
if (z <= -0.025) {
tmp = t_1;
} else if (z <= -3.4e-154) {
tmp = x + ((y - z) * (t / (a - z)));
} else if (z <= 5.2e-11) {
tmp = x + ((t - x) / ((a - z) / y));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t + (((t - x) * (a - y)) / z) tmp = 0 if z <= -0.025: tmp = t_1 elif z <= -3.4e-154: tmp = x + ((y - z) * (t / (a - z))) elif z <= 5.2e-11: tmp = x + ((t - x) / ((a - z) / y)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t + Float64(Float64(Float64(t - x) * Float64(a - y)) / z)) tmp = 0.0 if (z <= -0.025) tmp = t_1; elseif (z <= -3.4e-154) tmp = Float64(x + Float64(Float64(y - z) * Float64(t / Float64(a - z)))); elseif (z <= 5.2e-11) tmp = Float64(x + Float64(Float64(t - x) / Float64(Float64(a - z) / y))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t + (((t - x) * (a - y)) / z); tmp = 0.0; if (z <= -0.025) tmp = t_1; elseif (z <= -3.4e-154) tmp = x + ((y - z) * (t / (a - z))); elseif (z <= 5.2e-11) tmp = x + ((t - x) / ((a - z) / y)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t + N[(N[(N[(t - x), $MachinePrecision] * N[(a - y), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -0.025], t$95$1, If[LessEqual[z, -3.4e-154], N[(x + N[(N[(y - z), $MachinePrecision] * N[(t / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.2e-11], N[(x + N[(N[(t - x), $MachinePrecision] / N[(N[(a - z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + \frac{\left(t - x\right) \cdot \left(a - y\right)}{z}\\
\mathbf{if}\;z \leq -0.025:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -3.4 \cdot 10^{-154}:\\
\;\;\;\;x + \left(y - z\right) \cdot \frac{t}{a - z}\\
\mathbf{elif}\;z \leq 5.2 \cdot 10^{-11}:\\
\;\;\;\;x + \frac{t - x}{\frac{a - z}{y}}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -0.025000000000000001 or 5.2000000000000001e-11 < z Initial program 55.4%
+-commutative55.4%
*-commutative55.4%
associate-/l*75.1%
fma-define75.0%
Simplified75.0%
Taylor expanded in z around inf 75.8%
associate--l+75.8%
associate-*r/75.8%
associate-*r/75.8%
mul-1-neg75.8%
div-sub75.8%
mul-1-neg75.8%
distribute-lft-out--75.8%
associate-*r/75.8%
mul-1-neg75.8%
unsub-neg75.8%
distribute-rgt-out--75.9%
Simplified75.9%
if -0.025000000000000001 < z < -3.3999999999999998e-154Initial program 86.6%
associate-/l*87.9%
Simplified87.9%
Taylor expanded in t around inf 82.7%
if -3.3999999999999998e-154 < z < 5.2000000000000001e-11Initial program 89.7%
associate-/l*93.8%
Simplified93.8%
Taylor expanded in y around 0 93.6%
mul-1-neg93.6%
associate-/l*87.1%
distribute-lft-neg-out87.1%
+-commutative87.1%
div-sub87.2%
distribute-rgt-out93.8%
sub-neg93.8%
associate-/r/94.8%
Simplified94.8%
Taylor expanded in y around inf 89.3%
Final simplification81.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ (- t x) (/ (- a z) y)))))
(if (<= y -2e+131)
t_1
(if (<= y -1.05e+51)
(+ t (* y (/ (- x t) z)))
(if (<= y 4e+78) (+ x (* t (/ (- y z) (- a z)))) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((t - x) / ((a - z) / y));
double tmp;
if (y <= -2e+131) {
tmp = t_1;
} else if (y <= -1.05e+51) {
tmp = t + (y * ((x - t) / z));
} else if (y <= 4e+78) {
tmp = x + (t * ((y - z) / (a - z)));
} else {
tmp = t_1;
}
return tmp;
}
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) :: tmp
t_1 = x + ((t - x) / ((a - z) / y))
if (y <= (-2d+131)) then
tmp = t_1
else if (y <= (-1.05d+51)) then
tmp = t + (y * ((x - t) / z))
else if (y <= 4d+78) then
tmp = x + (t * ((y - z) / (a - z)))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((t - x) / ((a - z) / y));
double tmp;
if (y <= -2e+131) {
tmp = t_1;
} else if (y <= -1.05e+51) {
tmp = t + (y * ((x - t) / z));
} else if (y <= 4e+78) {
tmp = x + (t * ((y - z) / (a - z)));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + ((t - x) / ((a - z) / y)) tmp = 0 if y <= -2e+131: tmp = t_1 elif y <= -1.05e+51: tmp = t + (y * ((x - t) / z)) elif y <= 4e+78: tmp = x + (t * ((y - z) / (a - z))) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(t - x) / Float64(Float64(a - z) / y))) tmp = 0.0 if (y <= -2e+131) tmp = t_1; elseif (y <= -1.05e+51) tmp = Float64(t + Float64(y * Float64(Float64(x - t) / z))); elseif (y <= 4e+78) tmp = Float64(x + Float64(t * Float64(Float64(y - z) / Float64(a - z)))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + ((t - x) / ((a - z) / y)); tmp = 0.0; if (y <= -2e+131) tmp = t_1; elseif (y <= -1.05e+51) tmp = t + (y * ((x - t) / z)); elseif (y <= 4e+78) tmp = x + (t * ((y - z) / (a - z))); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(t - x), $MachinePrecision] / N[(N[(a - z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2e+131], t$95$1, If[LessEqual[y, -1.05e+51], N[(t + N[(y * N[(N[(x - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4e+78], N[(x + N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{t - x}{\frac{a - z}{y}}\\
\mathbf{if}\;y \leq -2 \cdot 10^{+131}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -1.05 \cdot 10^{+51}:\\
\;\;\;\;t + y \cdot \frac{x - t}{z}\\
\mathbf{elif}\;y \leq 4 \cdot 10^{+78}:\\
\;\;\;\;x + t \cdot \frac{y - z}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -1.9999999999999998e131 or 4.00000000000000003e78 < y Initial program 77.1%
associate-/l*88.2%
Simplified88.2%
Taylor expanded in y around 0 82.0%
mul-1-neg82.0%
associate-/l*80.6%
distribute-lft-neg-out80.6%
+-commutative80.6%
div-sub80.6%
distribute-rgt-out88.2%
sub-neg88.2%
associate-/r/93.8%
Simplified93.8%
Taylor expanded in y around inf 88.3%
if -1.9999999999999998e131 < y < -1.0500000000000001e51Initial program 58.3%
+-commutative58.3%
*-commutative58.3%
associate-/l*65.3%
fma-define65.2%
Simplified65.2%
Taylor expanded in z around inf 86.2%
associate--l+86.2%
associate-*r/86.2%
associate-*r/86.2%
mul-1-neg86.2%
div-sub93.3%
mul-1-neg93.3%
distribute-lft-out--93.3%
associate-*r/93.3%
mul-1-neg93.3%
unsub-neg93.3%
distribute-rgt-out--93.3%
Simplified93.3%
Taylor expanded in y around inf 93.3%
associate-/l*99.9%
Simplified99.9%
if -1.0500000000000001e51 < y < 4.00000000000000003e78Initial program 71.3%
associate-/l*77.0%
Simplified77.0%
Taylor expanded in t around inf 69.1%
associate-/l*76.8%
Simplified76.8%
Final simplification81.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (+ (/ (- a y) z) 1.0))))
(if (<= z -1.1e+53)
t_1
(if (<= z -3.3e-12)
(/ (* x (- y a)) z)
(if (<= z 2.6e-10) (+ x (* t (/ y a))) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * (((a - y) / z) + 1.0);
double tmp;
if (z <= -1.1e+53) {
tmp = t_1;
} else if (z <= -3.3e-12) {
tmp = (x * (y - a)) / z;
} else if (z <= 2.6e-10) {
tmp = x + (t * (y / a));
} else {
tmp = t_1;
}
return tmp;
}
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) :: tmp
t_1 = t * (((a - y) / z) + 1.0d0)
if (z <= (-1.1d+53)) then
tmp = t_1
else if (z <= (-3.3d-12)) then
tmp = (x * (y - a)) / z
else if (z <= 2.6d-10) then
tmp = x + (t * (y / a))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * (((a - y) / z) + 1.0);
double tmp;
if (z <= -1.1e+53) {
tmp = t_1;
} else if (z <= -3.3e-12) {
tmp = (x * (y - a)) / z;
} else if (z <= 2.6e-10) {
tmp = x + (t * (y / a));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * (((a - y) / z) + 1.0) tmp = 0 if z <= -1.1e+53: tmp = t_1 elif z <= -3.3e-12: tmp = (x * (y - a)) / z elif z <= 2.6e-10: tmp = x + (t * (y / a)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(Float64(Float64(a - y) / z) + 1.0)) tmp = 0.0 if (z <= -1.1e+53) tmp = t_1; elseif (z <= -3.3e-12) tmp = Float64(Float64(x * Float64(y - a)) / z); elseif (z <= 2.6e-10) tmp = Float64(x + Float64(t * Float64(y / a))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * (((a - y) / z) + 1.0); tmp = 0.0; if (z <= -1.1e+53) tmp = t_1; elseif (z <= -3.3e-12) tmp = (x * (y - a)) / z; elseif (z <= 2.6e-10) tmp = x + (t * (y / a)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(N[(a - y), $MachinePrecision] / z), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.1e+53], t$95$1, If[LessEqual[z, -3.3e-12], N[(N[(x * N[(y - a), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, 2.6e-10], N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(\frac{a - y}{z} + 1\right)\\
\mathbf{if}\;z \leq -1.1 \cdot 10^{+53}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -3.3 \cdot 10^{-12}:\\
\;\;\;\;\frac{x \cdot \left(y - a\right)}{z}\\
\mathbf{elif}\;z \leq 2.6 \cdot 10^{-10}:\\
\;\;\;\;x + t \cdot \frac{y}{a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.09999999999999999e53 or 2.59999999999999981e-10 < z Initial program 54.8%
+-commutative54.8%
*-commutative54.8%
associate-/l*75.4%
fma-define75.4%
Simplified75.4%
Taylor expanded in z around inf 75.4%
associate--l+75.4%
associate-*r/75.4%
associate-*r/75.4%
mul-1-neg75.4%
div-sub75.4%
mul-1-neg75.4%
distribute-lft-out--75.4%
associate-*r/75.4%
mul-1-neg75.4%
unsub-neg75.4%
distribute-rgt-out--75.5%
Simplified75.5%
Taylor expanded in t around -inf 55.7%
neg-mul-155.7%
unsub-neg55.7%
Simplified55.7%
if -1.09999999999999999e53 < z < -3.3000000000000001e-12Initial program 79.0%
+-commutative79.0%
*-commutative79.0%
associate-/l*78.5%
fma-define78.5%
Simplified78.5%
Taylor expanded in z around inf 67.8%
associate--l+67.8%
associate-*r/67.8%
associate-*r/67.8%
mul-1-neg67.8%
div-sub67.8%
mul-1-neg67.8%
distribute-lft-out--67.8%
associate-*r/67.8%
mul-1-neg67.8%
unsub-neg67.8%
distribute-rgt-out--67.8%
Simplified67.8%
Taylor expanded in t around 0 67.8%
if -3.3000000000000001e-12 < z < 2.59999999999999981e-10Initial program 88.6%
associate-/l*91.9%
Simplified91.9%
Taylor expanded in t around inf 77.0%
associate-/l*77.5%
Simplified77.5%
Taylor expanded in z around 0 56.8%
+-commutative56.8%
associate-/l*59.8%
Simplified59.8%
Final simplification58.2%
(FPCore (x y z t a)
:precision binary64
(if (<= z -2.05e+154)
(+ t (/ (* (- t x) (- a y)) z))
(if (<= z 4.4e+235)
(+ x (* (/ (- t x) (- z a)) (- z y)))
(+ t (/ (* (- t x) a) z)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.05e+154) {
tmp = t + (((t - x) * (a - y)) / z);
} else if (z <= 4.4e+235) {
tmp = x + (((t - x) / (z - a)) * (z - y));
} else {
tmp = t + (((t - x) * a) / z);
}
return tmp;
}
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 <= (-2.05d+154)) then
tmp = t + (((t - x) * (a - y)) / z)
else if (z <= 4.4d+235) then
tmp = x + (((t - x) / (z - a)) * (z - y))
else
tmp = t + (((t - x) * a) / z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.05e+154) {
tmp = t + (((t - x) * (a - y)) / z);
} else if (z <= 4.4e+235) {
tmp = x + (((t - x) / (z - a)) * (z - y));
} else {
tmp = t + (((t - x) * a) / z);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.05e+154: tmp = t + (((t - x) * (a - y)) / z) elif z <= 4.4e+235: tmp = x + (((t - x) / (z - a)) * (z - y)) else: tmp = t + (((t - x) * a) / z) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.05e+154) tmp = Float64(t + Float64(Float64(Float64(t - x) * Float64(a - y)) / z)); elseif (z <= 4.4e+235) tmp = Float64(x + Float64(Float64(Float64(t - x) / Float64(z - a)) * Float64(z - y))); else tmp = Float64(t + Float64(Float64(Float64(t - x) * a) / z)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.05e+154) tmp = t + (((t - x) * (a - y)) / z); elseif (z <= 4.4e+235) tmp = x + (((t - x) / (z - a)) * (z - y)); else tmp = t + (((t - x) * a) / z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.05e+154], N[(t + N[(N[(N[(t - x), $MachinePrecision] * N[(a - y), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.4e+235], N[(x + N[(N[(N[(t - x), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision] * N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(N[(N[(t - x), $MachinePrecision] * a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.05 \cdot 10^{+154}:\\
\;\;\;\;t + \frac{\left(t - x\right) \cdot \left(a - y\right)}{z}\\
\mathbf{elif}\;z \leq 4.4 \cdot 10^{+235}:\\
\;\;\;\;x + \frac{t - x}{z - a} \cdot \left(z - y\right)\\
\mathbf{else}:\\
\;\;\;\;t + \frac{\left(t - x\right) \cdot a}{z}\\
\end{array}
\end{array}
if z < -2.05e154Initial program 32.0%
+-commutative32.0%
*-commutative32.0%
associate-/l*59.7%
fma-define59.7%
Simplified59.7%
Taylor expanded in z around inf 81.4%
associate--l+81.4%
associate-*r/81.4%
associate-*r/81.4%
mul-1-neg81.4%
div-sub81.4%
mul-1-neg81.4%
distribute-lft-out--81.4%
associate-*r/81.4%
mul-1-neg81.4%
unsub-neg81.4%
distribute-rgt-out--81.7%
Simplified81.7%
if -2.05e154 < z < 4.4e235Initial program 82.4%
associate-/l*88.2%
Simplified88.2%
if 4.4e235 < z Initial program 23.2%
+-commutative23.2%
*-commutative23.2%
associate-/l*51.8%
fma-define51.8%
Simplified51.8%
Taylor expanded in z around inf 88.4%
associate--l+88.4%
associate-*r/88.4%
associate-*r/88.4%
mul-1-neg88.4%
div-sub88.4%
mul-1-neg88.4%
distribute-lft-out--88.4%
associate-*r/88.4%
mul-1-neg88.4%
unsub-neg88.4%
distribute-rgt-out--88.4%
Simplified88.4%
Taylor expanded in y around 0 88.6%
neg-mul-188.6%
Simplified88.6%
Final simplification87.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- t (/ (* y t) z))))
(if (<= z -3.5e+56)
t_1
(if (<= z -1.55e-18)
(/ (* x (- y a)) z)
(if (<= z 2.3e-10) (+ x (* t (/ y a))) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t - ((y * t) / z);
double tmp;
if (z <= -3.5e+56) {
tmp = t_1;
} else if (z <= -1.55e-18) {
tmp = (x * (y - a)) / z;
} else if (z <= 2.3e-10) {
tmp = x + (t * (y / a));
} else {
tmp = t_1;
}
return tmp;
}
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) :: tmp
t_1 = t - ((y * t) / z)
if (z <= (-3.5d+56)) then
tmp = t_1
else if (z <= (-1.55d-18)) then
tmp = (x * (y - a)) / z
else if (z <= 2.3d-10) then
tmp = x + (t * (y / a))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t - ((y * t) / z);
double tmp;
if (z <= -3.5e+56) {
tmp = t_1;
} else if (z <= -1.55e-18) {
tmp = (x * (y - a)) / z;
} else if (z <= 2.3e-10) {
tmp = x + (t * (y / a));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t - ((y * t) / z) tmp = 0 if z <= -3.5e+56: tmp = t_1 elif z <= -1.55e-18: tmp = (x * (y - a)) / z elif z <= 2.3e-10: tmp = x + (t * (y / a)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t - Float64(Float64(y * t) / z)) tmp = 0.0 if (z <= -3.5e+56) tmp = t_1; elseif (z <= -1.55e-18) tmp = Float64(Float64(x * Float64(y - a)) / z); elseif (z <= 2.3e-10) tmp = Float64(x + Float64(t * Float64(y / a))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t - ((y * t) / z); tmp = 0.0; if (z <= -3.5e+56) tmp = t_1; elseif (z <= -1.55e-18) tmp = (x * (y - a)) / z; elseif (z <= 2.3e-10) tmp = x + (t * (y / a)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t - N[(N[(y * t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -3.5e+56], t$95$1, If[LessEqual[z, -1.55e-18], N[(N[(x * N[(y - a), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, 2.3e-10], N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t - \frac{y \cdot t}{z}\\
\mathbf{if}\;z \leq -3.5 \cdot 10^{+56}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -1.55 \cdot 10^{-18}:\\
\;\;\;\;\frac{x \cdot \left(y - a\right)}{z}\\
\mathbf{elif}\;z \leq 2.3 \cdot 10^{-10}:\\
\;\;\;\;x + t \cdot \frac{y}{a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -3.49999999999999999e56 or 2.30000000000000007e-10 < z Initial program 54.8%
+-commutative54.8%
*-commutative54.8%
associate-/l*75.4%
fma-define75.4%
Simplified75.4%
Taylor expanded in z around inf 75.4%
associate--l+75.4%
associate-*r/75.4%
associate-*r/75.4%
mul-1-neg75.4%
div-sub75.4%
mul-1-neg75.4%
distribute-lft-out--75.4%
associate-*r/75.4%
mul-1-neg75.4%
unsub-neg75.4%
distribute-rgt-out--75.5%
Simplified75.5%
Taylor expanded in t around inf 52.9%
associate-/l*55.7%
Simplified55.7%
Taylor expanded in y around inf 53.6%
if -3.49999999999999999e56 < z < -1.55000000000000003e-18Initial program 79.0%
+-commutative79.0%
*-commutative79.0%
associate-/l*78.5%
fma-define78.5%
Simplified78.5%
Taylor expanded in z around inf 67.8%
associate--l+67.8%
associate-*r/67.8%
associate-*r/67.8%
mul-1-neg67.8%
div-sub67.8%
mul-1-neg67.8%
distribute-lft-out--67.8%
associate-*r/67.8%
mul-1-neg67.8%
unsub-neg67.8%
distribute-rgt-out--67.8%
Simplified67.8%
Taylor expanded in t around 0 67.8%
if -1.55000000000000003e-18 < z < 2.30000000000000007e-10Initial program 88.6%
associate-/l*91.9%
Simplified91.9%
Taylor expanded in t around inf 77.0%
associate-/l*77.5%
Simplified77.5%
Taylor expanded in z around 0 56.8%
+-commutative56.8%
associate-/l*59.8%
Simplified59.8%
Final simplification57.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- t (/ (* y t) z))))
(if (<= z -6.2e+60)
t_1
(if (<= z -7.5e-15)
(* x (/ (- y a) z))
(if (<= z 1.4e-10) (+ x (* t (/ y a))) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t - ((y * t) / z);
double tmp;
if (z <= -6.2e+60) {
tmp = t_1;
} else if (z <= -7.5e-15) {
tmp = x * ((y - a) / z);
} else if (z <= 1.4e-10) {
tmp = x + (t * (y / a));
} else {
tmp = t_1;
}
return tmp;
}
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) :: tmp
t_1 = t - ((y * t) / z)
if (z <= (-6.2d+60)) then
tmp = t_1
else if (z <= (-7.5d-15)) then
tmp = x * ((y - a) / z)
else if (z <= 1.4d-10) then
tmp = x + (t * (y / a))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t - ((y * t) / z);
double tmp;
if (z <= -6.2e+60) {
tmp = t_1;
} else if (z <= -7.5e-15) {
tmp = x * ((y - a) / z);
} else if (z <= 1.4e-10) {
tmp = x + (t * (y / a));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t - ((y * t) / z) tmp = 0 if z <= -6.2e+60: tmp = t_1 elif z <= -7.5e-15: tmp = x * ((y - a) / z) elif z <= 1.4e-10: tmp = x + (t * (y / a)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t - Float64(Float64(y * t) / z)) tmp = 0.0 if (z <= -6.2e+60) tmp = t_1; elseif (z <= -7.5e-15) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (z <= 1.4e-10) tmp = Float64(x + Float64(t * Float64(y / a))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t - ((y * t) / z); tmp = 0.0; if (z <= -6.2e+60) tmp = t_1; elseif (z <= -7.5e-15) tmp = x * ((y - a) / z); elseif (z <= 1.4e-10) tmp = x + (t * (y / a)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t - N[(N[(y * t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -6.2e+60], t$95$1, If[LessEqual[z, -7.5e-15], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.4e-10], N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t - \frac{y \cdot t}{z}\\
\mathbf{if}\;z \leq -6.2 \cdot 10^{+60}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -7.5 \cdot 10^{-15}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;z \leq 1.4 \cdot 10^{-10}:\\
\;\;\;\;x + t \cdot \frac{y}{a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -6.2000000000000001e60 or 1.40000000000000008e-10 < z Initial program 54.8%
+-commutative54.8%
*-commutative54.8%
associate-/l*75.4%
fma-define75.4%
Simplified75.4%
Taylor expanded in z around inf 75.4%
associate--l+75.4%
associate-*r/75.4%
associate-*r/75.4%
mul-1-neg75.4%
div-sub75.4%
mul-1-neg75.4%
distribute-lft-out--75.4%
associate-*r/75.4%
mul-1-neg75.4%
unsub-neg75.4%
distribute-rgt-out--75.5%
Simplified75.5%
Taylor expanded in t around inf 52.9%
associate-/l*55.7%
Simplified55.7%
Taylor expanded in y around inf 53.6%
if -6.2000000000000001e60 < z < -7.4999999999999996e-15Initial program 79.0%
+-commutative79.0%
*-commutative79.0%
associate-/l*78.5%
fma-define78.5%
Simplified78.5%
Taylor expanded in z around inf 67.8%
associate--l+67.8%
associate-*r/67.8%
associate-*r/67.8%
mul-1-neg67.8%
div-sub67.8%
mul-1-neg67.8%
distribute-lft-out--67.8%
associate-*r/67.8%
mul-1-neg67.8%
unsub-neg67.8%
distribute-rgt-out--67.8%
Simplified67.8%
Taylor expanded in t around 0 67.8%
associate-/l*67.5%
Simplified67.5%
if -7.4999999999999996e-15 < z < 1.40000000000000008e-10Initial program 88.6%
associate-/l*91.9%
Simplified91.9%
Taylor expanded in t around inf 77.0%
associate-/l*77.5%
Simplified77.5%
Taylor expanded in z around 0 56.8%
+-commutative56.8%
associate-/l*59.8%
Simplified59.8%
Final simplification57.1%
(FPCore (x y z t a) :precision binary64 (if (or (<= a -3.7e-93) (not (<= a 2e-106))) (+ x (* t (/ (- y z) (- a z)))) (+ t (* y (/ (- x t) z)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -3.7e-93) || !(a <= 2e-106)) {
tmp = x + (t * ((y - z) / (a - z)));
} else {
tmp = t + (y * ((x - t) / z));
}
return tmp;
}
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 ((a <= (-3.7d-93)) .or. (.not. (a <= 2d-106))) then
tmp = x + (t * ((y - z) / (a - z)))
else
tmp = t + (y * ((x - t) / z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -3.7e-93) || !(a <= 2e-106)) {
tmp = x + (t * ((y - z) / (a - z)));
} else {
tmp = t + (y * ((x - t) / z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (a <= -3.7e-93) or not (a <= 2e-106): tmp = x + (t * ((y - z) / (a - z))) else: tmp = t + (y * ((x - t) / z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((a <= -3.7e-93) || !(a <= 2e-106)) tmp = Float64(x + Float64(t * Float64(Float64(y - z) / Float64(a - z)))); else tmp = Float64(t + Float64(y * Float64(Float64(x - t) / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((a <= -3.7e-93) || ~((a <= 2e-106))) tmp = x + (t * ((y - z) / (a - z))); else tmp = t + (y * ((x - t) / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[a, -3.7e-93], N[Not[LessEqual[a, 2e-106]], $MachinePrecision]], N[(x + N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(y * N[(N[(x - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -3.7 \cdot 10^{-93} \lor \neg \left(a \leq 2 \cdot 10^{-106}\right):\\
\;\;\;\;x + t \cdot \frac{y - z}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t + y \cdot \frac{x - t}{z}\\
\end{array}
\end{array}
if a < -3.70000000000000002e-93 or 1.99999999999999988e-106 < a Initial program 71.8%
associate-/l*83.1%
Simplified83.1%
Taylor expanded in t around inf 63.4%
associate-/l*73.1%
Simplified73.1%
if -3.70000000000000002e-93 < a < 1.99999999999999988e-106Initial program 73.6%
+-commutative73.6%
*-commutative73.6%
associate-/l*79.1%
fma-define79.0%
Simplified79.0%
Taylor expanded in z around inf 86.1%
associate--l+86.1%
associate-*r/86.1%
associate-*r/86.1%
mul-1-neg86.1%
div-sub86.1%
mul-1-neg86.1%
distribute-lft-out--86.1%
associate-*r/86.1%
mul-1-neg86.1%
unsub-neg86.1%
distribute-rgt-out--86.1%
Simplified86.1%
Taylor expanded in y around inf 81.8%
associate-/l*80.5%
Simplified80.5%
Final simplification75.6%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -6.4e+38) (not (<= z 5.8e-11))) (* t (+ (/ (- a y) z) 1.0)) (+ x (* y (/ (- t x) a)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -6.4e+38) || !(z <= 5.8e-11)) {
tmp = t * (((a - y) / z) + 1.0);
} else {
tmp = x + (y * ((t - x) / a));
}
return tmp;
}
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 <= (-6.4d+38)) .or. (.not. (z <= 5.8d-11))) then
tmp = t * (((a - y) / z) + 1.0d0)
else
tmp = x + (y * ((t - x) / a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -6.4e+38) || !(z <= 5.8e-11)) {
tmp = t * (((a - y) / z) + 1.0);
} else {
tmp = x + (y * ((t - x) / a));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -6.4e+38) or not (z <= 5.8e-11): tmp = t * (((a - y) / z) + 1.0) else: tmp = x + (y * ((t - x) / a)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -6.4e+38) || !(z <= 5.8e-11)) tmp = Float64(t * Float64(Float64(Float64(a - y) / z) + 1.0)); else tmp = Float64(x + Float64(y * Float64(Float64(t - x) / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -6.4e+38) || ~((z <= 5.8e-11))) tmp = t * (((a - y) / z) + 1.0); else tmp = x + (y * ((t - x) / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -6.4e+38], N[Not[LessEqual[z, 5.8e-11]], $MachinePrecision]], N[(t * N[(N[(N[(a - y), $MachinePrecision] / z), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(x + N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -6.4 \cdot 10^{+38} \lor \neg \left(z \leq 5.8 \cdot 10^{-11}\right):\\
\;\;\;\;t \cdot \left(\frac{a - y}{z} + 1\right)\\
\mathbf{else}:\\
\;\;\;\;x + y \cdot \frac{t - x}{a}\\
\end{array}
\end{array}
if z < -6.3999999999999997e38 or 5.8e-11 < z Initial program 54.0%
+-commutative54.0%
*-commutative54.0%
associate-/l*74.2%
fma-define74.2%
Simplified74.2%
Taylor expanded in z around inf 75.8%
associate--l+75.8%
associate-*r/75.8%
associate-*r/75.8%
mul-1-neg75.8%
div-sub75.8%
mul-1-neg75.8%
distribute-lft-out--75.8%
associate-*r/75.8%
mul-1-neg75.8%
unsub-neg75.8%
distribute-rgt-out--75.9%
Simplified75.9%
Taylor expanded in t around -inf 54.9%
neg-mul-154.9%
unsub-neg54.9%
Simplified54.9%
if -6.3999999999999997e38 < z < 5.8e-11Initial program 89.2%
associate-/l*92.3%
Simplified92.3%
Taylor expanded in z around 0 64.1%
associate-/l*68.3%
Simplified68.3%
Final simplification61.9%
(FPCore (x y z t a) :precision binary64 (if (<= z -17500.0) t (if (<= z 2.85e-128) x (if (<= z 2.7e+234) (+ x t) t))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -17500.0) {
tmp = t;
} else if (z <= 2.85e-128) {
tmp = x;
} else if (z <= 2.7e+234) {
tmp = x + t;
} else {
tmp = t;
}
return tmp;
}
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 <= (-17500.0d0)) then
tmp = t
else if (z <= 2.85d-128) then
tmp = x
else if (z <= 2.7d+234) then
tmp = x + t
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -17500.0) {
tmp = t;
} else if (z <= 2.85e-128) {
tmp = x;
} else if (z <= 2.7e+234) {
tmp = x + t;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -17500.0: tmp = t elif z <= 2.85e-128: tmp = x elif z <= 2.7e+234: tmp = x + t else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -17500.0) tmp = t; elseif (z <= 2.85e-128) tmp = x; elseif (z <= 2.7e+234) tmp = Float64(x + t); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -17500.0) tmp = t; elseif (z <= 2.85e-128) tmp = x; elseif (z <= 2.7e+234) tmp = x + t; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -17500.0], t, If[LessEqual[z, 2.85e-128], x, If[LessEqual[z, 2.7e+234], N[(x + t), $MachinePrecision], t]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -17500:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 2.85 \cdot 10^{-128}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 2.7 \cdot 10^{+234}:\\
\;\;\;\;x + t\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -17500 or 2.7000000000000002e234 < z Initial program 41.3%
associate-/l*52.8%
Simplified52.8%
Taylor expanded in y around 0 41.1%
mul-1-neg41.1%
associate-/l*52.8%
distribute-lft-neg-out52.8%
+-commutative52.8%
div-sub52.8%
distribute-rgt-out52.8%
sub-neg52.8%
associate-/r/62.4%
Simplified62.4%
Taylor expanded in z around inf 54.9%
if -17500 < z < 2.84999999999999992e-128Initial program 89.4%
+-commutative89.4%
*-commutative89.4%
associate-/l*92.7%
fma-define92.7%
Simplified92.7%
Taylor expanded in a around inf 40.4%
if 2.84999999999999992e-128 < z < 2.7000000000000002e234Initial program 75.7%
associate-/l*87.0%
Simplified87.0%
Taylor expanded in t around inf 57.7%
associate-/l*69.1%
Simplified69.1%
Taylor expanded in z around inf 43.7%
(FPCore (x y z t a) :precision binary64 (if (<= z -2.7e+38) t (if (<= z 6.5e-17) (* x (- 1.0 (/ y a))) t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.7e+38) {
tmp = t;
} else if (z <= 6.5e-17) {
tmp = x * (1.0 - (y / a));
} else {
tmp = t;
}
return tmp;
}
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 <= (-2.7d+38)) then
tmp = t
else if (z <= 6.5d-17) then
tmp = x * (1.0d0 - (y / a))
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.7e+38) {
tmp = t;
} else if (z <= 6.5e-17) {
tmp = x * (1.0 - (y / a));
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.7e+38: tmp = t elif z <= 6.5e-17: tmp = x * (1.0 - (y / a)) else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.7e+38) tmp = t; elseif (z <= 6.5e-17) tmp = Float64(x * Float64(1.0 - Float64(y / a))); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.7e+38) tmp = t; elseif (z <= 6.5e-17) tmp = x * (1.0 - (y / a)); else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.7e+38], t, If[LessEqual[z, 6.5e-17], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.7 \cdot 10^{+38}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 6.5 \cdot 10^{-17}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -2.69999999999999996e38 or 6.4999999999999996e-17 < z Initial program 54.3%
associate-/l*66.3%
Simplified66.3%
Taylor expanded in y around 0 51.9%
mul-1-neg51.9%
associate-/l*66.3%
distribute-lft-neg-out66.3%
+-commutative66.3%
div-sub66.3%
distribute-rgt-out66.3%
sub-neg66.3%
associate-/r/74.4%
Simplified74.4%
Taylor expanded in z around inf 47.6%
if -2.69999999999999996e38 < z < 6.4999999999999996e-17Initial program 89.1%
+-commutative89.1%
*-commutative89.1%
associate-/l*93.0%
fma-define93.0%
Simplified93.0%
Taylor expanded in t around 0 55.7%
*-rgt-identity55.7%
mul-1-neg55.7%
associate-/l*61.9%
distribute-rgt-neg-in61.9%
mul-1-neg61.9%
distribute-lft-in61.9%
mul-1-neg61.9%
unsub-neg61.9%
Simplified61.9%
Taylor expanded in z around 0 55.5%
(FPCore (x y z t a) :precision binary64 (if (or (<= y -1.95e+62) (not (<= y 1.9e+57))) (* x (/ y z)) (+ x t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((y <= -1.95e+62) || !(y <= 1.9e+57)) {
tmp = x * (y / z);
} else {
tmp = x + t;
}
return tmp;
}
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 ((y <= (-1.95d+62)) .or. (.not. (y <= 1.9d+57))) then
tmp = x * (y / z)
else
tmp = x + t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((y <= -1.95e+62) || !(y <= 1.9e+57)) {
tmp = x * (y / z);
} else {
tmp = x + t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (y <= -1.95e+62) or not (y <= 1.9e+57): tmp = x * (y / z) else: tmp = x + t return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((y <= -1.95e+62) || !(y <= 1.9e+57)) tmp = Float64(x * Float64(y / z)); else tmp = Float64(x + t); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((y <= -1.95e+62) || ~((y <= 1.9e+57))) tmp = x * (y / z); else tmp = x + t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[y, -1.95e+62], N[Not[LessEqual[y, 1.9e+57]], $MachinePrecision]], N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision], N[(x + t), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.95 \cdot 10^{+62} \lor \neg \left(y \leq 1.9 \cdot 10^{+57}\right):\\
\;\;\;\;x \cdot \frac{y}{z}\\
\mathbf{else}:\\
\;\;\;\;x + t\\
\end{array}
\end{array}
if y < -1.95e62 or 1.8999999999999999e57 < y Initial program 76.1%
+-commutative76.1%
*-commutative76.1%
associate-/l*90.4%
fma-define90.4%
Simplified90.4%
Taylor expanded in t around 0 45.7%
*-rgt-identity45.7%
mul-1-neg45.7%
associate-/l*54.9%
distribute-rgt-neg-in54.9%
mul-1-neg54.9%
distribute-lft-in54.9%
mul-1-neg54.9%
unsub-neg54.9%
Simplified54.9%
Taylor expanded in a around 0 42.3%
if -1.95e62 < y < 1.8999999999999999e57Initial program 70.3%
associate-/l*76.5%
Simplified76.5%
Taylor expanded in t around inf 68.1%
associate-/l*76.4%
Simplified76.4%
Taylor expanded in z around inf 50.9%
Final simplification47.8%
(FPCore (x y z t a) :precision binary64 (if (<= z -23500.0) t (if (<= z 1.55e-30) x t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -23500.0) {
tmp = t;
} else if (z <= 1.55e-30) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
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 <= (-23500.0d0)) then
tmp = t
else if (z <= 1.55d-30) then
tmp = x
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -23500.0) {
tmp = t;
} else if (z <= 1.55e-30) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -23500.0: tmp = t elif z <= 1.55e-30: tmp = x else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -23500.0) tmp = t; elseif (z <= 1.55e-30) tmp = x; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -23500.0) tmp = t; elseif (z <= 1.55e-30) tmp = x; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -23500.0], t, If[LessEqual[z, 1.55e-30], x, t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -23500:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 1.55 \cdot 10^{-30}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -23500 or 1.54999999999999995e-30 < z Initial program 55.4%
associate-/l*67.6%
Simplified67.6%
Taylor expanded in y around 0 52.9%
mul-1-neg52.9%
associate-/l*67.6%
distribute-lft-neg-out67.6%
+-commutative67.6%
div-sub67.6%
distribute-rgt-out67.6%
sub-neg67.6%
associate-/r/74.6%
Simplified74.6%
Taylor expanded in z around inf 45.9%
if -23500 < z < 1.54999999999999995e-30Initial program 89.4%
+-commutative89.4%
*-commutative89.4%
associate-/l*93.0%
fma-define93.0%
Simplified93.0%
Taylor expanded in a around inf 40.9%
(FPCore (x y z t a) :precision binary64 t)
double code(double x, double y, double z, double t, double a) {
return t;
}
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 = t
end function
public static double code(double x, double y, double z, double t, double a) {
return t;
}
def code(x, y, z, t, a): return t
function code(x, y, z, t, a) return t end
function tmp = code(x, y, z, t, a) tmp = t; end
code[x_, y_, z_, t_, a_] := t
\begin{array}{l}
\\
t
\end{array}
Initial program 72.4%
associate-/l*79.8%
Simplified79.8%
Taylor expanded in y around 0 72.4%
mul-1-neg72.4%
associate-/l*77.0%
distribute-lft-neg-out77.0%
+-commutative77.0%
div-sub77.0%
distribute-rgt-out79.8%
sub-neg79.8%
associate-/r/83.5%
Simplified83.5%
Taylor expanded in z around inf 27.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- t (* (/ y z) (- t x)))))
(if (< z -1.2536131056095036e+188)
t_1
(if (< z 4.446702369113811e+64)
(+ x (/ (- y z) (/ (- a z) (- t x))))
t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t - ((y / z) * (t - x));
double tmp;
if (z < -1.2536131056095036e+188) {
tmp = t_1;
} else if (z < 4.446702369113811e+64) {
tmp = x + ((y - z) / ((a - z) / (t - x)));
} else {
tmp = t_1;
}
return tmp;
}
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) :: tmp
t_1 = t - ((y / z) * (t - x))
if (z < (-1.2536131056095036d+188)) then
tmp = t_1
else if (z < 4.446702369113811d+64) then
tmp = x + ((y - z) / ((a - z) / (t - x)))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t - ((y / z) * (t - x));
double tmp;
if (z < -1.2536131056095036e+188) {
tmp = t_1;
} else if (z < 4.446702369113811e+64) {
tmp = x + ((y - z) / ((a - z) / (t - x)));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t - ((y / z) * (t - x)) tmp = 0 if z < -1.2536131056095036e+188: tmp = t_1 elif z < 4.446702369113811e+64: tmp = x + ((y - z) / ((a - z) / (t - x))) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t - Float64(Float64(y / z) * Float64(t - x))) tmp = 0.0 if (z < -1.2536131056095036e+188) tmp = t_1; elseif (z < 4.446702369113811e+64) tmp = Float64(x + Float64(Float64(y - z) / Float64(Float64(a - z) / Float64(t - x)))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t - ((y / z) * (t - x)); tmp = 0.0; if (z < -1.2536131056095036e+188) tmp = t_1; elseif (z < 4.446702369113811e+64) tmp = x + ((y - z) / ((a - z) / (t - x))); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t - N[(N[(y / z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[z, -1.2536131056095036e+188], t$95$1, If[Less[z, 4.446702369113811e+64], N[(x + N[(N[(y - z), $MachinePrecision] / N[(N[(a - z), $MachinePrecision] / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t - \frac{y}{z} \cdot \left(t - x\right)\\
\mathbf{if}\;z < -1.2536131056095036 \cdot 10^{+188}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z < 4.446702369113811 \cdot 10^{+64}:\\
\;\;\;\;x + \frac{y - z}{\frac{a - z}{t - x}}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
herbie shell --seed 2024145
(FPCore (x y z t a)
:name "Graphics.Rendering.Chart.Axis.Types:invLinMap from Chart-1.5.3"
:precision binary64
:alt
(! :herbie-platform default (if (< z -125361310560950360000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (- t (* (/ y z) (- t x))) (if (< z 44467023691138110000000000000000000000000000000000000000000000000) (+ x (/ (- y z) (/ (- a z) (- t x)))) (- t (* (/ y z) (- t x))))))
(+ x (/ (* (- y z) (- t x)) (- a z))))