
(FPCore (x y z t a) :precision binary64 (+ x (/ (* (- y x) (- z t)) (- a t))))
double code(double x, double y, double z, double t, double a) {
return x + (((y - x) * (z - t)) / (a - 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 = x + (((y - x) * (z - t)) / (a - t))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + (((y - x) * (z - t)) / (a - t));
}
def code(x, y, z, t, a): return x + (((y - x) * (z - t)) / (a - t))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(Float64(y - x) * Float64(z - t)) / Float64(a - t))) end
function tmp = code(x, y, z, t, a) tmp = x + (((y - x) * (z - t)) / (a - t)); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(N[(y - x), $MachinePrecision] * N[(z - t), $MachinePrecision]), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{\left(y - x\right) \cdot \left(z - t\right)}{a - t}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 26 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (+ x (/ (* (- y x) (- z t)) (- a t))))
double code(double x, double y, double z, double t, double a) {
return x + (((y - x) * (z - t)) / (a - 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 = x + (((y - x) * (z - t)) / (a - t))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + (((y - x) * (z - t)) / (a - t));
}
def code(x, y, z, t, a): return x + (((y - x) * (z - t)) / (a - t))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(Float64(y - x) * Float64(z - t)) / Float64(a - t))) end
function tmp = code(x, y, z, t, a) tmp = x + (((y - x) * (z - t)) / (a - t)); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(N[(y - x), $MachinePrecision] * N[(z - t), $MachinePrecision]), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{\left(y - x\right) \cdot \left(z - t\right)}{a - t}
\end{array}
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- x (/ (* (- y x) (- t z)) (- a t)))))
(if (<= t_1 (- INFINITY))
(+ x (/ (- y x) (/ (- a t) (- z t))))
(if (<= t_1 -1e-236)
t_1
(if (<= t_1 0.0)
(- y (/ (- y x) (/ t (- z a))))
(fma (/ (- z t) (- a t)) (- y x) x))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x - (((y - x) * (t - z)) / (a - t));
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = x + ((y - x) / ((a - t) / (z - t)));
} else if (t_1 <= -1e-236) {
tmp = t_1;
} else if (t_1 <= 0.0) {
tmp = y - ((y - x) / (t / (z - a)));
} else {
tmp = fma(((z - t) / (a - t)), (y - x), x);
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(x - Float64(Float64(Float64(y - x) * Float64(t - z)) / Float64(a - t))) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = Float64(x + Float64(Float64(y - x) / Float64(Float64(a - t) / Float64(z - t)))); elseif (t_1 <= -1e-236) tmp = t_1; elseif (t_1 <= 0.0) tmp = Float64(y - Float64(Float64(y - x) / Float64(t / Float64(z - a)))); else tmp = fma(Float64(Float64(z - t) / Float64(a - t)), Float64(y - x), x); end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(N[(N[(y - x), $MachinePrecision] * N[(t - z), $MachinePrecision]), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], N[(x + N[(N[(y - x), $MachinePrecision] / N[(N[(a - t), $MachinePrecision] / N[(z - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -1e-236], t$95$1, If[LessEqual[t$95$1, 0.0], N[(y - N[(N[(y - x), $MachinePrecision] / N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision] * N[(y - x), $MachinePrecision] + x), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - \frac{\left(y - x\right) \cdot \left(t - z\right)}{a - t}\\
\mathbf{if}\;t_1 \leq -\infty:\\
\;\;\;\;x + \frac{y - x}{\frac{a - t}{z - t}}\\
\mathbf{elif}\;t_1 \leq -1 \cdot 10^{-236}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t_1 \leq 0:\\
\;\;\;\;y - \frac{y - x}{\frac{t}{z - a}}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{z - t}{a - t}, y - x, x\right)\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < -inf.0Initial program 35.9%
associate-/l*86.5%
Simplified86.5%
if -inf.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < -1e-236Initial program 97.5%
if -1e-236 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < 0.0Initial program 10.2%
+-commutative10.2%
associate-*r/10.2%
*-commutative10.2%
fma-def10.2%
Simplified10.2%
Taylor expanded in t around inf 99.8%
*-commutative99.8%
cancel-sign-sub-inv99.8%
metadata-eval99.8%
*-lft-identity99.8%
distribute-lft-in99.8%
mul-1-neg99.8%
distribute-rgt-neg-in99.8%
mul-1-neg99.8%
*-commutative99.8%
cancel-sign-sub99.8%
mul-1-neg99.8%
associate-*r*99.8%
distribute-lft-out--99.8%
associate-*r/99.8%
mul-1-neg99.8%
Simplified99.9%
if 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) Initial program 80.7%
+-commutative80.7%
associate-*r/93.1%
*-commutative93.1%
fma-def93.1%
Simplified93.1%
Final simplification93.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- x (/ (* (- y x) (- t z)) (- a t)))))
(if (or (<= t_1 (- INFINITY))
(not
(or (<= t_1 -1e-236) (and (not (<= t_1 0.0)) (<= t_1 1e+296)))))
(- y (/ (- y x) (/ t (- z a))))
t_1)))
double code(double x, double y, double z, double t, double a) {
double t_1 = x - (((y - x) * (t - z)) / (a - t));
double tmp;
if ((t_1 <= -((double) INFINITY)) || !((t_1 <= -1e-236) || (!(t_1 <= 0.0) && (t_1 <= 1e+296)))) {
tmp = y - ((y - x) / (t / (z - a)));
} else {
tmp = t_1;
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x - (((y - x) * (t - z)) / (a - t));
double tmp;
if ((t_1 <= -Double.POSITIVE_INFINITY) || !((t_1 <= -1e-236) || (!(t_1 <= 0.0) && (t_1 <= 1e+296)))) {
tmp = y - ((y - x) / (t / (z - a)));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x - (((y - x) * (t - z)) / (a - t)) tmp = 0 if (t_1 <= -math.inf) or not ((t_1 <= -1e-236) or (not (t_1 <= 0.0) and (t_1 <= 1e+296))): tmp = y - ((y - x) / (t / (z - a))) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(x - Float64(Float64(Float64(y - x) * Float64(t - z)) / Float64(a - t))) tmp = 0.0 if ((t_1 <= Float64(-Inf)) || !((t_1 <= -1e-236) || (!(t_1 <= 0.0) && (t_1 <= 1e+296)))) tmp = Float64(y - Float64(Float64(y - x) / Float64(t / Float64(z - a)))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x - (((y - x) * (t - z)) / (a - t)); tmp = 0.0; if ((t_1 <= -Inf) || ~(((t_1 <= -1e-236) || (~((t_1 <= 0.0)) && (t_1 <= 1e+296))))) tmp = y - ((y - x) / (t / (z - a))); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(N[(N[(y - x), $MachinePrecision] * N[(t - z), $MachinePrecision]), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, (-Infinity)], N[Not[Or[LessEqual[t$95$1, -1e-236], And[N[Not[LessEqual[t$95$1, 0.0]], $MachinePrecision], LessEqual[t$95$1, 1e+296]]]], $MachinePrecision]], N[(y - N[(N[(y - x), $MachinePrecision] / N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - \frac{\left(y - x\right) \cdot \left(t - z\right)}{a - t}\\
\mathbf{if}\;t_1 \leq -\infty \lor \neg \left(t_1 \leq -1 \cdot 10^{-236} \lor \neg \left(t_1 \leq 0\right) \land t_1 \leq 10^{+296}\right):\\
\;\;\;\;y - \frac{y - x}{\frac{t}{z - a}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < -inf.0 or -1e-236 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < 0.0 or 9.99999999999999981e295 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) Initial program 34.5%
+-commutative34.5%
associate-*r/72.1%
*-commutative72.1%
fma-def72.1%
Simplified72.1%
Taylor expanded in t around inf 62.2%
*-commutative62.2%
cancel-sign-sub-inv62.2%
metadata-eval62.2%
*-lft-identity62.2%
distribute-lft-in61.0%
mul-1-neg61.0%
distribute-rgt-neg-in61.0%
mul-1-neg61.0%
*-commutative61.0%
cancel-sign-sub61.0%
mul-1-neg61.0%
associate-*r*61.0%
distribute-lft-out--61.0%
associate-*r/61.0%
mul-1-neg61.0%
Simplified73.6%
if -inf.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < -1e-236 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < 9.99999999999999981e295Initial program 97.7%
Final simplification88.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ (- y x) (/ (- a t) (- z t)))))
(t_2 (- x (/ (* (- y x) (- t z)) (- a t)))))
(if (<= t_2 (- INFINITY))
t_1
(if (<= t_2 -1e-236)
t_2
(if (<= t_2 0.0) (- y (/ (- y x) (/ t (- z a)))) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((y - x) / ((a - t) / (z - t)));
double t_2 = x - (((y - x) * (t - z)) / (a - t));
double tmp;
if (t_2 <= -((double) INFINITY)) {
tmp = t_1;
} else if (t_2 <= -1e-236) {
tmp = t_2;
} else if (t_2 <= 0.0) {
tmp = y - ((y - x) / (t / (z - a)));
} else {
tmp = t_1;
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((y - x) / ((a - t) / (z - t)));
double t_2 = x - (((y - x) * (t - z)) / (a - t));
double tmp;
if (t_2 <= -Double.POSITIVE_INFINITY) {
tmp = t_1;
} else if (t_2 <= -1e-236) {
tmp = t_2;
} else if (t_2 <= 0.0) {
tmp = y - ((y - x) / (t / (z - a)));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + ((y - x) / ((a - t) / (z - t))) t_2 = x - (((y - x) * (t - z)) / (a - t)) tmp = 0 if t_2 <= -math.inf: tmp = t_1 elif t_2 <= -1e-236: tmp = t_2 elif t_2 <= 0.0: tmp = y - ((y - x) / (t / (z - a))) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(y - x) / Float64(Float64(a - t) / Float64(z - t)))) t_2 = Float64(x - Float64(Float64(Float64(y - x) * Float64(t - z)) / Float64(a - t))) tmp = 0.0 if (t_2 <= Float64(-Inf)) tmp = t_1; elseif (t_2 <= -1e-236) tmp = t_2; elseif (t_2 <= 0.0) tmp = Float64(y - Float64(Float64(y - x) / Float64(t / Float64(z - a)))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + ((y - x) / ((a - t) / (z - t))); t_2 = x - (((y - x) * (t - z)) / (a - t)); tmp = 0.0; if (t_2 <= -Inf) tmp = t_1; elseif (t_2 <= -1e-236) tmp = t_2; elseif (t_2 <= 0.0) tmp = y - ((y - x) / (t / (z - a))); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(y - x), $MachinePrecision] / N[(N[(a - t), $MachinePrecision] / N[(z - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(N[(N[(y - x), $MachinePrecision] * N[(t - z), $MachinePrecision]), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, (-Infinity)], t$95$1, If[LessEqual[t$95$2, -1e-236], t$95$2, If[LessEqual[t$95$2, 0.0], N[(y - N[(N[(y - x), $MachinePrecision] / N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{y - x}{\frac{a - t}{z - t}}\\
t_2 := x - \frac{\left(y - x\right) \cdot \left(t - z\right)}{a - t}\\
\mathbf{if}\;t_2 \leq -\infty:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t_2 \leq -1 \cdot 10^{-236}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t_2 \leq 0:\\
\;\;\;\;y - \frac{y - x}{\frac{t}{z - a}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < -inf.0 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) Initial program 68.6%
associate-/l*91.3%
Simplified91.3%
if -inf.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < -1e-236Initial program 97.5%
if -1e-236 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < 0.0Initial program 10.2%
+-commutative10.2%
associate-*r/10.2%
*-commutative10.2%
fma-def10.2%
Simplified10.2%
Taylor expanded in t around inf 99.8%
*-commutative99.8%
cancel-sign-sub-inv99.8%
metadata-eval99.8%
*-lft-identity99.8%
distribute-lft-in99.8%
mul-1-neg99.8%
distribute-rgt-neg-in99.8%
mul-1-neg99.8%
*-commutative99.8%
cancel-sign-sub99.8%
mul-1-neg99.8%
associate-*r*99.8%
distribute-lft-out--99.8%
associate-*r/99.8%
mul-1-neg99.8%
Simplified99.9%
Final simplification93.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- y (* z (/ y t)))))
(if (<= t -1.2e+121)
(* y (/ (- t) (- a t)))
(if (<= t -1.2e+59)
(/ (- y x) (/ a z))
(if (<= t -5.3e-5)
t_1
(if (<= t -1.05e-70)
(/ (- z) (/ (- a t) x))
(if (<= t -9.6e-91)
t_1
(if (<= t -3.8e-274)
x
(if (<= t 2.55e-235)
(/ z (/ a (- y x)))
(if (<= t 1.65e-14)
(* y (/ z (- a t)))
(if (<= t 390000000.0) x t_1)))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y - (z * (y / t));
double tmp;
if (t <= -1.2e+121) {
tmp = y * (-t / (a - t));
} else if (t <= -1.2e+59) {
tmp = (y - x) / (a / z);
} else if (t <= -5.3e-5) {
tmp = t_1;
} else if (t <= -1.05e-70) {
tmp = -z / ((a - t) / x);
} else if (t <= -9.6e-91) {
tmp = t_1;
} else if (t <= -3.8e-274) {
tmp = x;
} else if (t <= 2.55e-235) {
tmp = z / (a / (y - x));
} else if (t <= 1.65e-14) {
tmp = y * (z / (a - t));
} else if (t <= 390000000.0) {
tmp = 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 = y - (z * (y / t))
if (t <= (-1.2d+121)) then
tmp = y * (-t / (a - t))
else if (t <= (-1.2d+59)) then
tmp = (y - x) / (a / z)
else if (t <= (-5.3d-5)) then
tmp = t_1
else if (t <= (-1.05d-70)) then
tmp = -z / ((a - t) / x)
else if (t <= (-9.6d-91)) then
tmp = t_1
else if (t <= (-3.8d-274)) then
tmp = x
else if (t <= 2.55d-235) then
tmp = z / (a / (y - x))
else if (t <= 1.65d-14) then
tmp = y * (z / (a - t))
else if (t <= 390000000.0d0) then
tmp = 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 = y - (z * (y / t));
double tmp;
if (t <= -1.2e+121) {
tmp = y * (-t / (a - t));
} else if (t <= -1.2e+59) {
tmp = (y - x) / (a / z);
} else if (t <= -5.3e-5) {
tmp = t_1;
} else if (t <= -1.05e-70) {
tmp = -z / ((a - t) / x);
} else if (t <= -9.6e-91) {
tmp = t_1;
} else if (t <= -3.8e-274) {
tmp = x;
} else if (t <= 2.55e-235) {
tmp = z / (a / (y - x));
} else if (t <= 1.65e-14) {
tmp = y * (z / (a - t));
} else if (t <= 390000000.0) {
tmp = x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y - (z * (y / t)) tmp = 0 if t <= -1.2e+121: tmp = y * (-t / (a - t)) elif t <= -1.2e+59: tmp = (y - x) / (a / z) elif t <= -5.3e-5: tmp = t_1 elif t <= -1.05e-70: tmp = -z / ((a - t) / x) elif t <= -9.6e-91: tmp = t_1 elif t <= -3.8e-274: tmp = x elif t <= 2.55e-235: tmp = z / (a / (y - x)) elif t <= 1.65e-14: tmp = y * (z / (a - t)) elif t <= 390000000.0: tmp = x else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(y - Float64(z * Float64(y / t))) tmp = 0.0 if (t <= -1.2e+121) tmp = Float64(y * Float64(Float64(-t) / Float64(a - t))); elseif (t <= -1.2e+59) tmp = Float64(Float64(y - x) / Float64(a / z)); elseif (t <= -5.3e-5) tmp = t_1; elseif (t <= -1.05e-70) tmp = Float64(Float64(-z) / Float64(Float64(a - t) / x)); elseif (t <= -9.6e-91) tmp = t_1; elseif (t <= -3.8e-274) tmp = x; elseif (t <= 2.55e-235) tmp = Float64(z / Float64(a / Float64(y - x))); elseif (t <= 1.65e-14) tmp = Float64(y * Float64(z / Float64(a - t))); elseif (t <= 390000000.0) tmp = x; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y - (z * (y / t)); tmp = 0.0; if (t <= -1.2e+121) tmp = y * (-t / (a - t)); elseif (t <= -1.2e+59) tmp = (y - x) / (a / z); elseif (t <= -5.3e-5) tmp = t_1; elseif (t <= -1.05e-70) tmp = -z / ((a - t) / x); elseif (t <= -9.6e-91) tmp = t_1; elseif (t <= -3.8e-274) tmp = x; elseif (t <= 2.55e-235) tmp = z / (a / (y - x)); elseif (t <= 1.65e-14) tmp = y * (z / (a - t)); elseif (t <= 390000000.0) tmp = x; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y - N[(z * N[(y / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.2e+121], N[(y * N[((-t) / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.2e+59], N[(N[(y - x), $MachinePrecision] / N[(a / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -5.3e-5], t$95$1, If[LessEqual[t, -1.05e-70], N[((-z) / N[(N[(a - t), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -9.6e-91], t$95$1, If[LessEqual[t, -3.8e-274], x, If[LessEqual[t, 2.55e-235], N[(z / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.65e-14], N[(y * N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 390000000.0], x, t$95$1]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y - z \cdot \frac{y}{t}\\
\mathbf{if}\;t \leq -1.2 \cdot 10^{+121}:\\
\;\;\;\;y \cdot \frac{-t}{a - t}\\
\mathbf{elif}\;t \leq -1.2 \cdot 10^{+59}:\\
\;\;\;\;\frac{y - x}{\frac{a}{z}}\\
\mathbf{elif}\;t \leq -5.3 \cdot 10^{-5}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -1.05 \cdot 10^{-70}:\\
\;\;\;\;\frac{-z}{\frac{a - t}{x}}\\
\mathbf{elif}\;t \leq -9.6 \cdot 10^{-91}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -3.8 \cdot 10^{-274}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 2.55 \cdot 10^{-235}:\\
\;\;\;\;\frac{z}{\frac{a}{y - x}}\\
\mathbf{elif}\;t \leq 1.65 \cdot 10^{-14}:\\
\;\;\;\;y \cdot \frac{z}{a - t}\\
\mathbf{elif}\;t \leq 390000000:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -1.2e121Initial program 46.9%
+-commutative46.9%
associate-*r/75.0%
*-commutative75.0%
fma-def75.0%
Simplified75.0%
Taylor expanded in y around inf 71.1%
div-sub71.1%
*-commutative71.1%
Simplified71.1%
Taylor expanded in z around 0 61.9%
neg-mul-161.9%
distribute-neg-frac61.9%
Simplified61.9%
if -1.2e121 < t < -1.2000000000000001e59Initial program 85.4%
+-commutative85.4%
associate-*r/99.6%
*-commutative99.6%
fma-def99.6%
Simplified99.6%
Taylor expanded in z around inf 60.9%
div-sub60.9%
*-commutative60.9%
associate-*l/46.8%
associate-/l*61.2%
Simplified61.2%
Taylor expanded in a around inf 49.5%
if -1.2000000000000001e59 < t < -5.3000000000000001e-5 or -1.0500000000000001e-70 < t < -9.60000000000000043e-91 or 3.9e8 < t Initial program 61.9%
+-commutative61.9%
associate-*r/81.0%
*-commutative81.0%
fma-def81.0%
Simplified81.0%
Taylor expanded in t around inf 72.3%
*-commutative72.3%
cancel-sign-sub-inv72.3%
metadata-eval72.3%
*-lft-identity72.3%
distribute-lft-in72.3%
mul-1-neg72.3%
distribute-rgt-neg-in72.3%
mul-1-neg72.3%
*-commutative72.3%
cancel-sign-sub72.3%
mul-1-neg72.3%
associate-*r*72.3%
distribute-lft-out--72.3%
associate-*r/72.3%
mul-1-neg72.3%
Simplified83.1%
Taylor expanded in z around inf 74.1%
*-commutative74.1%
associate-/l*80.6%
Simplified80.6%
Taylor expanded in y around inf 59.9%
associate-*l/62.1%
Simplified62.1%
if -5.3000000000000001e-5 < t < -1.0500000000000001e-70Initial program 65.3%
+-commutative65.3%
associate-*r/72.9%
*-commutative72.9%
fma-def73.1%
Simplified73.1%
Taylor expanded in z around inf 78.4%
div-sub78.4%
*-commutative78.4%
associate-*l/70.7%
associate-/l*78.8%
Simplified78.8%
Taylor expanded in y around 0 55.0%
mul-1-neg55.0%
associate-/l*55.1%
Simplified55.1%
if -9.60000000000000043e-91 < t < -3.79999999999999985e-274 or 1.6499999999999999e-14 < t < 3.9e8Initial program 91.3%
+-commutative91.3%
associate-*r/95.4%
*-commutative95.4%
fma-def95.4%
Simplified95.4%
Taylor expanded in a around inf 52.5%
if -3.79999999999999985e-274 < t < 2.54999999999999996e-235Initial program 96.4%
+-commutative96.4%
associate-*r/86.2%
*-commutative86.2%
fma-def86.2%
Simplified86.2%
Taylor expanded in z around inf 60.5%
div-sub60.5%
*-commutative60.5%
associate-*l/60.8%
associate-/l*50.8%
Simplified50.8%
Taylor expanded in a around inf 51.9%
associate-/l*55.2%
Simplified55.2%
if 2.54999999999999996e-235 < t < 1.6499999999999999e-14Initial program 89.8%
+-commutative89.8%
associate-*r/96.5%
*-commutative96.5%
fma-def96.5%
Simplified96.5%
Taylor expanded in y around inf 63.6%
div-sub63.6%
*-commutative63.6%
Simplified63.6%
Taylor expanded in z around inf 56.8%
Final simplification58.1%
(FPCore (x y z t a)
:precision binary64
(if (or (<= a -1.5e-13)
(not
(or (<= a 4.1e-143)
(and (not (<= a 2.4e-120))
(or (<= a 4.8e+55)
(and (not (<= a 2.15e+126)) (<= a 8e+154)))))))
(+ x (/ (- z t) (/ a (- y x))))
(+ y (/ (- x y) (/ t z)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -1.5e-13) || !((a <= 4.1e-143) || (!(a <= 2.4e-120) && ((a <= 4.8e+55) || (!(a <= 2.15e+126) && (a <= 8e+154)))))) {
tmp = x + ((z - t) / (a / (y - x)));
} else {
tmp = y + ((x - y) / (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 <= (-1.5d-13)) .or. (.not. (a <= 4.1d-143) .or. (.not. (a <= 2.4d-120)) .and. (a <= 4.8d+55) .or. (.not. (a <= 2.15d+126)) .and. (a <= 8d+154))) then
tmp = x + ((z - t) / (a / (y - x)))
else
tmp = y + ((x - y) / (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 <= -1.5e-13) || !((a <= 4.1e-143) || (!(a <= 2.4e-120) && ((a <= 4.8e+55) || (!(a <= 2.15e+126) && (a <= 8e+154)))))) {
tmp = x + ((z - t) / (a / (y - x)));
} else {
tmp = y + ((x - y) / (t / z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (a <= -1.5e-13) or not ((a <= 4.1e-143) or (not (a <= 2.4e-120) and ((a <= 4.8e+55) or (not (a <= 2.15e+126) and (a <= 8e+154))))): tmp = x + ((z - t) / (a / (y - x))) else: tmp = y + ((x - y) / (t / z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((a <= -1.5e-13) || !((a <= 4.1e-143) || (!(a <= 2.4e-120) && ((a <= 4.8e+55) || (!(a <= 2.15e+126) && (a <= 8e+154)))))) tmp = Float64(x + Float64(Float64(z - t) / Float64(a / Float64(y - x)))); else tmp = Float64(y + Float64(Float64(x - y) / Float64(t / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((a <= -1.5e-13) || ~(((a <= 4.1e-143) || (~((a <= 2.4e-120)) && ((a <= 4.8e+55) || (~((a <= 2.15e+126)) && (a <= 8e+154))))))) tmp = x + ((z - t) / (a / (y - x))); else tmp = y + ((x - y) / (t / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[a, -1.5e-13], N[Not[Or[LessEqual[a, 4.1e-143], And[N[Not[LessEqual[a, 2.4e-120]], $MachinePrecision], Or[LessEqual[a, 4.8e+55], And[N[Not[LessEqual[a, 2.15e+126]], $MachinePrecision], LessEqual[a, 8e+154]]]]]], $MachinePrecision]], N[(x + N[(N[(z - t), $MachinePrecision] / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y + N[(N[(x - y), $MachinePrecision] / N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.5 \cdot 10^{-13} \lor \neg \left(a \leq 4.1 \cdot 10^{-143} \lor \neg \left(a \leq 2.4 \cdot 10^{-120}\right) \land \left(a \leq 4.8 \cdot 10^{+55} \lor \neg \left(a \leq 2.15 \cdot 10^{+126}\right) \land a \leq 8 \cdot 10^{+154}\right)\right):\\
\;\;\;\;x + \frac{z - t}{\frac{a}{y - x}}\\
\mathbf{else}:\\
\;\;\;\;y + \frac{x - y}{\frac{t}{z}}\\
\end{array}
\end{array}
if a < -1.49999999999999992e-13 or 4.1e-143 < a < 2.3999999999999999e-120 or 4.7999999999999998e55 < a < 2.1500000000000001e126 or 8.0000000000000003e154 < a Initial program 75.1%
+-commutative75.1%
associate-*r/92.1%
*-commutative92.1%
fma-def92.1%
Simplified92.1%
Taylor expanded in a around inf 66.0%
+-commutative66.0%
associate-/l*79.7%
Simplified79.7%
if -1.49999999999999992e-13 < a < 4.1e-143 or 2.3999999999999999e-120 < a < 4.7999999999999998e55 or 2.1500000000000001e126 < a < 8.0000000000000003e154Initial program 71.1%
+-commutative71.1%
associate-*r/79.6%
*-commutative79.6%
fma-def79.6%
Simplified79.6%
Taylor expanded in t around inf 76.0%
*-commutative76.0%
cancel-sign-sub-inv76.0%
metadata-eval76.0%
*-lft-identity76.0%
distribute-lft-in75.3%
mul-1-neg75.3%
distribute-rgt-neg-in75.3%
mul-1-neg75.3%
*-commutative75.3%
cancel-sign-sub75.3%
mul-1-neg75.3%
associate-*r*75.3%
distribute-lft-out--75.3%
associate-*r/75.3%
mul-1-neg75.3%
Simplified81.5%
Taylor expanded in z around inf 74.9%
*-commutative74.9%
associate-/l*79.8%
Simplified79.8%
Final simplification79.7%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ z (/ t x)))
(t_2 (* z (/ y (- a t))))
(t_3 (+ y (/ y (/ t a)))))
(if (<= t -3.5e-6)
t_3
(if (<= t -1.8e-60)
t_1
(if (<= t -3.6e-96)
t_2
(if (<= t 4.2e-248)
x
(if (<= t 1.75e+56)
t_2
(if (or (<= t 4.4e+131) (not (<= t 1.15e+194))) t_3 t_1))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = z / (t / x);
double t_2 = z * (y / (a - t));
double t_3 = y + (y / (t / a));
double tmp;
if (t <= -3.5e-6) {
tmp = t_3;
} else if (t <= -1.8e-60) {
tmp = t_1;
} else if (t <= -3.6e-96) {
tmp = t_2;
} else if (t <= 4.2e-248) {
tmp = x;
} else if (t <= 1.75e+56) {
tmp = t_2;
} else if ((t <= 4.4e+131) || !(t <= 1.15e+194)) {
tmp = t_3;
} 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) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = z / (t / x)
t_2 = z * (y / (a - t))
t_3 = y + (y / (t / a))
if (t <= (-3.5d-6)) then
tmp = t_3
else if (t <= (-1.8d-60)) then
tmp = t_1
else if (t <= (-3.6d-96)) then
tmp = t_2
else if (t <= 4.2d-248) then
tmp = x
else if (t <= 1.75d+56) then
tmp = t_2
else if ((t <= 4.4d+131) .or. (.not. (t <= 1.15d+194))) then
tmp = t_3
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 = z / (t / x);
double t_2 = z * (y / (a - t));
double t_3 = y + (y / (t / a));
double tmp;
if (t <= -3.5e-6) {
tmp = t_3;
} else if (t <= -1.8e-60) {
tmp = t_1;
} else if (t <= -3.6e-96) {
tmp = t_2;
} else if (t <= 4.2e-248) {
tmp = x;
} else if (t <= 1.75e+56) {
tmp = t_2;
} else if ((t <= 4.4e+131) || !(t <= 1.15e+194)) {
tmp = t_3;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = z / (t / x) t_2 = z * (y / (a - t)) t_3 = y + (y / (t / a)) tmp = 0 if t <= -3.5e-6: tmp = t_3 elif t <= -1.8e-60: tmp = t_1 elif t <= -3.6e-96: tmp = t_2 elif t <= 4.2e-248: tmp = x elif t <= 1.75e+56: tmp = t_2 elif (t <= 4.4e+131) or not (t <= 1.15e+194): tmp = t_3 else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(z / Float64(t / x)) t_2 = Float64(z * Float64(y / Float64(a - t))) t_3 = Float64(y + Float64(y / Float64(t / a))) tmp = 0.0 if (t <= -3.5e-6) tmp = t_3; elseif (t <= -1.8e-60) tmp = t_1; elseif (t <= -3.6e-96) tmp = t_2; elseif (t <= 4.2e-248) tmp = x; elseif (t <= 1.75e+56) tmp = t_2; elseif ((t <= 4.4e+131) || !(t <= 1.15e+194)) tmp = t_3; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = z / (t / x); t_2 = z * (y / (a - t)); t_3 = y + (y / (t / a)); tmp = 0.0; if (t <= -3.5e-6) tmp = t_3; elseif (t <= -1.8e-60) tmp = t_1; elseif (t <= -3.6e-96) tmp = t_2; elseif (t <= 4.2e-248) tmp = x; elseif (t <= 1.75e+56) tmp = t_2; elseif ((t <= 4.4e+131) || ~((t <= 1.15e+194))) tmp = t_3; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(z / N[(t / x), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(z * N[(y / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(y + N[(y / N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -3.5e-6], t$95$3, If[LessEqual[t, -1.8e-60], t$95$1, If[LessEqual[t, -3.6e-96], t$95$2, If[LessEqual[t, 4.2e-248], x, If[LessEqual[t, 1.75e+56], t$95$2, If[Or[LessEqual[t, 4.4e+131], N[Not[LessEqual[t, 1.15e+194]], $MachinePrecision]], t$95$3, t$95$1]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z}{\frac{t}{x}}\\
t_2 := z \cdot \frac{y}{a - t}\\
t_3 := y + \frac{y}{\frac{t}{a}}\\
\mathbf{if}\;t \leq -3.5 \cdot 10^{-6}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;t \leq -1.8 \cdot 10^{-60}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -3.6 \cdot 10^{-96}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 4.2 \cdot 10^{-248}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 1.75 \cdot 10^{+56}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 4.4 \cdot 10^{+131} \lor \neg \left(t \leq 1.15 \cdot 10^{+194}\right):\\
\;\;\;\;t_3\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -3.49999999999999995e-6 or 1.75e56 < t < 4.3999999999999998e131 or 1.15000000000000003e194 < t Initial program 55.4%
+-commutative55.4%
associate-*r/79.7%
*-commutative79.7%
fma-def79.7%
Simplified79.7%
Taylor expanded in y around inf 72.4%
div-sub72.5%
*-commutative72.5%
Simplified72.5%
Taylor expanded in z around 0 59.1%
neg-mul-159.1%
distribute-neg-frac59.1%
Simplified59.1%
Taylor expanded in t around inf 54.6%
+-commutative54.6%
*-commutative54.6%
associate-/l*56.4%
Simplified56.4%
if -3.49999999999999995e-6 < t < -1.8e-60 or 4.3999999999999998e131 < t < 1.15000000000000003e194Initial program 62.2%
+-commutative62.2%
associate-*r/80.1%
*-commutative80.1%
fma-def80.2%
Simplified80.2%
Taylor expanded in t around inf 65.6%
*-commutative65.6%
cancel-sign-sub-inv65.6%
metadata-eval65.6%
*-lft-identity65.6%
distribute-lft-in65.5%
mul-1-neg65.5%
distribute-rgt-neg-in65.5%
mul-1-neg65.5%
*-commutative65.5%
cancel-sign-sub65.5%
mul-1-neg65.5%
associate-*r*65.5%
distribute-lft-out--65.5%
associate-*r/65.5%
mul-1-neg65.5%
Simplified69.1%
Taylor expanded in z around inf 64.9%
*-commutative64.9%
associate-/l*68.5%
Simplified68.5%
Taylor expanded in y around 0 46.4%
associate-/l*50.0%
Simplified50.0%
if -1.8e-60 < t < -3.60000000000000008e-96 or 4.2e-248 < t < 1.75e56Initial program 89.6%
+-commutative89.6%
associate-*r/88.6%
*-commutative88.6%
fma-def88.6%
Simplified88.6%
Taylor expanded in y around inf 53.8%
div-sub53.8%
*-commutative53.8%
Simplified53.8%
Taylor expanded in z around inf 37.7%
associate-/l*39.1%
associate-/r/40.9%
Simplified40.9%
if -3.60000000000000008e-96 < t < 4.2e-248Initial program 92.3%
+-commutative92.3%
associate-*r/95.2%
*-commutative95.2%
fma-def95.2%
Simplified95.2%
Taylor expanded in a around inf 48.8%
Final simplification50.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- y (* z (/ y t)))))
(if (<= t -5.5e-7)
t_1
(if (<= t -1.5e-81)
(/ z (/ t (- x y)))
(if (<= t -1.7e-97)
(* y (/ z a))
(if (<= t -3.8e-274)
x
(if (<= t 2.4e-234)
(/ z (/ a (- y x)))
(if (<= t 6.4e-15)
(* y (/ z (- a t)))
(if (<= t 3.2e+15) x t_1)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y - (z * (y / t));
double tmp;
if (t <= -5.5e-7) {
tmp = t_1;
} else if (t <= -1.5e-81) {
tmp = z / (t / (x - y));
} else if (t <= -1.7e-97) {
tmp = y * (z / a);
} else if (t <= -3.8e-274) {
tmp = x;
} else if (t <= 2.4e-234) {
tmp = z / (a / (y - x));
} else if (t <= 6.4e-15) {
tmp = y * (z / (a - t));
} else if (t <= 3.2e+15) {
tmp = 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 = y - (z * (y / t))
if (t <= (-5.5d-7)) then
tmp = t_1
else if (t <= (-1.5d-81)) then
tmp = z / (t / (x - y))
else if (t <= (-1.7d-97)) then
tmp = y * (z / a)
else if (t <= (-3.8d-274)) then
tmp = x
else if (t <= 2.4d-234) then
tmp = z / (a / (y - x))
else if (t <= 6.4d-15) then
tmp = y * (z / (a - t))
else if (t <= 3.2d+15) then
tmp = 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 = y - (z * (y / t));
double tmp;
if (t <= -5.5e-7) {
tmp = t_1;
} else if (t <= -1.5e-81) {
tmp = z / (t / (x - y));
} else if (t <= -1.7e-97) {
tmp = y * (z / a);
} else if (t <= -3.8e-274) {
tmp = x;
} else if (t <= 2.4e-234) {
tmp = z / (a / (y - x));
} else if (t <= 6.4e-15) {
tmp = y * (z / (a - t));
} else if (t <= 3.2e+15) {
tmp = x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y - (z * (y / t)) tmp = 0 if t <= -5.5e-7: tmp = t_1 elif t <= -1.5e-81: tmp = z / (t / (x - y)) elif t <= -1.7e-97: tmp = y * (z / a) elif t <= -3.8e-274: tmp = x elif t <= 2.4e-234: tmp = z / (a / (y - x)) elif t <= 6.4e-15: tmp = y * (z / (a - t)) elif t <= 3.2e+15: tmp = x else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(y - Float64(z * Float64(y / t))) tmp = 0.0 if (t <= -5.5e-7) tmp = t_1; elseif (t <= -1.5e-81) tmp = Float64(z / Float64(t / Float64(x - y))); elseif (t <= -1.7e-97) tmp = Float64(y * Float64(z / a)); elseif (t <= -3.8e-274) tmp = x; elseif (t <= 2.4e-234) tmp = Float64(z / Float64(a / Float64(y - x))); elseif (t <= 6.4e-15) tmp = Float64(y * Float64(z / Float64(a - t))); elseif (t <= 3.2e+15) tmp = x; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y - (z * (y / t)); tmp = 0.0; if (t <= -5.5e-7) tmp = t_1; elseif (t <= -1.5e-81) tmp = z / (t / (x - y)); elseif (t <= -1.7e-97) tmp = y * (z / a); elseif (t <= -3.8e-274) tmp = x; elseif (t <= 2.4e-234) tmp = z / (a / (y - x)); elseif (t <= 6.4e-15) tmp = y * (z / (a - t)); elseif (t <= 3.2e+15) tmp = x; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y - N[(z * N[(y / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -5.5e-7], t$95$1, If[LessEqual[t, -1.5e-81], N[(z / N[(t / N[(x - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.7e-97], N[(y * N[(z / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -3.8e-274], x, If[LessEqual[t, 2.4e-234], N[(z / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 6.4e-15], N[(y * N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.2e+15], x, t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y - z \cdot \frac{y}{t}\\
\mathbf{if}\;t \leq -5.5 \cdot 10^{-7}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -1.5 \cdot 10^{-81}:\\
\;\;\;\;\frac{z}{\frac{t}{x - y}}\\
\mathbf{elif}\;t \leq -1.7 \cdot 10^{-97}:\\
\;\;\;\;y \cdot \frac{z}{a}\\
\mathbf{elif}\;t \leq -3.8 \cdot 10^{-274}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 2.4 \cdot 10^{-234}:\\
\;\;\;\;\frac{z}{\frac{a}{y - x}}\\
\mathbf{elif}\;t \leq 6.4 \cdot 10^{-15}:\\
\;\;\;\;y \cdot \frac{z}{a - t}\\
\mathbf{elif}\;t \leq 3.2 \cdot 10^{+15}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -5.5000000000000003e-7 or 3.2e15 < t Initial program 58.6%
+-commutative58.6%
associate-*r/80.9%
*-commutative80.9%
fma-def80.9%
Simplified80.9%
Taylor expanded in t around inf 67.1%
*-commutative67.1%
cancel-sign-sub-inv67.1%
metadata-eval67.1%
*-lft-identity67.1%
distribute-lft-in67.0%
mul-1-neg67.0%
distribute-rgt-neg-in67.0%
mul-1-neg67.0%
*-commutative67.0%
cancel-sign-sub67.0%
mul-1-neg67.0%
associate-*r*67.0%
distribute-lft-out--67.0%
associate-*r/67.0%
mul-1-neg67.0%
Simplified75.5%
Taylor expanded in z around inf 66.7%
*-commutative66.7%
associate-/l*72.4%
Simplified72.4%
Taylor expanded in y around inf 55.4%
associate-*l/57.5%
Simplified57.5%
if -5.5000000000000003e-7 < t < -1.4999999999999999e-81Initial program 67.9%
+-commutative67.9%
associate-*r/73.5%
*-commutative73.5%
fma-def73.7%
Simplified73.7%
Taylor expanded in t around inf 56.0%
*-commutative56.0%
cancel-sign-sub-inv56.0%
metadata-eval56.0%
*-lft-identity56.0%
distribute-lft-in56.0%
mul-1-neg56.0%
distribute-rgt-neg-in56.0%
mul-1-neg56.0%
*-commutative56.0%
cancel-sign-sub56.0%
mul-1-neg56.0%
associate-*r*56.0%
distribute-lft-out--56.0%
associate-*r/56.0%
mul-1-neg56.0%
Simplified56.1%
Taylor expanded in z around inf 48.2%
*-commutative48.2%
associate-/l*48.2%
Simplified48.2%
Taylor expanded in x around 0 42.0%
associate--l+42.0%
associate-*l/42.0%
cancel-sign-sub-inv42.0%
*-commutative42.0%
associate-*l/41.8%
distribute-rgt-in48.0%
sub-neg48.0%
*-commutative48.0%
+-commutative48.0%
*-commutative48.0%
fma-def48.1%
Simplified48.1%
Taylor expanded in z around inf 48.5%
div-sub48.5%
*-commutative48.5%
associate-*r/48.7%
associate-/l*48.7%
Simplified48.7%
if -1.4999999999999999e-81 < t < -1.6999999999999999e-97Initial program 100.0%
+-commutative100.0%
associate-*r/100.0%
*-commutative100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in y around inf 75.0%
div-sub75.0%
*-commutative75.0%
Simplified75.0%
Taylor expanded in t around 0 53.7%
if -1.6999999999999999e-97 < t < -3.79999999999999985e-274 or 6.3999999999999999e-15 < t < 3.2e15Initial program 90.9%
+-commutative90.9%
associate-*r/95.2%
*-commutative95.2%
fma-def95.2%
Simplified95.2%
Taylor expanded in a around inf 54.9%
if -3.79999999999999985e-274 < t < 2.3999999999999999e-234Initial program 96.4%
+-commutative96.4%
associate-*r/86.2%
*-commutative86.2%
fma-def86.2%
Simplified86.2%
Taylor expanded in z around inf 60.5%
div-sub60.5%
*-commutative60.5%
associate-*l/60.8%
associate-/l*50.8%
Simplified50.8%
Taylor expanded in a around inf 51.9%
associate-/l*55.2%
Simplified55.2%
if 2.3999999999999999e-234 < t < 6.3999999999999999e-15Initial program 89.8%
+-commutative89.8%
associate-*r/96.5%
*-commutative96.5%
fma-def96.5%
Simplified96.5%
Taylor expanded in y around inf 63.6%
div-sub63.6%
*-commutative63.6%
Simplified63.6%
Taylor expanded in z around inf 56.8%
Final simplification56.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- y (* z (/ y t)))))
(if (<= t -4.4e-7)
t_1
(if (<= t -1e-71)
(/ (- z) (/ (- a t) x))
(if (<= t -6.2e-89)
t_1
(if (<= t -3.8e-274)
x
(if (<= t 1.9e-234)
(/ z (/ a (- y x)))
(if (<= t 8.5e-15)
(* y (/ z (- a t)))
(if (<= t 38000000000.0) x t_1)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y - (z * (y / t));
double tmp;
if (t <= -4.4e-7) {
tmp = t_1;
} else if (t <= -1e-71) {
tmp = -z / ((a - t) / x);
} else if (t <= -6.2e-89) {
tmp = t_1;
} else if (t <= -3.8e-274) {
tmp = x;
} else if (t <= 1.9e-234) {
tmp = z / (a / (y - x));
} else if (t <= 8.5e-15) {
tmp = y * (z / (a - t));
} else if (t <= 38000000000.0) {
tmp = 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 = y - (z * (y / t))
if (t <= (-4.4d-7)) then
tmp = t_1
else if (t <= (-1d-71)) then
tmp = -z / ((a - t) / x)
else if (t <= (-6.2d-89)) then
tmp = t_1
else if (t <= (-3.8d-274)) then
tmp = x
else if (t <= 1.9d-234) then
tmp = z / (a / (y - x))
else if (t <= 8.5d-15) then
tmp = y * (z / (a - t))
else if (t <= 38000000000.0d0) then
tmp = 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 = y - (z * (y / t));
double tmp;
if (t <= -4.4e-7) {
tmp = t_1;
} else if (t <= -1e-71) {
tmp = -z / ((a - t) / x);
} else if (t <= -6.2e-89) {
tmp = t_1;
} else if (t <= -3.8e-274) {
tmp = x;
} else if (t <= 1.9e-234) {
tmp = z / (a / (y - x));
} else if (t <= 8.5e-15) {
tmp = y * (z / (a - t));
} else if (t <= 38000000000.0) {
tmp = x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y - (z * (y / t)) tmp = 0 if t <= -4.4e-7: tmp = t_1 elif t <= -1e-71: tmp = -z / ((a - t) / x) elif t <= -6.2e-89: tmp = t_1 elif t <= -3.8e-274: tmp = x elif t <= 1.9e-234: tmp = z / (a / (y - x)) elif t <= 8.5e-15: tmp = y * (z / (a - t)) elif t <= 38000000000.0: tmp = x else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(y - Float64(z * Float64(y / t))) tmp = 0.0 if (t <= -4.4e-7) tmp = t_1; elseif (t <= -1e-71) tmp = Float64(Float64(-z) / Float64(Float64(a - t) / x)); elseif (t <= -6.2e-89) tmp = t_1; elseif (t <= -3.8e-274) tmp = x; elseif (t <= 1.9e-234) tmp = Float64(z / Float64(a / Float64(y - x))); elseif (t <= 8.5e-15) tmp = Float64(y * Float64(z / Float64(a - t))); elseif (t <= 38000000000.0) tmp = x; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y - (z * (y / t)); tmp = 0.0; if (t <= -4.4e-7) tmp = t_1; elseif (t <= -1e-71) tmp = -z / ((a - t) / x); elseif (t <= -6.2e-89) tmp = t_1; elseif (t <= -3.8e-274) tmp = x; elseif (t <= 1.9e-234) tmp = z / (a / (y - x)); elseif (t <= 8.5e-15) tmp = y * (z / (a - t)); elseif (t <= 38000000000.0) tmp = x; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y - N[(z * N[(y / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -4.4e-7], t$95$1, If[LessEqual[t, -1e-71], N[((-z) / N[(N[(a - t), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -6.2e-89], t$95$1, If[LessEqual[t, -3.8e-274], x, If[LessEqual[t, 1.9e-234], N[(z / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8.5e-15], N[(y * N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 38000000000.0], x, t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y - z \cdot \frac{y}{t}\\
\mathbf{if}\;t \leq -4.4 \cdot 10^{-7}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -1 \cdot 10^{-71}:\\
\;\;\;\;\frac{-z}{\frac{a - t}{x}}\\
\mathbf{elif}\;t \leq -6.2 \cdot 10^{-89}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -3.8 \cdot 10^{-274}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 1.9 \cdot 10^{-234}:\\
\;\;\;\;\frac{z}{\frac{a}{y - x}}\\
\mathbf{elif}\;t \leq 8.5 \cdot 10^{-15}:\\
\;\;\;\;y \cdot \frac{z}{a - t}\\
\mathbf{elif}\;t \leq 38000000000:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -4.4000000000000002e-7 or -9.9999999999999992e-72 < t < -6.19999999999999993e-89 or 3.8e10 < t Initial program 59.7%
+-commutative59.7%
associate-*r/81.0%
*-commutative81.0%
fma-def81.0%
Simplified81.0%
Taylor expanded in t around inf 67.8%
*-commutative67.8%
cancel-sign-sub-inv67.8%
metadata-eval67.8%
*-lft-identity67.8%
distribute-lft-in67.7%
mul-1-neg67.7%
distribute-rgt-neg-in67.7%
mul-1-neg67.7%
*-commutative67.7%
cancel-sign-sub67.7%
mul-1-neg67.7%
associate-*r*67.7%
distribute-lft-out--67.7%
associate-*r/67.7%
mul-1-neg67.7%
Simplified75.8%
Taylor expanded in z around inf 66.8%
*-commutative66.8%
associate-/l*72.2%
Simplified72.2%
Taylor expanded in y around inf 55.9%
associate-*l/58.0%
Simplified58.0%
if -4.4000000000000002e-7 < t < -9.9999999999999992e-72Initial program 65.3%
+-commutative65.3%
associate-*r/72.9%
*-commutative72.9%
fma-def73.1%
Simplified73.1%
Taylor expanded in z around inf 78.4%
div-sub78.4%
*-commutative78.4%
associate-*l/70.7%
associate-/l*78.8%
Simplified78.8%
Taylor expanded in y around 0 55.0%
mul-1-neg55.0%
associate-/l*55.1%
Simplified55.1%
if -6.19999999999999993e-89 < t < -3.79999999999999985e-274 or 8.50000000000000007e-15 < t < 3.8e10Initial program 91.3%
+-commutative91.3%
associate-*r/95.4%
*-commutative95.4%
fma-def95.4%
Simplified95.4%
Taylor expanded in a around inf 52.5%
if -3.79999999999999985e-274 < t < 1.89999999999999992e-234Initial program 96.4%
+-commutative96.4%
associate-*r/86.2%
*-commutative86.2%
fma-def86.2%
Simplified86.2%
Taylor expanded in z around inf 60.5%
div-sub60.5%
*-commutative60.5%
associate-*l/60.8%
associate-/l*50.8%
Simplified50.8%
Taylor expanded in a around inf 51.9%
associate-/l*55.2%
Simplified55.2%
if 1.89999999999999992e-234 < t < 8.50000000000000007e-15Initial program 89.8%
+-commutative89.8%
associate-*r/96.5%
*-commutative96.5%
fma-def96.5%
Simplified96.5%
Taylor expanded in y around inf 63.6%
div-sub63.6%
*-commutative63.6%
Simplified63.6%
Taylor expanded in z around inf 56.8%
Final simplification56.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ y (* z (/ x t)))))
(if (<= t -2.8e-5)
(- y (* z (/ y t)))
(if (<= t -5.2e-81)
(/ z (/ t (- x y)))
(if (<= t -1.8e-98)
t_1
(if (<= t -3.8e-274)
x
(if (<= t 2.4e-234)
(/ z (/ a (- y x)))
(if (<= t 5.1e-15)
(* y (/ z (- a t)))
(if (<= t 14000000000.0) x t_1)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y + (z * (x / t));
double tmp;
if (t <= -2.8e-5) {
tmp = y - (z * (y / t));
} else if (t <= -5.2e-81) {
tmp = z / (t / (x - y));
} else if (t <= -1.8e-98) {
tmp = t_1;
} else if (t <= -3.8e-274) {
tmp = x;
} else if (t <= 2.4e-234) {
tmp = z / (a / (y - x));
} else if (t <= 5.1e-15) {
tmp = y * (z / (a - t));
} else if (t <= 14000000000.0) {
tmp = 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 = y + (z * (x / t))
if (t <= (-2.8d-5)) then
tmp = y - (z * (y / t))
else if (t <= (-5.2d-81)) then
tmp = z / (t / (x - y))
else if (t <= (-1.8d-98)) then
tmp = t_1
else if (t <= (-3.8d-274)) then
tmp = x
else if (t <= 2.4d-234) then
tmp = z / (a / (y - x))
else if (t <= 5.1d-15) then
tmp = y * (z / (a - t))
else if (t <= 14000000000.0d0) then
tmp = 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 = y + (z * (x / t));
double tmp;
if (t <= -2.8e-5) {
tmp = y - (z * (y / t));
} else if (t <= -5.2e-81) {
tmp = z / (t / (x - y));
} else if (t <= -1.8e-98) {
tmp = t_1;
} else if (t <= -3.8e-274) {
tmp = x;
} else if (t <= 2.4e-234) {
tmp = z / (a / (y - x));
} else if (t <= 5.1e-15) {
tmp = y * (z / (a - t));
} else if (t <= 14000000000.0) {
tmp = x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y + (z * (x / t)) tmp = 0 if t <= -2.8e-5: tmp = y - (z * (y / t)) elif t <= -5.2e-81: tmp = z / (t / (x - y)) elif t <= -1.8e-98: tmp = t_1 elif t <= -3.8e-274: tmp = x elif t <= 2.4e-234: tmp = z / (a / (y - x)) elif t <= 5.1e-15: tmp = y * (z / (a - t)) elif t <= 14000000000.0: tmp = x else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(y + Float64(z * Float64(x / t))) tmp = 0.0 if (t <= -2.8e-5) tmp = Float64(y - Float64(z * Float64(y / t))); elseif (t <= -5.2e-81) tmp = Float64(z / Float64(t / Float64(x - y))); elseif (t <= -1.8e-98) tmp = t_1; elseif (t <= -3.8e-274) tmp = x; elseif (t <= 2.4e-234) tmp = Float64(z / Float64(a / Float64(y - x))); elseif (t <= 5.1e-15) tmp = Float64(y * Float64(z / Float64(a - t))); elseif (t <= 14000000000.0) tmp = x; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y + (z * (x / t)); tmp = 0.0; if (t <= -2.8e-5) tmp = y - (z * (y / t)); elseif (t <= -5.2e-81) tmp = z / (t / (x - y)); elseif (t <= -1.8e-98) tmp = t_1; elseif (t <= -3.8e-274) tmp = x; elseif (t <= 2.4e-234) tmp = z / (a / (y - x)); elseif (t <= 5.1e-15) tmp = y * (z / (a - t)); elseif (t <= 14000000000.0) tmp = x; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y + N[(z * N[(x / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.8e-5], N[(y - N[(z * N[(y / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -5.2e-81], N[(z / N[(t / N[(x - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.8e-98], t$95$1, If[LessEqual[t, -3.8e-274], x, If[LessEqual[t, 2.4e-234], N[(z / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.1e-15], N[(y * N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 14000000000.0], x, t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + z \cdot \frac{x}{t}\\
\mathbf{if}\;t \leq -2.8 \cdot 10^{-5}:\\
\;\;\;\;y - z \cdot \frac{y}{t}\\
\mathbf{elif}\;t \leq -5.2 \cdot 10^{-81}:\\
\;\;\;\;\frac{z}{\frac{t}{x - y}}\\
\mathbf{elif}\;t \leq -1.8 \cdot 10^{-98}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -3.8 \cdot 10^{-274}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 2.4 \cdot 10^{-234}:\\
\;\;\;\;\frac{z}{\frac{a}{y - x}}\\
\mathbf{elif}\;t \leq 5.1 \cdot 10^{-15}:\\
\;\;\;\;y \cdot \frac{z}{a - t}\\
\mathbf{elif}\;t \leq 14000000000:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -2.79999999999999996e-5Initial program 60.6%
+-commutative60.6%
associate-*r/80.5%
*-commutative80.5%
fma-def80.5%
Simplified80.5%
Taylor expanded in t around inf 66.8%
*-commutative66.8%
cancel-sign-sub-inv66.8%
metadata-eval66.8%
*-lft-identity66.8%
distribute-lft-in66.7%
mul-1-neg66.7%
distribute-rgt-neg-in66.7%
mul-1-neg66.7%
*-commutative66.7%
cancel-sign-sub66.7%
mul-1-neg66.7%
associate-*r*66.7%
distribute-lft-out--66.7%
associate-*r/66.7%
mul-1-neg66.7%
Simplified69.7%
Taylor expanded in z around inf 62.4%
*-commutative62.4%
associate-/l*65.3%
Simplified65.3%
Taylor expanded in y around inf 57.8%
associate-*l/59.3%
Simplified59.3%
if -2.79999999999999996e-5 < t < -5.1999999999999998e-81Initial program 67.9%
+-commutative67.9%
associate-*r/73.5%
*-commutative73.5%
fma-def73.7%
Simplified73.7%
Taylor expanded in t around inf 56.0%
*-commutative56.0%
cancel-sign-sub-inv56.0%
metadata-eval56.0%
*-lft-identity56.0%
distribute-lft-in56.0%
mul-1-neg56.0%
distribute-rgt-neg-in56.0%
mul-1-neg56.0%
*-commutative56.0%
cancel-sign-sub56.0%
mul-1-neg56.0%
associate-*r*56.0%
distribute-lft-out--56.0%
associate-*r/56.0%
mul-1-neg56.0%
Simplified56.1%
Taylor expanded in z around inf 48.2%
*-commutative48.2%
associate-/l*48.2%
Simplified48.2%
Taylor expanded in x around 0 42.0%
associate--l+42.0%
associate-*l/42.0%
cancel-sign-sub-inv42.0%
*-commutative42.0%
associate-*l/41.8%
distribute-rgt-in48.0%
sub-neg48.0%
*-commutative48.0%
+-commutative48.0%
*-commutative48.0%
fma-def48.1%
Simplified48.1%
Taylor expanded in z around inf 48.5%
div-sub48.5%
*-commutative48.5%
associate-*r/48.7%
associate-/l*48.7%
Simplified48.7%
if -5.1999999999999998e-81 < t < -1.8000000000000001e-98 or 1.4e10 < t Initial program 59.1%
+-commutative59.1%
associate-*r/82.3%
*-commutative82.3%
fma-def82.3%
Simplified82.3%
Taylor expanded in t around inf 67.8%
*-commutative67.8%
cancel-sign-sub-inv67.8%
metadata-eval67.8%
*-lft-identity67.8%
distribute-lft-in67.8%
mul-1-neg67.8%
distribute-rgt-neg-in67.8%
mul-1-neg67.8%
*-commutative67.8%
cancel-sign-sub67.8%
mul-1-neg67.8%
associate-*r*67.8%
distribute-lft-out--67.8%
associate-*r/67.8%
mul-1-neg67.8%
Simplified80.8%
Taylor expanded in z around inf 71.3%
*-commutative71.3%
associate-/l*79.1%
Simplified79.1%
Taylor expanded in y around 0 67.1%
mul-1-neg67.1%
*-commutative67.1%
associate-*l/72.3%
distribute-rgt-neg-in72.3%
Simplified72.3%
if -1.8000000000000001e-98 < t < -3.79999999999999985e-274 or 5.1e-15 < t < 1.4e10Initial program 90.9%
+-commutative90.9%
associate-*r/95.2%
*-commutative95.2%
fma-def95.2%
Simplified95.2%
Taylor expanded in a around inf 54.9%
if -3.79999999999999985e-274 < t < 2.3999999999999999e-234Initial program 96.4%
+-commutative96.4%
associate-*r/86.2%
*-commutative86.2%
fma-def86.2%
Simplified86.2%
Taylor expanded in z around inf 60.5%
div-sub60.5%
*-commutative60.5%
associate-*l/60.8%
associate-/l*50.8%
Simplified50.8%
Taylor expanded in a around inf 51.9%
associate-/l*55.2%
Simplified55.2%
if 2.3999999999999999e-234 < t < 5.1e-15Initial program 89.8%
+-commutative89.8%
associate-*r/96.5%
*-commutative96.5%
fma-def96.5%
Simplified96.5%
Taylor expanded in y around inf 63.6%
div-sub63.6%
*-commutative63.6%
Simplified63.6%
Taylor expanded in z around inf 56.8%
Final simplification60.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ y (/ (- x y) (/ t z)))) (t_2 (+ x (/ (- z t) (/ a (- y x))))))
(if (<= a -1.05e-12)
t_2
(if (<= a 4.1e-143)
t_1
(if (<= a 2.4e-120)
t_2
(if (<= a 4.8e+17)
t_1
(if (<= a 3.4e+153) (- x (/ t (/ (- a t) (- y x)))) t_2)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y + ((x - y) / (t / z));
double t_2 = x + ((z - t) / (a / (y - x)));
double tmp;
if (a <= -1.05e-12) {
tmp = t_2;
} else if (a <= 4.1e-143) {
tmp = t_1;
} else if (a <= 2.4e-120) {
tmp = t_2;
} else if (a <= 4.8e+17) {
tmp = t_1;
} else if (a <= 3.4e+153) {
tmp = x - (t / ((a - t) / (y - x)));
} else {
tmp = t_2;
}
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) :: t_2
real(8) :: tmp
t_1 = y + ((x - y) / (t / z))
t_2 = x + ((z - t) / (a / (y - x)))
if (a <= (-1.05d-12)) then
tmp = t_2
else if (a <= 4.1d-143) then
tmp = t_1
else if (a <= 2.4d-120) then
tmp = t_2
else if (a <= 4.8d+17) then
tmp = t_1
else if (a <= 3.4d+153) then
tmp = x - (t / ((a - t) / (y - x)))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y + ((x - y) / (t / z));
double t_2 = x + ((z - t) / (a / (y - x)));
double tmp;
if (a <= -1.05e-12) {
tmp = t_2;
} else if (a <= 4.1e-143) {
tmp = t_1;
} else if (a <= 2.4e-120) {
tmp = t_2;
} else if (a <= 4.8e+17) {
tmp = t_1;
} else if (a <= 3.4e+153) {
tmp = x - (t / ((a - t) / (y - x)));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y + ((x - y) / (t / z)) t_2 = x + ((z - t) / (a / (y - x))) tmp = 0 if a <= -1.05e-12: tmp = t_2 elif a <= 4.1e-143: tmp = t_1 elif a <= 2.4e-120: tmp = t_2 elif a <= 4.8e+17: tmp = t_1 elif a <= 3.4e+153: tmp = x - (t / ((a - t) / (y - x))) else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(y + Float64(Float64(x - y) / Float64(t / z))) t_2 = Float64(x + Float64(Float64(z - t) / Float64(a / Float64(y - x)))) tmp = 0.0 if (a <= -1.05e-12) tmp = t_2; elseif (a <= 4.1e-143) tmp = t_1; elseif (a <= 2.4e-120) tmp = t_2; elseif (a <= 4.8e+17) tmp = t_1; elseif (a <= 3.4e+153) tmp = Float64(x - Float64(t / Float64(Float64(a - t) / Float64(y - x)))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y + ((x - y) / (t / z)); t_2 = x + ((z - t) / (a / (y - x))); tmp = 0.0; if (a <= -1.05e-12) tmp = t_2; elseif (a <= 4.1e-143) tmp = t_1; elseif (a <= 2.4e-120) tmp = t_2; elseif (a <= 4.8e+17) tmp = t_1; elseif (a <= 3.4e+153) tmp = x - (t / ((a - t) / (y - x))); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y + N[(N[(x - y), $MachinePrecision] / N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(z - t), $MachinePrecision] / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.05e-12], t$95$2, If[LessEqual[a, 4.1e-143], t$95$1, If[LessEqual[a, 2.4e-120], t$95$2, If[LessEqual[a, 4.8e+17], t$95$1, If[LessEqual[a, 3.4e+153], N[(x - N[(t / N[(N[(a - t), $MachinePrecision] / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + \frac{x - y}{\frac{t}{z}}\\
t_2 := x + \frac{z - t}{\frac{a}{y - x}}\\
\mathbf{if}\;a \leq -1.05 \cdot 10^{-12}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq 4.1 \cdot 10^{-143}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 2.4 \cdot 10^{-120}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq 4.8 \cdot 10^{+17}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 3.4 \cdot 10^{+153}:\\
\;\;\;\;x - \frac{t}{\frac{a - t}{y - x}}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if a < -1.04999999999999997e-12 or 4.1e-143 < a < 2.3999999999999999e-120 or 3.3999999999999997e153 < a Initial program 73.2%
+-commutative73.2%
associate-*r/90.9%
*-commutative90.9%
fma-def91.0%
Simplified91.0%
Taylor expanded in a around inf 63.5%
+-commutative63.5%
associate-/l*78.4%
Simplified78.4%
if -1.04999999999999997e-12 < a < 4.1e-143 or 2.3999999999999999e-120 < a < 4.8e17Initial program 70.4%
+-commutative70.4%
associate-*r/76.2%
*-commutative76.2%
fma-def76.3%
Simplified76.3%
Taylor expanded in t around inf 78.7%
*-commutative78.7%
cancel-sign-sub-inv78.7%
metadata-eval78.7%
*-lft-identity78.7%
distribute-lft-in78.7%
mul-1-neg78.7%
distribute-rgt-neg-in78.7%
mul-1-neg78.7%
*-commutative78.7%
cancel-sign-sub78.7%
mul-1-neg78.7%
associate-*r*78.7%
distribute-lft-out--78.7%
associate-*r/78.7%
mul-1-neg78.7%
Simplified82.8%
Taylor expanded in z around inf 76.1%
*-commutative76.1%
associate-/l*81.0%
Simplified81.0%
if 4.8e17 < a < 3.3999999999999997e153Initial program 81.3%
+-commutative81.3%
associate-*r/100.0%
*-commutative100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in z around 0 70.1%
fma-def70.1%
associate-*r/78.1%
fma-def78.1%
neg-mul-178.1%
+-commutative78.1%
unsub-neg78.1%
associate-*r/70.1%
associate-/l*78.1%
Simplified78.1%
Final simplification79.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ y (/ (- x y) (/ t (- z a)))))
(t_2 (+ x (/ (- z t) (/ a (- y x))))))
(if (<= a -7e-14)
t_2
(if (<= a 4.1e-143)
t_1
(if (<= a 2.4e-120)
t_2
(if (<= a 1.9e+17)
t_1
(if (<= a 1.45e+154) (- x (/ t (/ (- a t) (- y x)))) t_2)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y + ((x - y) / (t / (z - a)));
double t_2 = x + ((z - t) / (a / (y - x)));
double tmp;
if (a <= -7e-14) {
tmp = t_2;
} else if (a <= 4.1e-143) {
tmp = t_1;
} else if (a <= 2.4e-120) {
tmp = t_2;
} else if (a <= 1.9e+17) {
tmp = t_1;
} else if (a <= 1.45e+154) {
tmp = x - (t / ((a - t) / (y - x)));
} else {
tmp = t_2;
}
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) :: t_2
real(8) :: tmp
t_1 = y + ((x - y) / (t / (z - a)))
t_2 = x + ((z - t) / (a / (y - x)))
if (a <= (-7d-14)) then
tmp = t_2
else if (a <= 4.1d-143) then
tmp = t_1
else if (a <= 2.4d-120) then
tmp = t_2
else if (a <= 1.9d+17) then
tmp = t_1
else if (a <= 1.45d+154) then
tmp = x - (t / ((a - t) / (y - x)))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y + ((x - y) / (t / (z - a)));
double t_2 = x + ((z - t) / (a / (y - x)));
double tmp;
if (a <= -7e-14) {
tmp = t_2;
} else if (a <= 4.1e-143) {
tmp = t_1;
} else if (a <= 2.4e-120) {
tmp = t_2;
} else if (a <= 1.9e+17) {
tmp = t_1;
} else if (a <= 1.45e+154) {
tmp = x - (t / ((a - t) / (y - x)));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y + ((x - y) / (t / (z - a))) t_2 = x + ((z - t) / (a / (y - x))) tmp = 0 if a <= -7e-14: tmp = t_2 elif a <= 4.1e-143: tmp = t_1 elif a <= 2.4e-120: tmp = t_2 elif a <= 1.9e+17: tmp = t_1 elif a <= 1.45e+154: tmp = x - (t / ((a - t) / (y - x))) else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(y + Float64(Float64(x - y) / Float64(t / Float64(z - a)))) t_2 = Float64(x + Float64(Float64(z - t) / Float64(a / Float64(y - x)))) tmp = 0.0 if (a <= -7e-14) tmp = t_2; elseif (a <= 4.1e-143) tmp = t_1; elseif (a <= 2.4e-120) tmp = t_2; elseif (a <= 1.9e+17) tmp = t_1; elseif (a <= 1.45e+154) tmp = Float64(x - Float64(t / Float64(Float64(a - t) / Float64(y - x)))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y + ((x - y) / (t / (z - a))); t_2 = x + ((z - t) / (a / (y - x))); tmp = 0.0; if (a <= -7e-14) tmp = t_2; elseif (a <= 4.1e-143) tmp = t_1; elseif (a <= 2.4e-120) tmp = t_2; elseif (a <= 1.9e+17) tmp = t_1; elseif (a <= 1.45e+154) tmp = x - (t / ((a - t) / (y - x))); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y + N[(N[(x - y), $MachinePrecision] / N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(z - t), $MachinePrecision] / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -7e-14], t$95$2, If[LessEqual[a, 4.1e-143], t$95$1, If[LessEqual[a, 2.4e-120], t$95$2, If[LessEqual[a, 1.9e+17], t$95$1, If[LessEqual[a, 1.45e+154], N[(x - N[(t / N[(N[(a - t), $MachinePrecision] / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + \frac{x - y}{\frac{t}{z - a}}\\
t_2 := x + \frac{z - t}{\frac{a}{y - x}}\\
\mathbf{if}\;a \leq -7 \cdot 10^{-14}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq 4.1 \cdot 10^{-143}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 2.4 \cdot 10^{-120}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq 1.9 \cdot 10^{+17}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 1.45 \cdot 10^{+154}:\\
\;\;\;\;x - \frac{t}{\frac{a - t}{y - x}}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if a < -7.0000000000000005e-14 or 4.1e-143 < a < 2.3999999999999999e-120 or 1.4499999999999999e154 < a Initial program 73.2%
+-commutative73.2%
associate-*r/90.9%
*-commutative90.9%
fma-def91.0%
Simplified91.0%
Taylor expanded in a around inf 63.5%
+-commutative63.5%
associate-/l*78.4%
Simplified78.4%
if -7.0000000000000005e-14 < a < 4.1e-143 or 2.3999999999999999e-120 < a < 1.9e17Initial program 70.4%
+-commutative70.4%
associate-*r/76.2%
*-commutative76.2%
fma-def76.3%
Simplified76.3%
Taylor expanded in t around inf 78.7%
*-commutative78.7%
cancel-sign-sub-inv78.7%
metadata-eval78.7%
*-lft-identity78.7%
distribute-lft-in78.7%
mul-1-neg78.7%
distribute-rgt-neg-in78.7%
mul-1-neg78.7%
*-commutative78.7%
cancel-sign-sub78.7%
mul-1-neg78.7%
associate-*r*78.7%
distribute-lft-out--78.7%
associate-*r/78.7%
mul-1-neg78.7%
Simplified82.8%
if 1.9e17 < a < 1.4499999999999999e154Initial program 81.3%
+-commutative81.3%
associate-*r/100.0%
*-commutative100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in z around 0 70.1%
fma-def70.1%
associate-*r/78.1%
fma-def78.1%
neg-mul-178.1%
+-commutative78.1%
unsub-neg78.1%
associate-*r/70.1%
associate-/l*78.1%
Simplified78.1%
Final simplification80.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (/ z (- a t)))))
(if (<= t -2.8e-5)
y
(if (<= t -3.6e-60)
(/ z (/ t x))
(if (<= t -2.8e-95)
t_1
(if (<= t 2.1e-206) x (if (<= t 1.65e+55) t_1 y)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * (z / (a - t));
double tmp;
if (t <= -2.8e-5) {
tmp = y;
} else if (t <= -3.6e-60) {
tmp = z / (t / x);
} else if (t <= -2.8e-95) {
tmp = t_1;
} else if (t <= 2.1e-206) {
tmp = x;
} else if (t <= 1.65e+55) {
tmp = t_1;
} else {
tmp = y;
}
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 = y * (z / (a - t))
if (t <= (-2.8d-5)) then
tmp = y
else if (t <= (-3.6d-60)) then
tmp = z / (t / x)
else if (t <= (-2.8d-95)) then
tmp = t_1
else if (t <= 2.1d-206) then
tmp = x
else if (t <= 1.65d+55) then
tmp = t_1
else
tmp = y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y * (z / (a - t));
double tmp;
if (t <= -2.8e-5) {
tmp = y;
} else if (t <= -3.6e-60) {
tmp = z / (t / x);
} else if (t <= -2.8e-95) {
tmp = t_1;
} else if (t <= 2.1e-206) {
tmp = x;
} else if (t <= 1.65e+55) {
tmp = t_1;
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * (z / (a - t)) tmp = 0 if t <= -2.8e-5: tmp = y elif t <= -3.6e-60: tmp = z / (t / x) elif t <= -2.8e-95: tmp = t_1 elif t <= 2.1e-206: tmp = x elif t <= 1.65e+55: tmp = t_1 else: tmp = y return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(z / Float64(a - t))) tmp = 0.0 if (t <= -2.8e-5) tmp = y; elseif (t <= -3.6e-60) tmp = Float64(z / Float64(t / x)); elseif (t <= -2.8e-95) tmp = t_1; elseif (t <= 2.1e-206) tmp = x; elseif (t <= 1.65e+55) tmp = t_1; else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * (z / (a - t)); tmp = 0.0; if (t <= -2.8e-5) tmp = y; elseif (t <= -3.6e-60) tmp = z / (t / x); elseif (t <= -2.8e-95) tmp = t_1; elseif (t <= 2.1e-206) tmp = x; elseif (t <= 1.65e+55) tmp = t_1; else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.8e-5], y, If[LessEqual[t, -3.6e-60], N[(z / N[(t / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -2.8e-95], t$95$1, If[LessEqual[t, 2.1e-206], x, If[LessEqual[t, 1.65e+55], t$95$1, y]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \frac{z}{a - t}\\
\mathbf{if}\;t \leq -2.8 \cdot 10^{-5}:\\
\;\;\;\;y\\
\mathbf{elif}\;t \leq -3.6 \cdot 10^{-60}:\\
\;\;\;\;\frac{z}{\frac{t}{x}}\\
\mathbf{elif}\;t \leq -2.8 \cdot 10^{-95}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 2.1 \cdot 10^{-206}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 1.65 \cdot 10^{+55}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -2.79999999999999996e-5 or 1.65e55 < t Initial program 56.6%
+-commutative56.6%
associate-*r/80.8%
*-commutative80.8%
fma-def80.8%
Simplified80.8%
Taylor expanded in t around inf 51.4%
if -2.79999999999999996e-5 < t < -3.6e-60Initial program 58.5%
+-commutative58.5%
associate-*r/67.7%
*-commutative67.7%
fma-def67.9%
Simplified67.9%
Taylor expanded in t around inf 59.2%
*-commutative59.2%
cancel-sign-sub-inv59.2%
metadata-eval59.2%
*-lft-identity59.2%
distribute-lft-in59.2%
mul-1-neg59.2%
distribute-rgt-neg-in59.2%
mul-1-neg59.2%
*-commutative59.2%
cancel-sign-sub59.2%
mul-1-neg59.2%
associate-*r*59.2%
distribute-lft-out--59.2%
associate-*r/59.2%
mul-1-neg59.2%
Simplified59.2%
Taylor expanded in z around inf 56.0%
*-commutative56.0%
associate-/l*56.0%
Simplified56.0%
Taylor expanded in y around 0 47.2%
associate-/l*47.2%
Simplified47.2%
if -3.6e-60 < t < -2.7999999999999999e-95 or 2.1000000000000001e-206 < t < 1.65e55Initial program 88.1%
+-commutative88.1%
associate-*r/92.5%
*-commutative92.5%
fma-def92.5%
Simplified92.5%
Taylor expanded in y around inf 58.0%
div-sub58.0%
*-commutative58.0%
Simplified58.0%
Taylor expanded in z around inf 42.6%
if -2.7999999999999999e-95 < t < 2.1000000000000001e-206Initial program 93.2%
+-commutative93.2%
associate-*r/91.5%
*-commutative91.5%
fma-def91.5%
Simplified91.5%
Taylor expanded in a around inf 46.2%
Final simplification48.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* z (/ y (- a t)))))
(if (<= t -2.8e-5)
y
(if (<= t -2.05e-60)
(/ z (/ t x))
(if (<= t -2.9e-96)
t_1
(if (<= t 2e-248) x (if (<= t 3.2e+57) t_1 y)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = z * (y / (a - t));
double tmp;
if (t <= -2.8e-5) {
tmp = y;
} else if (t <= -2.05e-60) {
tmp = z / (t / x);
} else if (t <= -2.9e-96) {
tmp = t_1;
} else if (t <= 2e-248) {
tmp = x;
} else if (t <= 3.2e+57) {
tmp = t_1;
} else {
tmp = y;
}
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 = z * (y / (a - t))
if (t <= (-2.8d-5)) then
tmp = y
else if (t <= (-2.05d-60)) then
tmp = z / (t / x)
else if (t <= (-2.9d-96)) then
tmp = t_1
else if (t <= 2d-248) then
tmp = x
else if (t <= 3.2d+57) then
tmp = t_1
else
tmp = y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = z * (y / (a - t));
double tmp;
if (t <= -2.8e-5) {
tmp = y;
} else if (t <= -2.05e-60) {
tmp = z / (t / x);
} else if (t <= -2.9e-96) {
tmp = t_1;
} else if (t <= 2e-248) {
tmp = x;
} else if (t <= 3.2e+57) {
tmp = t_1;
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = z * (y / (a - t)) tmp = 0 if t <= -2.8e-5: tmp = y elif t <= -2.05e-60: tmp = z / (t / x) elif t <= -2.9e-96: tmp = t_1 elif t <= 2e-248: tmp = x elif t <= 3.2e+57: tmp = t_1 else: tmp = y return tmp
function code(x, y, z, t, a) t_1 = Float64(z * Float64(y / Float64(a - t))) tmp = 0.0 if (t <= -2.8e-5) tmp = y; elseif (t <= -2.05e-60) tmp = Float64(z / Float64(t / x)); elseif (t <= -2.9e-96) tmp = t_1; elseif (t <= 2e-248) tmp = x; elseif (t <= 3.2e+57) tmp = t_1; else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = z * (y / (a - t)); tmp = 0.0; if (t <= -2.8e-5) tmp = y; elseif (t <= -2.05e-60) tmp = z / (t / x); elseif (t <= -2.9e-96) tmp = t_1; elseif (t <= 2e-248) tmp = x; elseif (t <= 3.2e+57) tmp = t_1; else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(z * N[(y / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.8e-5], y, If[LessEqual[t, -2.05e-60], N[(z / N[(t / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -2.9e-96], t$95$1, If[LessEqual[t, 2e-248], x, If[LessEqual[t, 3.2e+57], t$95$1, y]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \frac{y}{a - t}\\
\mathbf{if}\;t \leq -2.8 \cdot 10^{-5}:\\
\;\;\;\;y\\
\mathbf{elif}\;t \leq -2.05 \cdot 10^{-60}:\\
\;\;\;\;\frac{z}{\frac{t}{x}}\\
\mathbf{elif}\;t \leq -2.9 \cdot 10^{-96}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 2 \cdot 10^{-248}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 3.2 \cdot 10^{+57}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -2.79999999999999996e-5 or 3.20000000000000029e57 < t Initial program 56.6%
+-commutative56.6%
associate-*r/80.8%
*-commutative80.8%
fma-def80.8%
Simplified80.8%
Taylor expanded in t around inf 51.4%
if -2.79999999999999996e-5 < t < -2.05000000000000006e-60Initial program 58.5%
+-commutative58.5%
associate-*r/67.7%
*-commutative67.7%
fma-def67.9%
Simplified67.9%
Taylor expanded in t around inf 59.2%
*-commutative59.2%
cancel-sign-sub-inv59.2%
metadata-eval59.2%
*-lft-identity59.2%
distribute-lft-in59.2%
mul-1-neg59.2%
distribute-rgt-neg-in59.2%
mul-1-neg59.2%
*-commutative59.2%
cancel-sign-sub59.2%
mul-1-neg59.2%
associate-*r*59.2%
distribute-lft-out--59.2%
associate-*r/59.2%
mul-1-neg59.2%
Simplified59.2%
Taylor expanded in z around inf 56.0%
*-commutative56.0%
associate-/l*56.0%
Simplified56.0%
Taylor expanded in y around 0 47.2%
associate-/l*47.2%
Simplified47.2%
if -2.05000000000000006e-60 < t < -2.89999999999999994e-96 or 1.99999999999999996e-248 < t < 3.20000000000000029e57Initial program 89.6%
+-commutative89.6%
associate-*r/88.6%
*-commutative88.6%
fma-def88.6%
Simplified88.6%
Taylor expanded in y around inf 53.8%
div-sub53.8%
*-commutative53.8%
Simplified53.8%
Taylor expanded in z around inf 37.7%
associate-/l*39.1%
associate-/r/40.9%
Simplified40.9%
if -2.89999999999999994e-96 < t < 1.99999999999999996e-248Initial program 92.3%
+-commutative92.3%
associate-*r/95.2%
*-commutative95.2%
fma-def95.2%
Simplified95.2%
Taylor expanded in a around inf 48.8%
Final simplification48.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- y (* z (/ y t)))))
(if (<= t -7e-92)
t_1
(if (<= t -3.6e-274)
x
(if (<= t 7.8e-236)
(/ z (/ a (- y x)))
(if (<= t 6.3e-15)
(* y (/ z (- a t)))
(if (<= t 1100000000.0) x t_1)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y - (z * (y / t));
double tmp;
if (t <= -7e-92) {
tmp = t_1;
} else if (t <= -3.6e-274) {
tmp = x;
} else if (t <= 7.8e-236) {
tmp = z / (a / (y - x));
} else if (t <= 6.3e-15) {
tmp = y * (z / (a - t));
} else if (t <= 1100000000.0) {
tmp = 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 = y - (z * (y / t))
if (t <= (-7d-92)) then
tmp = t_1
else if (t <= (-3.6d-274)) then
tmp = x
else if (t <= 7.8d-236) then
tmp = z / (a / (y - x))
else if (t <= 6.3d-15) then
tmp = y * (z / (a - t))
else if (t <= 1100000000.0d0) then
tmp = 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 = y - (z * (y / t));
double tmp;
if (t <= -7e-92) {
tmp = t_1;
} else if (t <= -3.6e-274) {
tmp = x;
} else if (t <= 7.8e-236) {
tmp = z / (a / (y - x));
} else if (t <= 6.3e-15) {
tmp = y * (z / (a - t));
} else if (t <= 1100000000.0) {
tmp = x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y - (z * (y / t)) tmp = 0 if t <= -7e-92: tmp = t_1 elif t <= -3.6e-274: tmp = x elif t <= 7.8e-236: tmp = z / (a / (y - x)) elif t <= 6.3e-15: tmp = y * (z / (a - t)) elif t <= 1100000000.0: tmp = x else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(y - Float64(z * Float64(y / t))) tmp = 0.0 if (t <= -7e-92) tmp = t_1; elseif (t <= -3.6e-274) tmp = x; elseif (t <= 7.8e-236) tmp = Float64(z / Float64(a / Float64(y - x))); elseif (t <= 6.3e-15) tmp = Float64(y * Float64(z / Float64(a - t))); elseif (t <= 1100000000.0) tmp = x; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y - (z * (y / t)); tmp = 0.0; if (t <= -7e-92) tmp = t_1; elseif (t <= -3.6e-274) tmp = x; elseif (t <= 7.8e-236) tmp = z / (a / (y - x)); elseif (t <= 6.3e-15) tmp = y * (z / (a - t)); elseif (t <= 1100000000.0) tmp = x; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y - N[(z * N[(y / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -7e-92], t$95$1, If[LessEqual[t, -3.6e-274], x, If[LessEqual[t, 7.8e-236], N[(z / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 6.3e-15], N[(y * N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1100000000.0], x, t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y - z \cdot \frac{y}{t}\\
\mathbf{if}\;t \leq -7 \cdot 10^{-92}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -3.6 \cdot 10^{-274}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 7.8 \cdot 10^{-236}:\\
\;\;\;\;\frac{z}{\frac{a}{y - x}}\\
\mathbf{elif}\;t \leq 6.3 \cdot 10^{-15}:\\
\;\;\;\;y \cdot \frac{z}{a - t}\\
\mathbf{elif}\;t \leq 1100000000:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -7e-92 or 1.1e9 < t Initial program 60.2%
+-commutative60.2%
associate-*r/80.4%
*-commutative80.4%
fma-def80.4%
Simplified80.4%
Taylor expanded in t around inf 66.3%
*-commutative66.3%
cancel-sign-sub-inv66.3%
metadata-eval66.3%
*-lft-identity66.3%
distribute-lft-in66.3%
mul-1-neg66.3%
distribute-rgt-neg-in66.3%
mul-1-neg66.3%
*-commutative66.3%
cancel-sign-sub66.3%
mul-1-neg66.3%
associate-*r*66.3%
distribute-lft-out--66.3%
associate-*r/66.3%
mul-1-neg66.3%
Simplified73.8%
Taylor expanded in z around inf 65.2%
*-commutative65.2%
associate-/l*70.2%
Simplified70.2%
Taylor expanded in y around inf 52.4%
associate-*l/54.3%
Simplified54.3%
if -7e-92 < t < -3.59999999999999983e-274 or 6.29999999999999982e-15 < t < 1.1e9Initial program 91.3%
+-commutative91.3%
associate-*r/95.4%
*-commutative95.4%
fma-def95.4%
Simplified95.4%
Taylor expanded in a around inf 52.5%
if -3.59999999999999983e-274 < t < 7.8000000000000001e-236Initial program 96.4%
+-commutative96.4%
associate-*r/86.2%
*-commutative86.2%
fma-def86.2%
Simplified86.2%
Taylor expanded in z around inf 60.5%
div-sub60.5%
*-commutative60.5%
associate-*l/60.8%
associate-/l*50.8%
Simplified50.8%
Taylor expanded in a around inf 51.9%
associate-/l*55.2%
Simplified55.2%
if 7.8000000000000001e-236 < t < 6.29999999999999982e-15Initial program 89.8%
+-commutative89.8%
associate-*r/96.5%
*-commutative96.5%
fma-def96.5%
Simplified96.5%
Taylor expanded in y around inf 63.6%
div-sub63.6%
*-commutative63.6%
Simplified63.6%
Taylor expanded in z around inf 56.8%
Final simplification54.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (/ (- z t) (- a t)))))
(if (<= t -1.05e-95)
t_1
(if (<= t -3.5e-274)
x
(if (<= t 2.4e-234)
(/ z (/ a (- y x)))
(if (<= t 4e+28) t_1 (+ y (* z (/ x t)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((z - t) / (a - t));
double tmp;
if (t <= -1.05e-95) {
tmp = t_1;
} else if (t <= -3.5e-274) {
tmp = x;
} else if (t <= 2.4e-234) {
tmp = z / (a / (y - x));
} else if (t <= 4e+28) {
tmp = t_1;
} else {
tmp = y + (z * (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) :: t_1
real(8) :: tmp
t_1 = y * ((z - t) / (a - t))
if (t <= (-1.05d-95)) then
tmp = t_1
else if (t <= (-3.5d-274)) then
tmp = x
else if (t <= 2.4d-234) then
tmp = z / (a / (y - x))
else if (t <= 4d+28) then
tmp = t_1
else
tmp = y + (z * (x / t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((z - t) / (a - t));
double tmp;
if (t <= -1.05e-95) {
tmp = t_1;
} else if (t <= -3.5e-274) {
tmp = x;
} else if (t <= 2.4e-234) {
tmp = z / (a / (y - x));
} else if (t <= 4e+28) {
tmp = t_1;
} else {
tmp = y + (z * (x / t));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * ((z - t) / (a - t)) tmp = 0 if t <= -1.05e-95: tmp = t_1 elif t <= -3.5e-274: tmp = x elif t <= 2.4e-234: tmp = z / (a / (y - x)) elif t <= 4e+28: tmp = t_1 else: tmp = y + (z * (x / t)) return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(Float64(z - t) / Float64(a - t))) tmp = 0.0 if (t <= -1.05e-95) tmp = t_1; elseif (t <= -3.5e-274) tmp = x; elseif (t <= 2.4e-234) tmp = Float64(z / Float64(a / Float64(y - x))); elseif (t <= 4e+28) tmp = t_1; else tmp = Float64(y + Float64(z * Float64(x / t))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * ((z - t) / (a - t)); tmp = 0.0; if (t <= -1.05e-95) tmp = t_1; elseif (t <= -3.5e-274) tmp = x; elseif (t <= 2.4e-234) tmp = z / (a / (y - x)); elseif (t <= 4e+28) tmp = t_1; else tmp = y + (z * (x / t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.05e-95], t$95$1, If[LessEqual[t, -3.5e-274], x, If[LessEqual[t, 2.4e-234], N[(z / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 4e+28], t$95$1, N[(y + N[(z * N[(x / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \frac{z - t}{a - t}\\
\mathbf{if}\;t \leq -1.05 \cdot 10^{-95}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -3.5 \cdot 10^{-274}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 2.4 \cdot 10^{-234}:\\
\;\;\;\;\frac{z}{\frac{a}{y - x}}\\
\mathbf{elif}\;t \leq 4 \cdot 10^{+28}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y + z \cdot \frac{x}{t}\\
\end{array}
\end{array}
if t < -1.05e-95 or 2.3999999999999999e-234 < t < 3.99999999999999983e28Initial program 72.6%
+-commutative72.6%
associate-*r/85.4%
*-commutative85.4%
fma-def85.5%
Simplified85.5%
Taylor expanded in y around inf 64.6%
div-sub64.6%
*-commutative64.6%
Simplified64.6%
if -1.05e-95 < t < -3.49999999999999982e-274Initial program 90.2%
+-commutative90.2%
associate-*r/94.8%
*-commutative94.8%
fma-def94.8%
Simplified94.8%
Taylor expanded in a around inf 51.4%
if -3.49999999999999982e-274 < t < 2.3999999999999999e-234Initial program 96.4%
+-commutative96.4%
associate-*r/86.2%
*-commutative86.2%
fma-def86.2%
Simplified86.2%
Taylor expanded in z around inf 60.5%
div-sub60.5%
*-commutative60.5%
associate-*l/60.8%
associate-/l*50.8%
Simplified50.8%
Taylor expanded in a around inf 51.9%
associate-/l*55.2%
Simplified55.2%
if 3.99999999999999983e28 < t Initial program 54.0%
+-commutative54.0%
associate-*r/80.1%
*-commutative80.1%
fma-def80.1%
Simplified80.1%
Taylor expanded in t around inf 66.8%
*-commutative66.8%
cancel-sign-sub-inv66.8%
metadata-eval66.8%
*-lft-identity66.8%
distribute-lft-in66.8%
mul-1-neg66.8%
distribute-rgt-neg-in66.8%
mul-1-neg66.8%
*-commutative66.8%
cancel-sign-sub66.8%
mul-1-neg66.8%
associate-*r*66.8%
distribute-lft-out--66.8%
associate-*r/66.8%
mul-1-neg66.8%
Simplified81.5%
Taylor expanded in z around inf 70.8%
*-commutative70.8%
associate-/l*79.6%
Simplified79.6%
Taylor expanded in y around 0 67.4%
mul-1-neg67.4%
*-commutative67.4%
associate-*l/73.3%
distribute-rgt-neg-in73.3%
Simplified73.3%
Final simplification63.8%
(FPCore (x y z t a)
:precision binary64
(if (<= t -4.7e-8)
(* y (/ (- z t) (- a t)))
(if (<= t -1.1e-65)
(/ (* (- y x) z) (- a t))
(if (<= t -2.6e-95)
(/ (* y (- z t)) (- a t))
(if (<= t 18000000000000.0)
(- x (/ (- x y) (/ a z)))
(+ y (/ (- x y) (/ t z))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -4.7e-8) {
tmp = y * ((z - t) / (a - t));
} else if (t <= -1.1e-65) {
tmp = ((y - x) * z) / (a - t);
} else if (t <= -2.6e-95) {
tmp = (y * (z - t)) / (a - t);
} else if (t <= 18000000000000.0) {
tmp = x - ((x - y) / (a / z));
} else {
tmp = y + ((x - y) / (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 (t <= (-4.7d-8)) then
tmp = y * ((z - t) / (a - t))
else if (t <= (-1.1d-65)) then
tmp = ((y - x) * z) / (a - t)
else if (t <= (-2.6d-95)) then
tmp = (y * (z - t)) / (a - t)
else if (t <= 18000000000000.0d0) then
tmp = x - ((x - y) / (a / z))
else
tmp = y + ((x - y) / (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 (t <= -4.7e-8) {
tmp = y * ((z - t) / (a - t));
} else if (t <= -1.1e-65) {
tmp = ((y - x) * z) / (a - t);
} else if (t <= -2.6e-95) {
tmp = (y * (z - t)) / (a - t);
} else if (t <= 18000000000000.0) {
tmp = x - ((x - y) / (a / z));
} else {
tmp = y + ((x - y) / (t / z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -4.7e-8: tmp = y * ((z - t) / (a - t)) elif t <= -1.1e-65: tmp = ((y - x) * z) / (a - t) elif t <= -2.6e-95: tmp = (y * (z - t)) / (a - t) elif t <= 18000000000000.0: tmp = x - ((x - y) / (a / z)) else: tmp = y + ((x - y) / (t / z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -4.7e-8) tmp = Float64(y * Float64(Float64(z - t) / Float64(a - t))); elseif (t <= -1.1e-65) tmp = Float64(Float64(Float64(y - x) * z) / Float64(a - t)); elseif (t <= -2.6e-95) tmp = Float64(Float64(y * Float64(z - t)) / Float64(a - t)); elseif (t <= 18000000000000.0) tmp = Float64(x - Float64(Float64(x - y) / Float64(a / z))); else tmp = Float64(y + Float64(Float64(x - y) / Float64(t / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -4.7e-8) tmp = y * ((z - t) / (a - t)); elseif (t <= -1.1e-65) tmp = ((y - x) * z) / (a - t); elseif (t <= -2.6e-95) tmp = (y * (z - t)) / (a - t); elseif (t <= 18000000000000.0) tmp = x - ((x - y) / (a / z)); else tmp = y + ((x - y) / (t / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -4.7e-8], N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.1e-65], N[(N[(N[(y - x), $MachinePrecision] * z), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -2.6e-95], N[(N[(y * N[(z - t), $MachinePrecision]), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 18000000000000.0], N[(x - N[(N[(x - y), $MachinePrecision] / N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y + N[(N[(x - y), $MachinePrecision] / N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -4.7 \cdot 10^{-8}:\\
\;\;\;\;y \cdot \frac{z - t}{a - t}\\
\mathbf{elif}\;t \leq -1.1 \cdot 10^{-65}:\\
\;\;\;\;\frac{\left(y - x\right) \cdot z}{a - t}\\
\mathbf{elif}\;t \leq -2.6 \cdot 10^{-95}:\\
\;\;\;\;\frac{y \cdot \left(z - t\right)}{a - t}\\
\mathbf{elif}\;t \leq 18000000000000:\\
\;\;\;\;x - \frac{x - y}{\frac{a}{z}}\\
\mathbf{else}:\\
\;\;\;\;y + \frac{x - y}{\frac{t}{z}}\\
\end{array}
\end{array}
if t < -4.6999999999999997e-8Initial program 60.6%
+-commutative60.6%
associate-*r/80.5%
*-commutative80.5%
fma-def80.5%
Simplified80.5%
Taylor expanded in y around inf 72.3%
div-sub72.3%
*-commutative72.3%
Simplified72.3%
if -4.6999999999999997e-8 < t < -1.10000000000000011e-65Initial program 62.2%
+-commutative62.2%
associate-*r/70.5%
*-commutative70.5%
fma-def70.7%
Simplified70.7%
Taylor expanded in z around inf 85.4%
div-sub85.4%
*-commutative85.4%
associate-*l/76.9%
Simplified76.9%
if -1.10000000000000011e-65 < t < -2.60000000000000001e-95Initial program 87.9%
+-commutative87.9%
associate-*r/87.7%
*-commutative87.7%
fma-def87.7%
Simplified87.7%
Taylor expanded in y around -inf 75.6%
if -2.60000000000000001e-95 < t < 1.8e13Initial program 92.1%
+-commutative92.1%
associate-*r/93.3%
*-commutative93.3%
fma-def93.3%
Simplified93.3%
Taylor expanded in t around 0 74.4%
+-commutative74.4%
associate-/l*75.8%
Simplified75.8%
if 1.8e13 < t Initial program 56.7%
+-commutative56.7%
associate-*r/81.3%
*-commutative81.3%
fma-def81.3%
Simplified81.3%
Taylor expanded in t around inf 67.3%
*-commutative67.3%
cancel-sign-sub-inv67.3%
metadata-eval67.3%
*-lft-identity67.3%
distribute-lft-in67.3%
mul-1-neg67.3%
distribute-rgt-neg-in67.3%
mul-1-neg67.3%
*-commutative67.3%
cancel-sign-sub67.3%
mul-1-neg67.3%
associate-*r*67.3%
distribute-lft-out--67.3%
associate-*r/67.3%
mul-1-neg67.3%
Simplified81.1%
Taylor expanded in z around inf 71.1%
*-commutative71.1%
associate-/l*79.4%
Simplified79.4%
Final simplification75.9%
(FPCore (x y z t a)
:precision binary64
(if (<= t -1.65e-6)
y
(if (<= t -4.2e-75)
(/ z (/ t x))
(if (<= t -2.9e-95)
y
(if (<= t 2.5e-247)
x
(if (<= t 6e-101) (/ z (/ a y)) (if (<= t 2.8e+105) x y)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -1.65e-6) {
tmp = y;
} else if (t <= -4.2e-75) {
tmp = z / (t / x);
} else if (t <= -2.9e-95) {
tmp = y;
} else if (t <= 2.5e-247) {
tmp = x;
} else if (t <= 6e-101) {
tmp = z / (a / y);
} else if (t <= 2.8e+105) {
tmp = x;
} else {
tmp = y;
}
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 (t <= (-1.65d-6)) then
tmp = y
else if (t <= (-4.2d-75)) then
tmp = z / (t / x)
else if (t <= (-2.9d-95)) then
tmp = y
else if (t <= 2.5d-247) then
tmp = x
else if (t <= 6d-101) then
tmp = z / (a / y)
else if (t <= 2.8d+105) then
tmp = x
else
tmp = y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -1.65e-6) {
tmp = y;
} else if (t <= -4.2e-75) {
tmp = z / (t / x);
} else if (t <= -2.9e-95) {
tmp = y;
} else if (t <= 2.5e-247) {
tmp = x;
} else if (t <= 6e-101) {
tmp = z / (a / y);
} else if (t <= 2.8e+105) {
tmp = x;
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -1.65e-6: tmp = y elif t <= -4.2e-75: tmp = z / (t / x) elif t <= -2.9e-95: tmp = y elif t <= 2.5e-247: tmp = x elif t <= 6e-101: tmp = z / (a / y) elif t <= 2.8e+105: tmp = x else: tmp = y return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -1.65e-6) tmp = y; elseif (t <= -4.2e-75) tmp = Float64(z / Float64(t / x)); elseif (t <= -2.9e-95) tmp = y; elseif (t <= 2.5e-247) tmp = x; elseif (t <= 6e-101) tmp = Float64(z / Float64(a / y)); elseif (t <= 2.8e+105) tmp = x; else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -1.65e-6) tmp = y; elseif (t <= -4.2e-75) tmp = z / (t / x); elseif (t <= -2.9e-95) tmp = y; elseif (t <= 2.5e-247) tmp = x; elseif (t <= 6e-101) tmp = z / (a / y); elseif (t <= 2.8e+105) tmp = x; else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -1.65e-6], y, If[LessEqual[t, -4.2e-75], N[(z / N[(t / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -2.9e-95], y, If[LessEqual[t, 2.5e-247], x, If[LessEqual[t, 6e-101], N[(z / N[(a / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.8e+105], x, y]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.65 \cdot 10^{-6}:\\
\;\;\;\;y\\
\mathbf{elif}\;t \leq -4.2 \cdot 10^{-75}:\\
\;\;\;\;\frac{z}{\frac{t}{x}}\\
\mathbf{elif}\;t \leq -2.9 \cdot 10^{-95}:\\
\;\;\;\;y\\
\mathbf{elif}\;t \leq 2.5 \cdot 10^{-247}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 6 \cdot 10^{-101}:\\
\;\;\;\;\frac{z}{\frac{a}{y}}\\
\mathbf{elif}\;t \leq 2.8 \cdot 10^{+105}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -1.65000000000000008e-6 or -4.2000000000000002e-75 < t < -2.90000000000000002e-95 or 2.8000000000000001e105 < t Initial program 58.2%
+-commutative58.2%
associate-*r/80.1%
*-commutative80.1%
fma-def80.1%
Simplified80.1%
Taylor expanded in t around inf 51.8%
if -1.65000000000000008e-6 < t < -4.2000000000000002e-75Initial program 65.3%
+-commutative65.3%
associate-*r/72.9%
*-commutative72.9%
fma-def73.1%
Simplified73.1%
Taylor expanded in t around inf 49.4%
*-commutative49.4%
cancel-sign-sub-inv49.4%
metadata-eval49.4%
*-lft-identity49.4%
distribute-lft-in49.4%
mul-1-neg49.4%
distribute-rgt-neg-in49.4%
mul-1-neg49.4%
*-commutative49.4%
cancel-sign-sub49.4%
mul-1-neg49.4%
associate-*r*49.4%
distribute-lft-out--49.4%
associate-*r/49.4%
mul-1-neg49.4%
Simplified49.4%
Taylor expanded in z around inf 46.8%
*-commutative46.8%
associate-/l*46.8%
Simplified46.8%
Taylor expanded in y around 0 39.6%
associate-/l*39.6%
Simplified39.6%
if -2.90000000000000002e-95 < t < 2.49999999999999989e-247 or 6.0000000000000006e-101 < t < 2.8000000000000001e105Initial program 87.3%
+-commutative87.3%
associate-*r/94.0%
*-commutative94.0%
fma-def94.0%
Simplified94.0%
Taylor expanded in a around inf 43.8%
if 2.49999999999999989e-247 < t < 6.0000000000000006e-101Initial program 91.2%
+-commutative91.2%
associate-*r/85.4%
*-commutative85.4%
fma-def85.4%
Simplified85.4%
Taylor expanded in z around inf 62.6%
div-sub70.0%
*-commutative70.0%
associate-*l/69.9%
associate-/l*59.6%
Simplified59.6%
Taylor expanded in a around inf 49.8%
associate-/l*53.9%
Simplified53.9%
Taylor expanded in y around inf 49.0%
Final simplification47.9%
(FPCore (x y z t a)
:precision binary64
(if (<= t -1.02e-5)
(* y (/ (- z t) (- a t)))
(if (<= t -2.8e-96)
(/ (- y x) (/ (- a t) z))
(if (<= t 116000000.0)
(- x (/ (- x y) (/ a z)))
(+ y (/ (- x y) (/ t z)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -1.02e-5) {
tmp = y * ((z - t) / (a - t));
} else if (t <= -2.8e-96) {
tmp = (y - x) / ((a - t) / z);
} else if (t <= 116000000.0) {
tmp = x - ((x - y) / (a / z));
} else {
tmp = y + ((x - y) / (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 (t <= (-1.02d-5)) then
tmp = y * ((z - t) / (a - t))
else if (t <= (-2.8d-96)) then
tmp = (y - x) / ((a - t) / z)
else if (t <= 116000000.0d0) then
tmp = x - ((x - y) / (a / z))
else
tmp = y + ((x - y) / (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 (t <= -1.02e-5) {
tmp = y * ((z - t) / (a - t));
} else if (t <= -2.8e-96) {
tmp = (y - x) / ((a - t) / z);
} else if (t <= 116000000.0) {
tmp = x - ((x - y) / (a / z));
} else {
tmp = y + ((x - y) / (t / z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -1.02e-5: tmp = y * ((z - t) / (a - t)) elif t <= -2.8e-96: tmp = (y - x) / ((a - t) / z) elif t <= 116000000.0: tmp = x - ((x - y) / (a / z)) else: tmp = y + ((x - y) / (t / z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -1.02e-5) tmp = Float64(y * Float64(Float64(z - t) / Float64(a - t))); elseif (t <= -2.8e-96) tmp = Float64(Float64(y - x) / Float64(Float64(a - t) / z)); elseif (t <= 116000000.0) tmp = Float64(x - Float64(Float64(x - y) / Float64(a / z))); else tmp = Float64(y + Float64(Float64(x - y) / Float64(t / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -1.02e-5) tmp = y * ((z - t) / (a - t)); elseif (t <= -2.8e-96) tmp = (y - x) / ((a - t) / z); elseif (t <= 116000000.0) tmp = x - ((x - y) / (a / z)); else tmp = y + ((x - y) / (t / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -1.02e-5], N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -2.8e-96], N[(N[(y - x), $MachinePrecision] / N[(N[(a - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 116000000.0], N[(x - N[(N[(x - y), $MachinePrecision] / N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y + N[(N[(x - y), $MachinePrecision] / N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.02 \cdot 10^{-5}:\\
\;\;\;\;y \cdot \frac{z - t}{a - t}\\
\mathbf{elif}\;t \leq -2.8 \cdot 10^{-96}:\\
\;\;\;\;\frac{y - x}{\frac{a - t}{z}}\\
\mathbf{elif}\;t \leq 116000000:\\
\;\;\;\;x - \frac{x - y}{\frac{a}{z}}\\
\mathbf{else}:\\
\;\;\;\;y + \frac{x - y}{\frac{t}{z}}\\
\end{array}
\end{array}
if t < -1.0200000000000001e-5Initial program 60.6%
+-commutative60.6%
associate-*r/80.5%
*-commutative80.5%
fma-def80.5%
Simplified80.5%
Taylor expanded in y around inf 72.3%
div-sub72.3%
*-commutative72.3%
Simplified72.3%
if -1.0200000000000001e-5 < t < -2.80000000000000015e-96Initial program 74.3%
+-commutative74.3%
associate-*r/78.8%
*-commutative78.8%
fma-def78.9%
Simplified78.9%
Taylor expanded in z around inf 68.2%
div-sub68.2%
*-commutative68.2%
associate-*l/63.5%
associate-/l*68.3%
Simplified68.3%
if -2.80000000000000015e-96 < t < 1.16e8Initial program 92.0%
+-commutative92.0%
associate-*r/93.2%
*-commutative93.2%
fma-def93.2%
Simplified93.2%
Taylor expanded in t around 0 75.1%
+-commutative75.1%
associate-/l*76.6%
Simplified76.6%
if 1.16e8 < t Initial program 56.7%
+-commutative56.7%
associate-*r/81.3%
*-commutative81.3%
fma-def81.3%
Simplified81.3%
Taylor expanded in t around inf 67.3%
*-commutative67.3%
cancel-sign-sub-inv67.3%
metadata-eval67.3%
*-lft-identity67.3%
distribute-lft-in67.3%
mul-1-neg67.3%
distribute-rgt-neg-in67.3%
mul-1-neg67.3%
*-commutative67.3%
cancel-sign-sub67.3%
mul-1-neg67.3%
associate-*r*67.3%
distribute-lft-out--67.3%
associate-*r/67.3%
mul-1-neg67.3%
Simplified81.1%
Taylor expanded in z around inf 71.1%
*-commutative71.1%
associate-/l*79.4%
Simplified79.4%
Final simplification75.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- y (* z (/ y t)))))
(if (<= t -1.16e-89)
t_1
(if (<= t 9.5e-248) x (if (<= t 3.2e+14) (* z (/ y (- a t))) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y - (z * (y / t));
double tmp;
if (t <= -1.16e-89) {
tmp = t_1;
} else if (t <= 9.5e-248) {
tmp = x;
} else if (t <= 3.2e+14) {
tmp = z * (y / (a - t));
} 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 = y - (z * (y / t))
if (t <= (-1.16d-89)) then
tmp = t_1
else if (t <= 9.5d-248) then
tmp = x
else if (t <= 3.2d+14) then
tmp = z * (y / (a - t))
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 = y - (z * (y / t));
double tmp;
if (t <= -1.16e-89) {
tmp = t_1;
} else if (t <= 9.5e-248) {
tmp = x;
} else if (t <= 3.2e+14) {
tmp = z * (y / (a - t));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y - (z * (y / t)) tmp = 0 if t <= -1.16e-89: tmp = t_1 elif t <= 9.5e-248: tmp = x elif t <= 3.2e+14: tmp = z * (y / (a - t)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(y - Float64(z * Float64(y / t))) tmp = 0.0 if (t <= -1.16e-89) tmp = t_1; elseif (t <= 9.5e-248) tmp = x; elseif (t <= 3.2e+14) tmp = Float64(z * Float64(y / Float64(a - t))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y - (z * (y / t)); tmp = 0.0; if (t <= -1.16e-89) tmp = t_1; elseif (t <= 9.5e-248) tmp = x; elseif (t <= 3.2e+14) tmp = z * (y / (a - t)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y - N[(z * N[(y / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.16e-89], t$95$1, If[LessEqual[t, 9.5e-248], x, If[LessEqual[t, 3.2e+14], N[(z * N[(y / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y - z \cdot \frac{y}{t}\\
\mathbf{if}\;t \leq -1.16 \cdot 10^{-89}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 9.5 \cdot 10^{-248}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 3.2 \cdot 10^{+14}:\\
\;\;\;\;z \cdot \frac{y}{a - t}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -1.15999999999999993e-89 or 3.2e14 < t Initial program 60.2%
+-commutative60.2%
associate-*r/80.4%
*-commutative80.4%
fma-def80.4%
Simplified80.4%
Taylor expanded in t around inf 66.3%
*-commutative66.3%
cancel-sign-sub-inv66.3%
metadata-eval66.3%
*-lft-identity66.3%
distribute-lft-in66.3%
mul-1-neg66.3%
distribute-rgt-neg-in66.3%
mul-1-neg66.3%
*-commutative66.3%
cancel-sign-sub66.3%
mul-1-neg66.3%
associate-*r*66.3%
distribute-lft-out--66.3%
associate-*r/66.3%
mul-1-neg66.3%
Simplified73.8%
Taylor expanded in z around inf 65.2%
*-commutative65.2%
associate-/l*70.2%
Simplified70.2%
Taylor expanded in y around inf 52.4%
associate-*l/54.3%
Simplified54.3%
if -1.15999999999999993e-89 < t < 9.49999999999999971e-248Initial program 92.4%
+-commutative92.4%
associate-*r/95.3%
*-commutative95.3%
fma-def95.3%
Simplified95.3%
Taylor expanded in a around inf 48.1%
if 9.49999999999999971e-248 < t < 3.2e14Initial program 91.8%
+-commutative91.8%
associate-*r/90.3%
*-commutative90.3%
fma-def90.3%
Simplified90.3%
Taylor expanded in y around inf 51.9%
div-sub51.9%
*-commutative51.9%
Simplified51.9%
Taylor expanded in z around inf 42.3%
associate-/l*44.5%
associate-/r/47.0%
Simplified47.0%
Final simplification51.6%
(FPCore (x y z t a) :precision binary64 (if (<= t -1.6e-95) (* y (/ (- z t) (- a t))) (if (<= t 2.2e+14) (- x (/ (- x y) (/ a z))) (+ y (* z (/ x t))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -1.6e-95) {
tmp = y * ((z - t) / (a - t));
} else if (t <= 2.2e+14) {
tmp = x - ((x - y) / (a / z));
} else {
tmp = y + (z * (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 (t <= (-1.6d-95)) then
tmp = y * ((z - t) / (a - t))
else if (t <= 2.2d+14) then
tmp = x - ((x - y) / (a / z))
else
tmp = y + (z * (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 (t <= -1.6e-95) {
tmp = y * ((z - t) / (a - t));
} else if (t <= 2.2e+14) {
tmp = x - ((x - y) / (a / z));
} else {
tmp = y + (z * (x / t));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -1.6e-95: tmp = y * ((z - t) / (a - t)) elif t <= 2.2e+14: tmp = x - ((x - y) / (a / z)) else: tmp = y + (z * (x / t)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -1.6e-95) tmp = Float64(y * Float64(Float64(z - t) / Float64(a - t))); elseif (t <= 2.2e+14) tmp = Float64(x - Float64(Float64(x - y) / Float64(a / z))); else tmp = Float64(y + Float64(z * Float64(x / t))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -1.6e-95) tmp = y * ((z - t) / (a - t)); elseif (t <= 2.2e+14) tmp = x - ((x - y) / (a / z)); else tmp = y + (z * (x / t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -1.6e-95], N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.2e+14], N[(x - N[(N[(x - y), $MachinePrecision] / N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y + N[(z * N[(x / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.6 \cdot 10^{-95}:\\
\;\;\;\;y \cdot \frac{z - t}{a - t}\\
\mathbf{elif}\;t \leq 2.2 \cdot 10^{+14}:\\
\;\;\;\;x - \frac{x - y}{\frac{a}{z}}\\
\mathbf{else}:\\
\;\;\;\;y + z \cdot \frac{x}{t}\\
\end{array}
\end{array}
if t < -1.5999999999999999e-95Initial program 63.4%
+-commutative63.4%
associate-*r/79.9%
*-commutative79.9%
fma-def79.9%
Simplified79.9%
Taylor expanded in y around inf 67.2%
div-sub67.2%
*-commutative67.2%
Simplified67.2%
if -1.5999999999999999e-95 < t < 2.2e14Initial program 92.1%
+-commutative92.1%
associate-*r/93.3%
*-commutative93.3%
fma-def93.3%
Simplified93.3%
Taylor expanded in t around 0 74.4%
+-commutative74.4%
associate-/l*75.8%
Simplified75.8%
if 2.2e14 < t Initial program 56.7%
+-commutative56.7%
associate-*r/81.3%
*-commutative81.3%
fma-def81.3%
Simplified81.3%
Taylor expanded in t around inf 67.3%
*-commutative67.3%
cancel-sign-sub-inv67.3%
metadata-eval67.3%
*-lft-identity67.3%
distribute-lft-in67.3%
mul-1-neg67.3%
distribute-rgt-neg-in67.3%
mul-1-neg67.3%
*-commutative67.3%
cancel-sign-sub67.3%
mul-1-neg67.3%
associate-*r*67.3%
distribute-lft-out--67.3%
associate-*r/67.3%
mul-1-neg67.3%
Simplified81.1%
Taylor expanded in z around inf 71.1%
*-commutative71.1%
associate-/l*79.4%
Simplified79.4%
Taylor expanded in y around 0 66.5%
mul-1-neg66.5%
*-commutative66.5%
associate-*l/72.0%
distribute-rgt-neg-in72.0%
Simplified72.0%
Final simplification71.9%
(FPCore (x y z t a)
:precision binary64
(if (<= t -1.05e-95)
(* y (/ (- z t) (- a t)))
(if (<= t 8200000000.0)
(- x (/ (- x y) (/ a z)))
(+ y (/ (- x y) (/ t z))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -1.05e-95) {
tmp = y * ((z - t) / (a - t));
} else if (t <= 8200000000.0) {
tmp = x - ((x - y) / (a / z));
} else {
tmp = y + ((x - y) / (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 (t <= (-1.05d-95)) then
tmp = y * ((z - t) / (a - t))
else if (t <= 8200000000.0d0) then
tmp = x - ((x - y) / (a / z))
else
tmp = y + ((x - y) / (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 (t <= -1.05e-95) {
tmp = y * ((z - t) / (a - t));
} else if (t <= 8200000000.0) {
tmp = x - ((x - y) / (a / z));
} else {
tmp = y + ((x - y) / (t / z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -1.05e-95: tmp = y * ((z - t) / (a - t)) elif t <= 8200000000.0: tmp = x - ((x - y) / (a / z)) else: tmp = y + ((x - y) / (t / z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -1.05e-95) tmp = Float64(y * Float64(Float64(z - t) / Float64(a - t))); elseif (t <= 8200000000.0) tmp = Float64(x - Float64(Float64(x - y) / Float64(a / z))); else tmp = Float64(y + Float64(Float64(x - y) / Float64(t / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -1.05e-95) tmp = y * ((z - t) / (a - t)); elseif (t <= 8200000000.0) tmp = x - ((x - y) / (a / z)); else tmp = y + ((x - y) / (t / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -1.05e-95], N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8200000000.0], N[(x - N[(N[(x - y), $MachinePrecision] / N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y + N[(N[(x - y), $MachinePrecision] / N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.05 \cdot 10^{-95}:\\
\;\;\;\;y \cdot \frac{z - t}{a - t}\\
\mathbf{elif}\;t \leq 8200000000:\\
\;\;\;\;x - \frac{x - y}{\frac{a}{z}}\\
\mathbf{else}:\\
\;\;\;\;y + \frac{x - y}{\frac{t}{z}}\\
\end{array}
\end{array}
if t < -1.05e-95Initial program 63.4%
+-commutative63.4%
associate-*r/79.9%
*-commutative79.9%
fma-def79.9%
Simplified79.9%
Taylor expanded in y around inf 67.2%
div-sub67.2%
*-commutative67.2%
Simplified67.2%
if -1.05e-95 < t < 8.2e9Initial program 92.1%
+-commutative92.1%
associate-*r/93.3%
*-commutative93.3%
fma-def93.3%
Simplified93.3%
Taylor expanded in t around 0 74.4%
+-commutative74.4%
associate-/l*75.8%
Simplified75.8%
if 8.2e9 < t Initial program 56.7%
+-commutative56.7%
associate-*r/81.3%
*-commutative81.3%
fma-def81.3%
Simplified81.3%
Taylor expanded in t around inf 67.3%
*-commutative67.3%
cancel-sign-sub-inv67.3%
metadata-eval67.3%
*-lft-identity67.3%
distribute-lft-in67.3%
mul-1-neg67.3%
distribute-rgt-neg-in67.3%
mul-1-neg67.3%
*-commutative67.3%
cancel-sign-sub67.3%
mul-1-neg67.3%
associate-*r*67.3%
distribute-lft-out--67.3%
associate-*r/67.3%
mul-1-neg67.3%
Simplified81.1%
Taylor expanded in z around inf 71.1%
*-commutative71.1%
associate-/l*79.4%
Simplified79.4%
Final simplification73.9%
(FPCore (x y z t a)
:precision binary64
(if (<= t -2.9e-95)
y
(if (<= t 1.15e-202)
x
(if (<= t 1.65e-97) (* y (/ z a)) (if (<= t 3.45e+105) x y)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -2.9e-95) {
tmp = y;
} else if (t <= 1.15e-202) {
tmp = x;
} else if (t <= 1.65e-97) {
tmp = y * (z / a);
} else if (t <= 3.45e+105) {
tmp = x;
} else {
tmp = y;
}
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 (t <= (-2.9d-95)) then
tmp = y
else if (t <= 1.15d-202) then
tmp = x
else if (t <= 1.65d-97) then
tmp = y * (z / a)
else if (t <= 3.45d+105) then
tmp = x
else
tmp = y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -2.9e-95) {
tmp = y;
} else if (t <= 1.15e-202) {
tmp = x;
} else if (t <= 1.65e-97) {
tmp = y * (z / a);
} else if (t <= 3.45e+105) {
tmp = x;
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -2.9e-95: tmp = y elif t <= 1.15e-202: tmp = x elif t <= 1.65e-97: tmp = y * (z / a) elif t <= 3.45e+105: tmp = x else: tmp = y return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -2.9e-95) tmp = y; elseif (t <= 1.15e-202) tmp = x; elseif (t <= 1.65e-97) tmp = Float64(y * Float64(z / a)); elseif (t <= 3.45e+105) tmp = x; else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -2.9e-95) tmp = y; elseif (t <= 1.15e-202) tmp = x; elseif (t <= 1.65e-97) tmp = y * (z / a); elseif (t <= 3.45e+105) tmp = x; else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -2.9e-95], y, If[LessEqual[t, 1.15e-202], x, If[LessEqual[t, 1.65e-97], N[(y * N[(z / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.45e+105], x, y]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -2.9 \cdot 10^{-95}:\\
\;\;\;\;y\\
\mathbf{elif}\;t \leq 1.15 \cdot 10^{-202}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 1.65 \cdot 10^{-97}:\\
\;\;\;\;y \cdot \frac{z}{a}\\
\mathbf{elif}\;t \leq 3.45 \cdot 10^{+105}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -2.90000000000000002e-95 or 3.45000000000000018e105 < t Initial program 58.9%
+-commutative58.9%
associate-*r/79.4%
*-commutative79.4%
fma-def79.5%
Simplified79.5%
Taylor expanded in t around inf 47.3%
if -2.90000000000000002e-95 < t < 1.1499999999999999e-202 or 1.6500000000000001e-97 < t < 3.45000000000000018e105Initial program 88.2%
+-commutative88.2%
associate-*r/91.6%
*-commutative91.6%
fma-def91.6%
Simplified91.6%
Taylor expanded in a around inf 42.5%
if 1.1499999999999999e-202 < t < 1.6500000000000001e-97Initial program 87.6%
+-commutative87.6%
associate-*r/94.9%
*-commutative94.9%
fma-def94.9%
Simplified94.9%
Taylor expanded in y around inf 68.7%
div-sub68.7%
*-commutative68.7%
Simplified68.7%
Taylor expanded in t around 0 56.9%
Final simplification46.1%
(FPCore (x y z t a)
:precision binary64
(if (<= t -2.8e-95)
y
(if (<= t 2.7e-248)
x
(if (<= t 6.5e-93) (* z (/ y a)) (if (<= t 1.08e+108) x y)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -2.8e-95) {
tmp = y;
} else if (t <= 2.7e-248) {
tmp = x;
} else if (t <= 6.5e-93) {
tmp = z * (y / a);
} else if (t <= 1.08e+108) {
tmp = x;
} else {
tmp = y;
}
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 (t <= (-2.8d-95)) then
tmp = y
else if (t <= 2.7d-248) then
tmp = x
else if (t <= 6.5d-93) then
tmp = z * (y / a)
else if (t <= 1.08d+108) then
tmp = x
else
tmp = y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -2.8e-95) {
tmp = y;
} else if (t <= 2.7e-248) {
tmp = x;
} else if (t <= 6.5e-93) {
tmp = z * (y / a);
} else if (t <= 1.08e+108) {
tmp = x;
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -2.8e-95: tmp = y elif t <= 2.7e-248: tmp = x elif t <= 6.5e-93: tmp = z * (y / a) elif t <= 1.08e+108: tmp = x else: tmp = y return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -2.8e-95) tmp = y; elseif (t <= 2.7e-248) tmp = x; elseif (t <= 6.5e-93) tmp = Float64(z * Float64(y / a)); elseif (t <= 1.08e+108) tmp = x; else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -2.8e-95) tmp = y; elseif (t <= 2.7e-248) tmp = x; elseif (t <= 6.5e-93) tmp = z * (y / a); elseif (t <= 1.08e+108) tmp = x; else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -2.8e-95], y, If[LessEqual[t, 2.7e-248], x, If[LessEqual[t, 6.5e-93], N[(z * N[(y / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.08e+108], x, y]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -2.8 \cdot 10^{-95}:\\
\;\;\;\;y\\
\mathbf{elif}\;t \leq 2.7 \cdot 10^{-248}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 6.5 \cdot 10^{-93}:\\
\;\;\;\;z \cdot \frac{y}{a}\\
\mathbf{elif}\;t \leq 1.08 \cdot 10^{+108}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -2.7999999999999999e-95 or 1.0800000000000001e108 < t Initial program 58.9%
+-commutative58.9%
associate-*r/79.4%
*-commutative79.4%
fma-def79.5%
Simplified79.5%
Taylor expanded in t around inf 47.3%
if -2.7999999999999999e-95 < t < 2.7000000000000001e-248 or 6.5e-93 < t < 1.0800000000000001e108Initial program 87.3%
+-commutative87.3%
associate-*r/94.0%
*-commutative94.0%
fma-def94.0%
Simplified94.0%
Taylor expanded in a around inf 43.8%
if 2.7000000000000001e-248 < t < 6.5e-93Initial program 91.2%
+-commutative91.2%
associate-*r/85.4%
*-commutative85.4%
fma-def85.4%
Simplified85.4%
Taylor expanded in y around inf 56.1%
div-sub56.1%
*-commutative56.1%
Simplified56.1%
Taylor expanded in t around 0 47.7%
Taylor expanded in y around 0 45.0%
associate-*l/48.5%
Simplified48.5%
Final simplification46.1%
(FPCore (x y z t a)
:precision binary64
(if (<= t -2.9e-95)
y
(if (<= t 1.55e-247)
x
(if (<= t 3.3e-101) (/ z (/ a y)) (if (<= t 8.5e+105) x y)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -2.9e-95) {
tmp = y;
} else if (t <= 1.55e-247) {
tmp = x;
} else if (t <= 3.3e-101) {
tmp = z / (a / y);
} else if (t <= 8.5e+105) {
tmp = x;
} else {
tmp = y;
}
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 (t <= (-2.9d-95)) then
tmp = y
else if (t <= 1.55d-247) then
tmp = x
else if (t <= 3.3d-101) then
tmp = z / (a / y)
else if (t <= 8.5d+105) then
tmp = x
else
tmp = y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -2.9e-95) {
tmp = y;
} else if (t <= 1.55e-247) {
tmp = x;
} else if (t <= 3.3e-101) {
tmp = z / (a / y);
} else if (t <= 8.5e+105) {
tmp = x;
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -2.9e-95: tmp = y elif t <= 1.55e-247: tmp = x elif t <= 3.3e-101: tmp = z / (a / y) elif t <= 8.5e+105: tmp = x else: tmp = y return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -2.9e-95) tmp = y; elseif (t <= 1.55e-247) tmp = x; elseif (t <= 3.3e-101) tmp = Float64(z / Float64(a / y)); elseif (t <= 8.5e+105) tmp = x; else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -2.9e-95) tmp = y; elseif (t <= 1.55e-247) tmp = x; elseif (t <= 3.3e-101) tmp = z / (a / y); elseif (t <= 8.5e+105) tmp = x; else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -2.9e-95], y, If[LessEqual[t, 1.55e-247], x, If[LessEqual[t, 3.3e-101], N[(z / N[(a / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8.5e+105], x, y]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -2.9 \cdot 10^{-95}:\\
\;\;\;\;y\\
\mathbf{elif}\;t \leq 1.55 \cdot 10^{-247}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 3.3 \cdot 10^{-101}:\\
\;\;\;\;\frac{z}{\frac{a}{y}}\\
\mathbf{elif}\;t \leq 8.5 \cdot 10^{+105}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -2.90000000000000002e-95 or 8.49999999999999986e105 < t Initial program 58.9%
+-commutative58.9%
associate-*r/79.4%
*-commutative79.4%
fma-def79.5%
Simplified79.5%
Taylor expanded in t around inf 47.3%
if -2.90000000000000002e-95 < t < 1.55000000000000008e-247 or 3.29999999999999984e-101 < t < 8.49999999999999986e105Initial program 87.3%
+-commutative87.3%
associate-*r/94.0%
*-commutative94.0%
fma-def94.0%
Simplified94.0%
Taylor expanded in a around inf 43.8%
if 1.55000000000000008e-247 < t < 3.29999999999999984e-101Initial program 91.2%
+-commutative91.2%
associate-*r/85.4%
*-commutative85.4%
fma-def85.4%
Simplified85.4%
Taylor expanded in z around inf 62.6%
div-sub70.0%
*-commutative70.0%
associate-*l/69.9%
associate-/l*59.6%
Simplified59.6%
Taylor expanded in a around inf 49.8%
associate-/l*53.9%
Simplified53.9%
Taylor expanded in y around inf 49.0%
Final simplification46.2%
(FPCore (x y z t a) :precision binary64 (if (<= t -2.9e-95) y (if (<= t 2.8e+105) x y)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -2.9e-95) {
tmp = y;
} else if (t <= 2.8e+105) {
tmp = x;
} else {
tmp = y;
}
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 (t <= (-2.9d-95)) then
tmp = y
else if (t <= 2.8d+105) then
tmp = x
else
tmp = y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -2.9e-95) {
tmp = y;
} else if (t <= 2.8e+105) {
tmp = x;
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -2.9e-95: tmp = y elif t <= 2.8e+105: tmp = x else: tmp = y return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -2.9e-95) tmp = y; elseif (t <= 2.8e+105) tmp = x; else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -2.9e-95) tmp = y; elseif (t <= 2.8e+105) tmp = x; else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -2.9e-95], y, If[LessEqual[t, 2.8e+105], x, y]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -2.9 \cdot 10^{-95}:\\
\;\;\;\;y\\
\mathbf{elif}\;t \leq 2.8 \cdot 10^{+105}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -2.90000000000000002e-95 or 2.8000000000000001e105 < t Initial program 58.9%
+-commutative58.9%
associate-*r/79.4%
*-commutative79.4%
fma-def79.5%
Simplified79.5%
Taylor expanded in t around inf 47.3%
if -2.90000000000000002e-95 < t < 2.8000000000000001e105Initial program 88.1%
+-commutative88.1%
associate-*r/92.1%
*-commutative92.1%
fma-def92.1%
Simplified92.1%
Taylor expanded in a around inf 38.2%
Final simplification42.9%
(FPCore (x y z t a) :precision binary64 x)
double code(double x, double y, double z, double t, double a) {
return x;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = x
end function
public static double code(double x, double y, double z, double t, double a) {
return x;
}
def code(x, y, z, t, a): return x
function code(x, y, z, t, a) return x end
function tmp = code(x, y, z, t, a) tmp = x; end
code[x_, y_, z_, t_, a_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 73.0%
+-commutative73.0%
associate-*r/85.6%
*-commutative85.6%
fma-def85.6%
Simplified85.6%
Taylor expanded in a around inf 25.2%
Final simplification25.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* (/ (- y x) 1.0) (/ (- z t) (- a t))))))
(if (< a -1.6153062845442575e-142)
t_1
(if (< a 3.774403170083174e-182) (- y (* (/ z t) (- y x))) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (((y - x) / 1.0) * ((z - t) / (a - t)));
double tmp;
if (a < -1.6153062845442575e-142) {
tmp = t_1;
} else if (a < 3.774403170083174e-182) {
tmp = y - ((z / t) * (y - 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 = x + (((y - x) / 1.0d0) * ((z - t) / (a - t)))
if (a < (-1.6153062845442575d-142)) then
tmp = t_1
else if (a < 3.774403170083174d-182) then
tmp = y - ((z / t) * (y - 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 = x + (((y - x) / 1.0) * ((z - t) / (a - t)));
double tmp;
if (a < -1.6153062845442575e-142) {
tmp = t_1;
} else if (a < 3.774403170083174e-182) {
tmp = y - ((z / t) * (y - x));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (((y - x) / 1.0) * ((z - t) / (a - t))) tmp = 0 if a < -1.6153062845442575e-142: tmp = t_1 elif a < 3.774403170083174e-182: tmp = y - ((z / t) * (y - x)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(Float64(y - x) / 1.0) * Float64(Float64(z - t) / Float64(a - t)))) tmp = 0.0 if (a < -1.6153062845442575e-142) tmp = t_1; elseif (a < 3.774403170083174e-182) tmp = Float64(y - Float64(Float64(z / t) * Float64(y - x))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (((y - x) / 1.0) * ((z - t) / (a - t))); tmp = 0.0; if (a < -1.6153062845442575e-142) tmp = t_1; elseif (a < 3.774403170083174e-182) tmp = y - ((z / t) * (y - x)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(N[(y - x), $MachinePrecision] / 1.0), $MachinePrecision] * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[a, -1.6153062845442575e-142], t$95$1, If[Less[a, 3.774403170083174e-182], N[(y - N[(N[(z / t), $MachinePrecision] * N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{y - x}{1} \cdot \frac{z - t}{a - t}\\
\mathbf{if}\;a < -1.6153062845442575 \cdot 10^{-142}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a < 3.774403170083174 \cdot 10^{-182}:\\
\;\;\;\;y - \frac{z}{t} \cdot \left(y - x\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
herbie shell --seed 2023176
(FPCore (x y z t a)
:name "Graphics.Rendering.Chart.Axis.Types:linMap from Chart-1.5.3"
:precision binary64
:herbie-target
(if (< a -1.6153062845442575e-142) (+ x (* (/ (- y x) 1.0) (/ (- z t) (- a t)))) (if (< a 3.774403170083174e-182) (- y (* (/ z t) (- y x))) (+ x (* (/ (- y x) 1.0) (/ (- z t) (- a t))))))
(+ x (/ (* (- y x) (- z t)) (- a t))))