
(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 27 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 -1e-278)
(- x (/ (- x y) (/ (- a t) (- z t))))
(if (<= t_1 0.0)
(+ y (/ (* (- y x) (- a z)) t))
(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 <= -1e-278) {
tmp = x - ((x - y) / ((a - t) / (z - t)));
} else if (t_1 <= 0.0) {
tmp = y + (((y - x) * (a - z)) / t);
} 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 <= -1e-278) tmp = Float64(x - Float64(Float64(x - y) / Float64(Float64(a - t) / Float64(z - t)))); elseif (t_1 <= 0.0) tmp = Float64(y + Float64(Float64(Float64(y - x) * Float64(a - z)) / t)); 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, -1e-278], N[(x - N[(N[(x - y), $MachinePrecision] / N[(N[(a - t), $MachinePrecision] / N[(z - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 0.0], N[(y + N[(N[(N[(y - x), $MachinePrecision] * N[(a - z), $MachinePrecision]), $MachinePrecision] / t), $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 -1 \cdot 10^{-278}:\\
\;\;\;\;x - \frac{x - y}{\frac{a - t}{z - t}}\\
\mathbf{elif}\;t_1 \leq 0:\\
\;\;\;\;y + \frac{\left(y - x\right) \cdot \left(a - z\right)}{t}\\
\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))) < -9.99999999999999938e-279Initial program 72.1%
associate-/l*89.7%
Simplified89.7%
if -9.99999999999999938e-279 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < 0.0Initial program 3.6%
associate-/l*3.6%
Simplified3.6%
Taylor expanded in t around -inf 99.7%
mul-1-neg99.7%
unsub-neg99.7%
div-sub99.7%
*-commutative99.7%
div-sub99.7%
distribute-rgt-out--99.7%
Simplified99.7%
if 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) Initial program 77.5%
+-commutative77.5%
associate-*r/96.2%
*-commutative96.2%
fma-def96.2%
Simplified96.2%
Final simplification93.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- x (/ (* (- y x) (- t z)) (- a t)))))
(if (<= t_1 (- INFINITY))
(* z (/ (- y x) (- a t)))
(if (<= t_1 -1e-278)
t_1
(if (<= t_1 0.0)
(+ y (/ (* (- y x) (- a z)) t))
(if (<= t_1 2e+289) t_1 (+ y (* (- y x) (/ (- a z) t)))))))))
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 = z * ((y - x) / (a - t));
} else if (t_1 <= -1e-278) {
tmp = t_1;
} else if (t_1 <= 0.0) {
tmp = y + (((y - x) * (a - z)) / t);
} else if (t_1 <= 2e+289) {
tmp = t_1;
} else {
tmp = y + ((y - x) * ((a - z) / t));
}
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) {
tmp = z * ((y - x) / (a - t));
} else if (t_1 <= -1e-278) {
tmp = t_1;
} else if (t_1 <= 0.0) {
tmp = y + (((y - x) * (a - z)) / t);
} else if (t_1 <= 2e+289) {
tmp = t_1;
} else {
tmp = y + ((y - x) * ((a - z) / t));
}
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: tmp = z * ((y - x) / (a - t)) elif t_1 <= -1e-278: tmp = t_1 elif t_1 <= 0.0: tmp = y + (((y - x) * (a - z)) / t) elif t_1 <= 2e+289: tmp = t_1 else: tmp = y + ((y - x) * ((a - z) / t)) 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(z * Float64(Float64(y - x) / Float64(a - t))); elseif (t_1 <= -1e-278) tmp = t_1; elseif (t_1 <= 0.0) tmp = Float64(y + Float64(Float64(Float64(y - x) * Float64(a - z)) / t)); elseif (t_1 <= 2e+289) tmp = t_1; else tmp = Float64(y + Float64(Float64(y - x) * Float64(Float64(a - z) / t))); 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) tmp = z * ((y - x) / (a - t)); elseif (t_1 <= -1e-278) tmp = t_1; elseif (t_1 <= 0.0) tmp = y + (((y - x) * (a - z)) / t); elseif (t_1 <= 2e+289) tmp = t_1; else tmp = y + ((y - x) * ((a - z) / t)); 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[LessEqual[t$95$1, (-Infinity)], N[(z * N[(N[(y - x), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -1e-278], t$95$1, If[LessEqual[t$95$1, 0.0], N[(y + N[(N[(N[(y - x), $MachinePrecision] * N[(a - z), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 2e+289], t$95$1, N[(y + N[(N[(y - x), $MachinePrecision] * N[(N[(a - z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $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:\\
\;\;\;\;z \cdot \frac{y - x}{a - t}\\
\mathbf{elif}\;t_1 \leq -1 \cdot 10^{-278}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t_1 \leq 0:\\
\;\;\;\;y + \frac{\left(y - x\right) \cdot \left(a - z\right)}{t}\\
\mathbf{elif}\;t_1 \leq 2 \cdot 10^{+289}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y + \left(y - x\right) \cdot \frac{a - z}{t}\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < -inf.0Initial program 43.0%
associate-/l*81.1%
Simplified81.1%
Taylor expanded in z around inf 68.8%
div-sub70.6%
Simplified70.6%
if -inf.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < -9.99999999999999938e-279 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < 2.0000000000000001e289Initial program 97.8%
if -9.99999999999999938e-279 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < 0.0Initial program 3.6%
associate-/l*3.6%
Simplified3.6%
Taylor expanded in t around -inf 99.7%
mul-1-neg99.7%
unsub-neg99.7%
div-sub99.7%
*-commutative99.7%
div-sub99.7%
distribute-rgt-out--99.7%
Simplified99.7%
if 2.0000000000000001e289 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) Initial program 41.5%
associate-/l*90.8%
Simplified90.8%
div-inv90.7%
Applied egg-rr90.7%
Taylor expanded in t around inf 48.3%
+-commutative48.3%
*-commutative48.3%
associate--l+48.3%
associate-*r/48.3%
associate-*r/48.3%
div-sub50.7%
distribute-lft-out--50.7%
*-commutative50.7%
distribute-rgt-out--51.5%
associate-*r/51.5%
+-commutative51.5%
fma-def51.5%
associate-/l*70.2%
Simplified70.2%
Final simplification87.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- x (/ (* (- y x) (- t z)) (- a t)))))
(if (or (<= t_1 -1e-278) (not (<= t_1 0.0)))
(- x (/ (- x y) (/ (- a t) (- z t))))
(+ y (/ (* (- y x) (- a z)) t)))))
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 <= -1e-278) || !(t_1 <= 0.0)) {
tmp = x - ((x - y) / ((a - t) / (z - t)));
} else {
tmp = y + (((y - x) * (a - z)) / t);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x - (((y - x) * (t - z)) / (a - t))
if ((t_1 <= (-1d-278)) .or. (.not. (t_1 <= 0.0d0))) then
tmp = x - ((x - y) / ((a - t) / (z - t)))
else
tmp = y + (((y - x) * (a - z)) / t)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x - (((y - x) * (t - z)) / (a - t));
double tmp;
if ((t_1 <= -1e-278) || !(t_1 <= 0.0)) {
tmp = x - ((x - y) / ((a - t) / (z - t)));
} else {
tmp = y + (((y - x) * (a - z)) / t);
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x - (((y - x) * (t - z)) / (a - t)) tmp = 0 if (t_1 <= -1e-278) or not (t_1 <= 0.0): tmp = x - ((x - y) / ((a - t) / (z - t))) else: tmp = y + (((y - x) * (a - z)) / t) 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 <= -1e-278) || !(t_1 <= 0.0)) tmp = Float64(x - Float64(Float64(x - y) / Float64(Float64(a - t) / Float64(z - t)))); else tmp = Float64(y + Float64(Float64(Float64(y - x) * Float64(a - z)) / t)); 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 <= -1e-278) || ~((t_1 <= 0.0))) tmp = x - ((x - y) / ((a - t) / (z - t))); else tmp = y + (((y - x) * (a - z)) / t); 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, -1e-278], N[Not[LessEqual[t$95$1, 0.0]], $MachinePrecision]], N[(x - N[(N[(x - y), $MachinePrecision] / N[(N[(a - t), $MachinePrecision] / N[(z - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y + N[(N[(N[(y - x), $MachinePrecision] * N[(a - z), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $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 -1 \cdot 10^{-278} \lor \neg \left(t_1 \leq 0\right):\\
\;\;\;\;x - \frac{x - y}{\frac{a - t}{z - t}}\\
\mathbf{else}:\\
\;\;\;\;y + \frac{\left(y - x\right) \cdot \left(a - z\right)}{t}\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < -9.99999999999999938e-279 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) Initial program 74.7%
associate-/l*92.9%
Simplified92.9%
if -9.99999999999999938e-279 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < 0.0Initial program 3.6%
associate-/l*3.6%
Simplified3.6%
Taylor expanded in t around -inf 99.7%
mul-1-neg99.7%
unsub-neg99.7%
div-sub99.7%
*-commutative99.7%
div-sub99.7%
distribute-rgt-out--99.7%
Simplified99.7%
Final simplification93.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (/ (- z t) (- a t)))) (t_2 (+ y (* x (/ z t)))))
(if (<= t -5.6e+73)
t_1
(if (<= t -9.6e+42)
(- x (/ z (/ a x)))
(if (<= t -1e-17)
t_1
(if (<= t 1.14e-125)
(+ x (/ z (/ a (- y x))))
(if (<= t 2.55e-17)
(* z (/ (- y x) (- a t)))
(if (<= t 1.26e+41)
(- x (* t (/ y a)))
(if (<= t 1.15e+66)
t_2
(if (<= t 6.7e+100)
(+ x y)
(if (<= t 1.4e+172) t_1 t_2)))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((z - t) / (a - t));
double t_2 = y + (x * (z / t));
double tmp;
if (t <= -5.6e+73) {
tmp = t_1;
} else if (t <= -9.6e+42) {
tmp = x - (z / (a / x));
} else if (t <= -1e-17) {
tmp = t_1;
} else if (t <= 1.14e-125) {
tmp = x + (z / (a / (y - x)));
} else if (t <= 2.55e-17) {
tmp = z * ((y - x) / (a - t));
} else if (t <= 1.26e+41) {
tmp = x - (t * (y / a));
} else if (t <= 1.15e+66) {
tmp = t_2;
} else if (t <= 6.7e+100) {
tmp = x + y;
} else if (t <= 1.4e+172) {
tmp = t_1;
} 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 * ((z - t) / (a - t))
t_2 = y + (x * (z / t))
if (t <= (-5.6d+73)) then
tmp = t_1
else if (t <= (-9.6d+42)) then
tmp = x - (z / (a / x))
else if (t <= (-1d-17)) then
tmp = t_1
else if (t <= 1.14d-125) then
tmp = x + (z / (a / (y - x)))
else if (t <= 2.55d-17) then
tmp = z * ((y - x) / (a - t))
else if (t <= 1.26d+41) then
tmp = x - (t * (y / a))
else if (t <= 1.15d+66) then
tmp = t_2
else if (t <= 6.7d+100) then
tmp = x + y
else if (t <= 1.4d+172) then
tmp = t_1
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 * ((z - t) / (a - t));
double t_2 = y + (x * (z / t));
double tmp;
if (t <= -5.6e+73) {
tmp = t_1;
} else if (t <= -9.6e+42) {
tmp = x - (z / (a / x));
} else if (t <= -1e-17) {
tmp = t_1;
} else if (t <= 1.14e-125) {
tmp = x + (z / (a / (y - x)));
} else if (t <= 2.55e-17) {
tmp = z * ((y - x) / (a - t));
} else if (t <= 1.26e+41) {
tmp = x - (t * (y / a));
} else if (t <= 1.15e+66) {
tmp = t_2;
} else if (t <= 6.7e+100) {
tmp = x + y;
} else if (t <= 1.4e+172) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * ((z - t) / (a - t)) t_2 = y + (x * (z / t)) tmp = 0 if t <= -5.6e+73: tmp = t_1 elif t <= -9.6e+42: tmp = x - (z / (a / x)) elif t <= -1e-17: tmp = t_1 elif t <= 1.14e-125: tmp = x + (z / (a / (y - x))) elif t <= 2.55e-17: tmp = z * ((y - x) / (a - t)) elif t <= 1.26e+41: tmp = x - (t * (y / a)) elif t <= 1.15e+66: tmp = t_2 elif t <= 6.7e+100: tmp = x + y elif t <= 1.4e+172: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(Float64(z - t) / Float64(a - t))) t_2 = Float64(y + Float64(x * Float64(z / t))) tmp = 0.0 if (t <= -5.6e+73) tmp = t_1; elseif (t <= -9.6e+42) tmp = Float64(x - Float64(z / Float64(a / x))); elseif (t <= -1e-17) tmp = t_1; elseif (t <= 1.14e-125) tmp = Float64(x + Float64(z / Float64(a / Float64(y - x)))); elseif (t <= 2.55e-17) tmp = Float64(z * Float64(Float64(y - x) / Float64(a - t))); elseif (t <= 1.26e+41) tmp = Float64(x - Float64(t * Float64(y / a))); elseif (t <= 1.15e+66) tmp = t_2; elseif (t <= 6.7e+100) tmp = Float64(x + y); elseif (t <= 1.4e+172) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * ((z - t) / (a - t)); t_2 = y + (x * (z / t)); tmp = 0.0; if (t <= -5.6e+73) tmp = t_1; elseif (t <= -9.6e+42) tmp = x - (z / (a / x)); elseif (t <= -1e-17) tmp = t_1; elseif (t <= 1.14e-125) tmp = x + (z / (a / (y - x))); elseif (t <= 2.55e-17) tmp = z * ((y - x) / (a - t)); elseif (t <= 1.26e+41) tmp = x - (t * (y / a)); elseif (t <= 1.15e+66) tmp = t_2; elseif (t <= 6.7e+100) tmp = x + y; elseif (t <= 1.4e+172) tmp = t_1; else tmp = t_2; 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]}, Block[{t$95$2 = N[(y + N[(x * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -5.6e+73], t$95$1, If[LessEqual[t, -9.6e+42], N[(x - N[(z / N[(a / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1e-17], t$95$1, If[LessEqual[t, 1.14e-125], N[(x + N[(z / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.55e-17], N[(z * N[(N[(y - x), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.26e+41], N[(x - N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.15e+66], t$95$2, If[LessEqual[t, 6.7e+100], N[(x + y), $MachinePrecision], If[LessEqual[t, 1.4e+172], t$95$1, t$95$2]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \frac{z - t}{a - t}\\
t_2 := y + x \cdot \frac{z}{t}\\
\mathbf{if}\;t \leq -5.6 \cdot 10^{+73}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -9.6 \cdot 10^{+42}:\\
\;\;\;\;x - \frac{z}{\frac{a}{x}}\\
\mathbf{elif}\;t \leq -1 \cdot 10^{-17}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 1.14 \cdot 10^{-125}:\\
\;\;\;\;x + \frac{z}{\frac{a}{y - x}}\\
\mathbf{elif}\;t \leq 2.55 \cdot 10^{-17}:\\
\;\;\;\;z \cdot \frac{y - x}{a - t}\\
\mathbf{elif}\;t \leq 1.26 \cdot 10^{+41}:\\
\;\;\;\;x - t \cdot \frac{y}{a}\\
\mathbf{elif}\;t \leq 1.15 \cdot 10^{+66}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 6.7 \cdot 10^{+100}:\\
\;\;\;\;x + y\\
\mathbf{elif}\;t \leq 1.4 \cdot 10^{+172}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -5.60000000000000016e73 or -9.5999999999999994e42 < t < -1.00000000000000007e-17 or 6.6999999999999997e100 < t < 1.4e172Initial program 59.2%
associate-/l*81.6%
Simplified81.6%
Taylor expanded in x around 0 53.0%
associate-*r/72.8%
Simplified72.8%
if -5.60000000000000016e73 < t < -9.5999999999999994e42Initial program 61.8%
associate-/l*99.7%
Simplified99.7%
Taylor expanded in t around 0 61.8%
+-commutative61.8%
*-commutative61.8%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in y around 0 61.8%
+-commutative61.8%
mul-1-neg61.8%
unsub-neg61.8%
associate-/l*100.0%
Simplified100.0%
if -1.00000000000000007e-17 < t < 1.13999999999999996e-125Initial program 84.8%
associate-/l*94.8%
Simplified94.8%
Taylor expanded in t around 0 72.1%
+-commutative72.1%
*-commutative72.1%
associate-/l*79.0%
Simplified79.0%
if 1.13999999999999996e-125 < t < 2.5500000000000001e-17Initial program 91.8%
associate-/l*97.4%
Simplified97.4%
Taylor expanded in z around inf 88.4%
div-sub88.4%
Simplified88.4%
if 2.5500000000000001e-17 < t < 1.26000000000000001e41Initial program 89.4%
*-commutative89.4%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in y around inf 100.0%
Taylor expanded in a around inf 92.7%
Taylor expanded in z around 0 82.2%
mul-1-neg82.2%
*-commutative82.2%
associate-*r/82.0%
distribute-rgt-neg-in82.0%
distribute-neg-frac82.0%
Simplified82.0%
if 1.26000000000000001e41 < t < 1.15e66 or 1.4e172 < t Initial program 38.3%
associate-/l*65.5%
Simplified65.5%
Taylor expanded in t around -inf 65.7%
mul-1-neg65.7%
unsub-neg65.7%
div-sub65.7%
*-commutative65.7%
div-sub65.7%
distribute-rgt-out--65.7%
Simplified65.7%
Taylor expanded in a around 0 68.5%
Taylor expanded in z around 0 68.5%
*-commutative68.5%
associate-*r/86.4%
Simplified86.4%
Taylor expanded in y around 0 66.0%
mul-1-neg66.0%
associate-*l/81.4%
distribute-rgt-neg-out81.4%
Simplified81.4%
if 1.15e66 < t < 6.6999999999999997e100Initial program 84.4%
*-commutative84.4%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in y around inf 100.0%
Taylor expanded in t around inf 86.6%
Final simplification78.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (/ (- z t) (- a t)))) (t_2 (+ y (* x (/ z t)))))
(if (<= t -1.7e+73)
t_1
(if (<= t -2.1e+42)
(- x (/ z (/ a x)))
(if (<= t -1.28e-17)
t_1
(if (<= t 1.06e-125)
(+ x (/ (- y x) (/ a z)))
(if (<= t 3.5e-17)
(* z (/ (- y x) (- a t)))
(if (<= t 7.5e+32)
(- x (* t (/ y a)))
(if (<= t 1.2e+67)
t_2
(if (<= t 1.65e+101)
(+ x y)
(if (<= t 1.35e+172) t_1 t_2)))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((z - t) / (a - t));
double t_2 = y + (x * (z / t));
double tmp;
if (t <= -1.7e+73) {
tmp = t_1;
} else if (t <= -2.1e+42) {
tmp = x - (z / (a / x));
} else if (t <= -1.28e-17) {
tmp = t_1;
} else if (t <= 1.06e-125) {
tmp = x + ((y - x) / (a / z));
} else if (t <= 3.5e-17) {
tmp = z * ((y - x) / (a - t));
} else if (t <= 7.5e+32) {
tmp = x - (t * (y / a));
} else if (t <= 1.2e+67) {
tmp = t_2;
} else if (t <= 1.65e+101) {
tmp = x + y;
} else if (t <= 1.35e+172) {
tmp = t_1;
} 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 * ((z - t) / (a - t))
t_2 = y + (x * (z / t))
if (t <= (-1.7d+73)) then
tmp = t_1
else if (t <= (-2.1d+42)) then
tmp = x - (z / (a / x))
else if (t <= (-1.28d-17)) then
tmp = t_1
else if (t <= 1.06d-125) then
tmp = x + ((y - x) / (a / z))
else if (t <= 3.5d-17) then
tmp = z * ((y - x) / (a - t))
else if (t <= 7.5d+32) then
tmp = x - (t * (y / a))
else if (t <= 1.2d+67) then
tmp = t_2
else if (t <= 1.65d+101) then
tmp = x + y
else if (t <= 1.35d+172) then
tmp = t_1
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 * ((z - t) / (a - t));
double t_2 = y + (x * (z / t));
double tmp;
if (t <= -1.7e+73) {
tmp = t_1;
} else if (t <= -2.1e+42) {
tmp = x - (z / (a / x));
} else if (t <= -1.28e-17) {
tmp = t_1;
} else if (t <= 1.06e-125) {
tmp = x + ((y - x) / (a / z));
} else if (t <= 3.5e-17) {
tmp = z * ((y - x) / (a - t));
} else if (t <= 7.5e+32) {
tmp = x - (t * (y / a));
} else if (t <= 1.2e+67) {
tmp = t_2;
} else if (t <= 1.65e+101) {
tmp = x + y;
} else if (t <= 1.35e+172) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * ((z - t) / (a - t)) t_2 = y + (x * (z / t)) tmp = 0 if t <= -1.7e+73: tmp = t_1 elif t <= -2.1e+42: tmp = x - (z / (a / x)) elif t <= -1.28e-17: tmp = t_1 elif t <= 1.06e-125: tmp = x + ((y - x) / (a / z)) elif t <= 3.5e-17: tmp = z * ((y - x) / (a - t)) elif t <= 7.5e+32: tmp = x - (t * (y / a)) elif t <= 1.2e+67: tmp = t_2 elif t <= 1.65e+101: tmp = x + y elif t <= 1.35e+172: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(Float64(z - t) / Float64(a - t))) t_2 = Float64(y + Float64(x * Float64(z / t))) tmp = 0.0 if (t <= -1.7e+73) tmp = t_1; elseif (t <= -2.1e+42) tmp = Float64(x - Float64(z / Float64(a / x))); elseif (t <= -1.28e-17) tmp = t_1; elseif (t <= 1.06e-125) tmp = Float64(x + Float64(Float64(y - x) / Float64(a / z))); elseif (t <= 3.5e-17) tmp = Float64(z * Float64(Float64(y - x) / Float64(a - t))); elseif (t <= 7.5e+32) tmp = Float64(x - Float64(t * Float64(y / a))); elseif (t <= 1.2e+67) tmp = t_2; elseif (t <= 1.65e+101) tmp = Float64(x + y); elseif (t <= 1.35e+172) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * ((z - t) / (a - t)); t_2 = y + (x * (z / t)); tmp = 0.0; if (t <= -1.7e+73) tmp = t_1; elseif (t <= -2.1e+42) tmp = x - (z / (a / x)); elseif (t <= -1.28e-17) tmp = t_1; elseif (t <= 1.06e-125) tmp = x + ((y - x) / (a / z)); elseif (t <= 3.5e-17) tmp = z * ((y - x) / (a - t)); elseif (t <= 7.5e+32) tmp = x - (t * (y / a)); elseif (t <= 1.2e+67) tmp = t_2; elseif (t <= 1.65e+101) tmp = x + y; elseif (t <= 1.35e+172) tmp = t_1; else tmp = t_2; 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]}, Block[{t$95$2 = N[(y + N[(x * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.7e+73], t$95$1, If[LessEqual[t, -2.1e+42], N[(x - N[(z / N[(a / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.28e-17], t$95$1, If[LessEqual[t, 1.06e-125], N[(x + N[(N[(y - x), $MachinePrecision] / N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.5e-17], N[(z * N[(N[(y - x), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 7.5e+32], N[(x - N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.2e+67], t$95$2, If[LessEqual[t, 1.65e+101], N[(x + y), $MachinePrecision], If[LessEqual[t, 1.35e+172], t$95$1, t$95$2]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \frac{z - t}{a - t}\\
t_2 := y + x \cdot \frac{z}{t}\\
\mathbf{if}\;t \leq -1.7 \cdot 10^{+73}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -2.1 \cdot 10^{+42}:\\
\;\;\;\;x - \frac{z}{\frac{a}{x}}\\
\mathbf{elif}\;t \leq -1.28 \cdot 10^{-17}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 1.06 \cdot 10^{-125}:\\
\;\;\;\;x + \frac{y - x}{\frac{a}{z}}\\
\mathbf{elif}\;t \leq 3.5 \cdot 10^{-17}:\\
\;\;\;\;z \cdot \frac{y - x}{a - t}\\
\mathbf{elif}\;t \leq 7.5 \cdot 10^{+32}:\\
\;\;\;\;x - t \cdot \frac{y}{a}\\
\mathbf{elif}\;t \leq 1.2 \cdot 10^{+67}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 1.65 \cdot 10^{+101}:\\
\;\;\;\;x + y\\
\mathbf{elif}\;t \leq 1.35 \cdot 10^{+172}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -1.7000000000000001e73 or -2.09999999999999995e42 < t < -1.28e-17 or 1.65000000000000006e101 < t < 1.35e172Initial program 59.2%
associate-/l*81.6%
Simplified81.6%
Taylor expanded in x around 0 53.0%
associate-*r/72.8%
Simplified72.8%
if -1.7000000000000001e73 < t < -2.09999999999999995e42Initial program 61.8%
associate-/l*99.7%
Simplified99.7%
Taylor expanded in t around 0 61.8%
+-commutative61.8%
*-commutative61.8%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in y around 0 61.8%
+-commutative61.8%
mul-1-neg61.8%
unsub-neg61.8%
associate-/l*100.0%
Simplified100.0%
if -1.28e-17 < t < 1.05999999999999999e-125Initial program 84.8%
associate-/l*94.8%
Simplified94.8%
Taylor expanded in t around 0 80.5%
if 1.05999999999999999e-125 < t < 3.5000000000000002e-17Initial program 91.8%
associate-/l*97.4%
Simplified97.4%
Taylor expanded in z around inf 88.4%
div-sub88.4%
Simplified88.4%
if 3.5000000000000002e-17 < t < 7.49999999999999959e32Initial program 89.4%
*-commutative89.4%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in y around inf 100.0%
Taylor expanded in a around inf 92.7%
Taylor expanded in z around 0 82.2%
mul-1-neg82.2%
*-commutative82.2%
associate-*r/82.0%
distribute-rgt-neg-in82.0%
distribute-neg-frac82.0%
Simplified82.0%
if 7.49999999999999959e32 < t < 1.20000000000000001e67 or 1.35e172 < t Initial program 38.3%
associate-/l*65.5%
Simplified65.5%
Taylor expanded in t around -inf 65.7%
mul-1-neg65.7%
unsub-neg65.7%
div-sub65.7%
*-commutative65.7%
div-sub65.7%
distribute-rgt-out--65.7%
Simplified65.7%
Taylor expanded in a around 0 68.5%
Taylor expanded in z around 0 68.5%
*-commutative68.5%
associate-*r/86.4%
Simplified86.4%
Taylor expanded in y around 0 66.0%
mul-1-neg66.0%
associate-*l/81.4%
distribute-rgt-neg-out81.4%
Simplified81.4%
if 1.20000000000000001e67 < t < 1.65000000000000006e101Initial program 84.4%
*-commutative84.4%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in y around inf 100.0%
Taylor expanded in t around inf 86.6%
Final simplification79.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ y (* x (/ z t)))) (t_2 (* y (/ (- z t) (- a t)))))
(if (<= t -5.6e+73)
t_2
(if (<= t -1.55e+42)
(- x (/ z (/ a x)))
(if (<= t -7e-19)
t_2
(if (<= t 1.15e-125)
(+ x (/ (- y x) (/ a z)))
(if (<= t 2.4e-17)
(* z (/ (- y x) (- a t)))
(if (<= t 2.75e+42)
(- x (/ (- t z) (/ a y)))
(if (<= t 3.6e+66)
t_1
(if (<= t 3.4e+101)
(+ x y)
(if (<= t 5e+172) t_2 t_1)))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y + (x * (z / t));
double t_2 = y * ((z - t) / (a - t));
double tmp;
if (t <= -5.6e+73) {
tmp = t_2;
} else if (t <= -1.55e+42) {
tmp = x - (z / (a / x));
} else if (t <= -7e-19) {
tmp = t_2;
} else if (t <= 1.15e-125) {
tmp = x + ((y - x) / (a / z));
} else if (t <= 2.4e-17) {
tmp = z * ((y - x) / (a - t));
} else if (t <= 2.75e+42) {
tmp = x - ((t - z) / (a / y));
} else if (t <= 3.6e+66) {
tmp = t_1;
} else if (t <= 3.4e+101) {
tmp = x + y;
} else if (t <= 5e+172) {
tmp = t_2;
} 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) :: tmp
t_1 = y + (x * (z / t))
t_2 = y * ((z - t) / (a - t))
if (t <= (-5.6d+73)) then
tmp = t_2
else if (t <= (-1.55d+42)) then
tmp = x - (z / (a / x))
else if (t <= (-7d-19)) then
tmp = t_2
else if (t <= 1.15d-125) then
tmp = x + ((y - x) / (a / z))
else if (t <= 2.4d-17) then
tmp = z * ((y - x) / (a - t))
else if (t <= 2.75d+42) then
tmp = x - ((t - z) / (a / y))
else if (t <= 3.6d+66) then
tmp = t_1
else if (t <= 3.4d+101) then
tmp = x + y
else if (t <= 5d+172) then
tmp = t_2
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 + (x * (z / t));
double t_2 = y * ((z - t) / (a - t));
double tmp;
if (t <= -5.6e+73) {
tmp = t_2;
} else if (t <= -1.55e+42) {
tmp = x - (z / (a / x));
} else if (t <= -7e-19) {
tmp = t_2;
} else if (t <= 1.15e-125) {
tmp = x + ((y - x) / (a / z));
} else if (t <= 2.4e-17) {
tmp = z * ((y - x) / (a - t));
} else if (t <= 2.75e+42) {
tmp = x - ((t - z) / (a / y));
} else if (t <= 3.6e+66) {
tmp = t_1;
} else if (t <= 3.4e+101) {
tmp = x + y;
} else if (t <= 5e+172) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y + (x * (z / t)) t_2 = y * ((z - t) / (a - t)) tmp = 0 if t <= -5.6e+73: tmp = t_2 elif t <= -1.55e+42: tmp = x - (z / (a / x)) elif t <= -7e-19: tmp = t_2 elif t <= 1.15e-125: tmp = x + ((y - x) / (a / z)) elif t <= 2.4e-17: tmp = z * ((y - x) / (a - t)) elif t <= 2.75e+42: tmp = x - ((t - z) / (a / y)) elif t <= 3.6e+66: tmp = t_1 elif t <= 3.4e+101: tmp = x + y elif t <= 5e+172: tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(y + Float64(x * Float64(z / t))) t_2 = Float64(y * Float64(Float64(z - t) / Float64(a - t))) tmp = 0.0 if (t <= -5.6e+73) tmp = t_2; elseif (t <= -1.55e+42) tmp = Float64(x - Float64(z / Float64(a / x))); elseif (t <= -7e-19) tmp = t_2; elseif (t <= 1.15e-125) tmp = Float64(x + Float64(Float64(y - x) / Float64(a / z))); elseif (t <= 2.4e-17) tmp = Float64(z * Float64(Float64(y - x) / Float64(a - t))); elseif (t <= 2.75e+42) tmp = Float64(x - Float64(Float64(t - z) / Float64(a / y))); elseif (t <= 3.6e+66) tmp = t_1; elseif (t <= 3.4e+101) tmp = Float64(x + y); elseif (t <= 5e+172) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y + (x * (z / t)); t_2 = y * ((z - t) / (a - t)); tmp = 0.0; if (t <= -5.6e+73) tmp = t_2; elseif (t <= -1.55e+42) tmp = x - (z / (a / x)); elseif (t <= -7e-19) tmp = t_2; elseif (t <= 1.15e-125) tmp = x + ((y - x) / (a / z)); elseif (t <= 2.4e-17) tmp = z * ((y - x) / (a - t)); elseif (t <= 2.75e+42) tmp = x - ((t - z) / (a / y)); elseif (t <= 3.6e+66) tmp = t_1; elseif (t <= 3.4e+101) tmp = x + y; elseif (t <= 5e+172) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y + N[(x * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -5.6e+73], t$95$2, If[LessEqual[t, -1.55e+42], N[(x - N[(z / N[(a / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -7e-19], t$95$2, If[LessEqual[t, 1.15e-125], N[(x + N[(N[(y - x), $MachinePrecision] / N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.4e-17], N[(z * N[(N[(y - x), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.75e+42], N[(x - N[(N[(t - z), $MachinePrecision] / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.6e+66], t$95$1, If[LessEqual[t, 3.4e+101], N[(x + y), $MachinePrecision], If[LessEqual[t, 5e+172], t$95$2, t$95$1]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + x \cdot \frac{z}{t}\\
t_2 := y \cdot \frac{z - t}{a - t}\\
\mathbf{if}\;t \leq -5.6 \cdot 10^{+73}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -1.55 \cdot 10^{+42}:\\
\;\;\;\;x - \frac{z}{\frac{a}{x}}\\
\mathbf{elif}\;t \leq -7 \cdot 10^{-19}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 1.15 \cdot 10^{-125}:\\
\;\;\;\;x + \frac{y - x}{\frac{a}{z}}\\
\mathbf{elif}\;t \leq 2.4 \cdot 10^{-17}:\\
\;\;\;\;z \cdot \frac{y - x}{a - t}\\
\mathbf{elif}\;t \leq 2.75 \cdot 10^{+42}:\\
\;\;\;\;x - \frac{t - z}{\frac{a}{y}}\\
\mathbf{elif}\;t \leq 3.6 \cdot 10^{+66}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 3.4 \cdot 10^{+101}:\\
\;\;\;\;x + y\\
\mathbf{elif}\;t \leq 5 \cdot 10^{+172}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -5.60000000000000016e73 or -1.5500000000000001e42 < t < -7.00000000000000031e-19 or 3.40000000000000017e101 < t < 5.0000000000000001e172Initial program 59.2%
associate-/l*81.6%
Simplified81.6%
Taylor expanded in x around 0 53.0%
associate-*r/72.8%
Simplified72.8%
if -5.60000000000000016e73 < t < -1.5500000000000001e42Initial program 61.8%
associate-/l*99.7%
Simplified99.7%
Taylor expanded in t around 0 61.8%
+-commutative61.8%
*-commutative61.8%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in y around 0 61.8%
+-commutative61.8%
mul-1-neg61.8%
unsub-neg61.8%
associate-/l*100.0%
Simplified100.0%
if -7.00000000000000031e-19 < t < 1.15e-125Initial program 84.8%
associate-/l*94.8%
Simplified94.8%
Taylor expanded in t around 0 80.5%
if 1.15e-125 < t < 2.39999999999999986e-17Initial program 91.8%
associate-/l*97.4%
Simplified97.4%
Taylor expanded in z around inf 88.4%
div-sub88.4%
Simplified88.4%
if 2.39999999999999986e-17 < t < 2.75000000000000001e42Initial program 89.4%
*-commutative89.4%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in y around inf 100.0%
Taylor expanded in a around inf 92.7%
if 2.75000000000000001e42 < t < 3.6e66 or 5.0000000000000001e172 < t Initial program 38.3%
associate-/l*65.5%
Simplified65.5%
Taylor expanded in t around -inf 65.7%
mul-1-neg65.7%
unsub-neg65.7%
div-sub65.7%
*-commutative65.7%
div-sub65.7%
distribute-rgt-out--65.7%
Simplified65.7%
Taylor expanded in a around 0 68.5%
Taylor expanded in z around 0 68.5%
*-commutative68.5%
associate-*r/86.4%
Simplified86.4%
Taylor expanded in y around 0 66.0%
mul-1-neg66.0%
associate-*l/81.4%
distribute-rgt-neg-out81.4%
Simplified81.4%
if 3.6e66 < t < 3.40000000000000017e101Initial program 84.4%
*-commutative84.4%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in y around inf 100.0%
Taylor expanded in t around inf 86.6%
Final simplification79.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- x (* t (/ y a)))) (t_2 (+ y (* x (/ z t)))))
(if (<= t -1.6e-18)
t_2
(if (<= t -2.35e-135)
t_1
(if (<= t -4e-197)
(* z (/ (- y x) a))
(if (<= t 1.18e-125)
(- x (/ z (/ a x)))
(if (<= t 6e-18)
(/ (* z (- x y)) t)
(if (<= t 5.4e+32)
t_1
(if (<= t 1.22e+67)
t_2
(if (<= t 2.5e+106)
(+ x y)
(if (<= t 3.4e+152) (* y (- 1.0 (/ z t))) t_2)))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x - (t * (y / a));
double t_2 = y + (x * (z / t));
double tmp;
if (t <= -1.6e-18) {
tmp = t_2;
} else if (t <= -2.35e-135) {
tmp = t_1;
} else if (t <= -4e-197) {
tmp = z * ((y - x) / a);
} else if (t <= 1.18e-125) {
tmp = x - (z / (a / x));
} else if (t <= 6e-18) {
tmp = (z * (x - y)) / t;
} else if (t <= 5.4e+32) {
tmp = t_1;
} else if (t <= 1.22e+67) {
tmp = t_2;
} else if (t <= 2.5e+106) {
tmp = x + y;
} else if (t <= 3.4e+152) {
tmp = y * (1.0 - (z / t));
} 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 = x - (t * (y / a))
t_2 = y + (x * (z / t))
if (t <= (-1.6d-18)) then
tmp = t_2
else if (t <= (-2.35d-135)) then
tmp = t_1
else if (t <= (-4d-197)) then
tmp = z * ((y - x) / a)
else if (t <= 1.18d-125) then
tmp = x - (z / (a / x))
else if (t <= 6d-18) then
tmp = (z * (x - y)) / t
else if (t <= 5.4d+32) then
tmp = t_1
else if (t <= 1.22d+67) then
tmp = t_2
else if (t <= 2.5d+106) then
tmp = x + y
else if (t <= 3.4d+152) then
tmp = y * (1.0d0 - (z / t))
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 = x - (t * (y / a));
double t_2 = y + (x * (z / t));
double tmp;
if (t <= -1.6e-18) {
tmp = t_2;
} else if (t <= -2.35e-135) {
tmp = t_1;
} else if (t <= -4e-197) {
tmp = z * ((y - x) / a);
} else if (t <= 1.18e-125) {
tmp = x - (z / (a / x));
} else if (t <= 6e-18) {
tmp = (z * (x - y)) / t;
} else if (t <= 5.4e+32) {
tmp = t_1;
} else if (t <= 1.22e+67) {
tmp = t_2;
} else if (t <= 2.5e+106) {
tmp = x + y;
} else if (t <= 3.4e+152) {
tmp = y * (1.0 - (z / t));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x - (t * (y / a)) t_2 = y + (x * (z / t)) tmp = 0 if t <= -1.6e-18: tmp = t_2 elif t <= -2.35e-135: tmp = t_1 elif t <= -4e-197: tmp = z * ((y - x) / a) elif t <= 1.18e-125: tmp = x - (z / (a / x)) elif t <= 6e-18: tmp = (z * (x - y)) / t elif t <= 5.4e+32: tmp = t_1 elif t <= 1.22e+67: tmp = t_2 elif t <= 2.5e+106: tmp = x + y elif t <= 3.4e+152: tmp = y * (1.0 - (z / t)) else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(x - Float64(t * Float64(y / a))) t_2 = Float64(y + Float64(x * Float64(z / t))) tmp = 0.0 if (t <= -1.6e-18) tmp = t_2; elseif (t <= -2.35e-135) tmp = t_1; elseif (t <= -4e-197) tmp = Float64(z * Float64(Float64(y - x) / a)); elseif (t <= 1.18e-125) tmp = Float64(x - Float64(z / Float64(a / x))); elseif (t <= 6e-18) tmp = Float64(Float64(z * Float64(x - y)) / t); elseif (t <= 5.4e+32) tmp = t_1; elseif (t <= 1.22e+67) tmp = t_2; elseif (t <= 2.5e+106) tmp = Float64(x + y); elseif (t <= 3.4e+152) tmp = Float64(y * Float64(1.0 - Float64(z / t))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x - (t * (y / a)); t_2 = y + (x * (z / t)); tmp = 0.0; if (t <= -1.6e-18) tmp = t_2; elseif (t <= -2.35e-135) tmp = t_1; elseif (t <= -4e-197) tmp = z * ((y - x) / a); elseif (t <= 1.18e-125) tmp = x - (z / (a / x)); elseif (t <= 6e-18) tmp = (z * (x - y)) / t; elseif (t <= 5.4e+32) tmp = t_1; elseif (t <= 1.22e+67) tmp = t_2; elseif (t <= 2.5e+106) tmp = x + y; elseif (t <= 3.4e+152) tmp = y * (1.0 - (z / t)); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y + N[(x * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.6e-18], t$95$2, If[LessEqual[t, -2.35e-135], t$95$1, If[LessEqual[t, -4e-197], N[(z * N[(N[(y - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.18e-125], N[(x - N[(z / N[(a / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 6e-18], N[(N[(z * N[(x - y), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision], If[LessEqual[t, 5.4e+32], t$95$1, If[LessEqual[t, 1.22e+67], t$95$2, If[LessEqual[t, 2.5e+106], N[(x + y), $MachinePrecision], If[LessEqual[t, 3.4e+152], N[(y * N[(1.0 - N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - t \cdot \frac{y}{a}\\
t_2 := y + x \cdot \frac{z}{t}\\
\mathbf{if}\;t \leq -1.6 \cdot 10^{-18}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -2.35 \cdot 10^{-135}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -4 \cdot 10^{-197}:\\
\;\;\;\;z \cdot \frac{y - x}{a}\\
\mathbf{elif}\;t \leq 1.18 \cdot 10^{-125}:\\
\;\;\;\;x - \frac{z}{\frac{a}{x}}\\
\mathbf{elif}\;t \leq 6 \cdot 10^{-18}:\\
\;\;\;\;\frac{z \cdot \left(x - y\right)}{t}\\
\mathbf{elif}\;t \leq 5.4 \cdot 10^{+32}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 1.22 \cdot 10^{+67}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 2.5 \cdot 10^{+106}:\\
\;\;\;\;x + y\\
\mathbf{elif}\;t \leq 3.4 \cdot 10^{+152}:\\
\;\;\;\;y \cdot \left(1 - \frac{z}{t}\right)\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -1.6e-18 or 5.40000000000000025e32 < t < 1.22000000000000004e67 or 3.4000000000000002e152 < t Initial program 52.1%
associate-/l*77.3%
Simplified77.3%
Taylor expanded in t around -inf 62.1%
mul-1-neg62.1%
unsub-neg62.1%
div-sub62.1%
*-commutative62.1%
div-sub62.1%
distribute-rgt-out--62.3%
Simplified62.3%
Taylor expanded in a around 0 62.1%
Taylor expanded in z around 0 62.1%
*-commutative62.1%
associate-*r/73.6%
Simplified73.6%
Taylor expanded in y around 0 56.8%
mul-1-neg56.8%
associate-*l/64.0%
distribute-rgt-neg-out64.0%
Simplified64.0%
if -1.6e-18 < t < -2.34999999999999988e-135 or 5.99999999999999966e-18 < t < 5.40000000000000025e32Initial program 78.3%
*-commutative78.3%
associate-/l*86.4%
Simplified86.4%
Taylor expanded in y around inf 78.8%
Taylor expanded in a around inf 68.7%
Taylor expanded in z around 0 58.2%
mul-1-neg58.2%
*-commutative58.2%
associate-*r/58.2%
distribute-rgt-neg-in58.2%
distribute-neg-frac58.2%
Simplified58.2%
if -2.34999999999999988e-135 < t < -3.9999999999999999e-197Initial program 91.1%
associate-/l*97.4%
Simplified97.4%
Taylor expanded in t around 0 69.6%
+-commutative69.6%
*-commutative69.6%
associate-/l*69.3%
Simplified69.3%
Taylor expanded in z around inf 69.1%
div-sub69.1%
Simplified69.1%
if -3.9999999999999999e-197 < t < 1.17999999999999994e-125Initial program 88.1%
associate-/l*96.9%
Simplified96.9%
Taylor expanded in t around 0 81.8%
+-commutative81.8%
*-commutative81.8%
associate-/l*88.2%
Simplified88.2%
Taylor expanded in y around 0 65.0%
+-commutative65.0%
mul-1-neg65.0%
unsub-neg65.0%
associate-/l*68.5%
Simplified68.5%
if 1.17999999999999994e-125 < t < 5.99999999999999966e-18Initial program 91.3%
associate-/l*97.2%
Simplified97.2%
Taylor expanded in z around inf 87.7%
div-sub87.7%
associate-*r/82.1%
Simplified82.1%
Taylor expanded in a around 0 75.5%
associate-*r/75.5%
mul-1-neg75.5%
*-commutative75.5%
Simplified75.5%
if 1.22000000000000004e67 < t < 2.4999999999999999e106Initial program 84.4%
*-commutative84.4%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in y around inf 100.0%
Taylor expanded in t around inf 86.6%
if 2.4999999999999999e106 < t < 3.4000000000000002e152Initial program 52.7%
associate-/l*67.7%
Simplified67.7%
Taylor expanded in t around -inf 84.5%
mul-1-neg84.5%
unsub-neg84.5%
div-sub84.5%
*-commutative84.5%
div-sub84.5%
distribute-rgt-out--84.5%
Simplified84.5%
Taylor expanded in a around 0 84.5%
Taylor expanded in y around inf 83.1%
Final simplification66.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (- 1.0 (/ z t))))
(t_2 (- x (/ z (/ a x))))
(t_3 (* x (/ (- z) (- a t)))))
(if (<= a -4.1e+65)
t_2
(if (<= a -6.1e-31)
t_1
(if (<= a -4.2e-50)
t_3
(if (<= a -5e-123)
t_1
(if (<= a -2.8e-156)
t_3
(if (<= a 8.8e-281)
t_1
(if (<= a 1.25e-275)
(/ z (/ t x))
(if (<= a 9.5e+47) (- y (/ y (/ t z))) t_2))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * (1.0 - (z / t));
double t_2 = x - (z / (a / x));
double t_3 = x * (-z / (a - t));
double tmp;
if (a <= -4.1e+65) {
tmp = t_2;
} else if (a <= -6.1e-31) {
tmp = t_1;
} else if (a <= -4.2e-50) {
tmp = t_3;
} else if (a <= -5e-123) {
tmp = t_1;
} else if (a <= -2.8e-156) {
tmp = t_3;
} else if (a <= 8.8e-281) {
tmp = t_1;
} else if (a <= 1.25e-275) {
tmp = z / (t / x);
} else if (a <= 9.5e+47) {
tmp = y - (y / (t / z));
} 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) :: t_3
real(8) :: tmp
t_1 = y * (1.0d0 - (z / t))
t_2 = x - (z / (a / x))
t_3 = x * (-z / (a - t))
if (a <= (-4.1d+65)) then
tmp = t_2
else if (a <= (-6.1d-31)) then
tmp = t_1
else if (a <= (-4.2d-50)) then
tmp = t_3
else if (a <= (-5d-123)) then
tmp = t_1
else if (a <= (-2.8d-156)) then
tmp = t_3
else if (a <= 8.8d-281) then
tmp = t_1
else if (a <= 1.25d-275) then
tmp = z / (t / x)
else if (a <= 9.5d+47) then
tmp = y - (y / (t / z))
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 * (1.0 - (z / t));
double t_2 = x - (z / (a / x));
double t_3 = x * (-z / (a - t));
double tmp;
if (a <= -4.1e+65) {
tmp = t_2;
} else if (a <= -6.1e-31) {
tmp = t_1;
} else if (a <= -4.2e-50) {
tmp = t_3;
} else if (a <= -5e-123) {
tmp = t_1;
} else if (a <= -2.8e-156) {
tmp = t_3;
} else if (a <= 8.8e-281) {
tmp = t_1;
} else if (a <= 1.25e-275) {
tmp = z / (t / x);
} else if (a <= 9.5e+47) {
tmp = y - (y / (t / z));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * (1.0 - (z / t)) t_2 = x - (z / (a / x)) t_3 = x * (-z / (a - t)) tmp = 0 if a <= -4.1e+65: tmp = t_2 elif a <= -6.1e-31: tmp = t_1 elif a <= -4.2e-50: tmp = t_3 elif a <= -5e-123: tmp = t_1 elif a <= -2.8e-156: tmp = t_3 elif a <= 8.8e-281: tmp = t_1 elif a <= 1.25e-275: tmp = z / (t / x) elif a <= 9.5e+47: tmp = y - (y / (t / z)) else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(1.0 - Float64(z / t))) t_2 = Float64(x - Float64(z / Float64(a / x))) t_3 = Float64(x * Float64(Float64(-z) / Float64(a - t))) tmp = 0.0 if (a <= -4.1e+65) tmp = t_2; elseif (a <= -6.1e-31) tmp = t_1; elseif (a <= -4.2e-50) tmp = t_3; elseif (a <= -5e-123) tmp = t_1; elseif (a <= -2.8e-156) tmp = t_3; elseif (a <= 8.8e-281) tmp = t_1; elseif (a <= 1.25e-275) tmp = Float64(z / Float64(t / x)); elseif (a <= 9.5e+47) tmp = Float64(y - Float64(y / Float64(t / z))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * (1.0 - (z / t)); t_2 = x - (z / (a / x)); t_3 = x * (-z / (a - t)); tmp = 0.0; if (a <= -4.1e+65) tmp = t_2; elseif (a <= -6.1e-31) tmp = t_1; elseif (a <= -4.2e-50) tmp = t_3; elseif (a <= -5e-123) tmp = t_1; elseif (a <= -2.8e-156) tmp = t_3; elseif (a <= 8.8e-281) tmp = t_1; elseif (a <= 1.25e-275) tmp = z / (t / x); elseif (a <= 9.5e+47) tmp = y - (y / (t / z)); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(1.0 - N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(z / N[(a / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(x * N[((-z) / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -4.1e+65], t$95$2, If[LessEqual[a, -6.1e-31], t$95$1, If[LessEqual[a, -4.2e-50], t$95$3, If[LessEqual[a, -5e-123], t$95$1, If[LessEqual[a, -2.8e-156], t$95$3, If[LessEqual[a, 8.8e-281], t$95$1, If[LessEqual[a, 1.25e-275], N[(z / N[(t / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 9.5e+47], N[(y - N[(y / N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(1 - \frac{z}{t}\right)\\
t_2 := x - \frac{z}{\frac{a}{x}}\\
t_3 := x \cdot \frac{-z}{a - t}\\
\mathbf{if}\;a \leq -4.1 \cdot 10^{+65}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq -6.1 \cdot 10^{-31}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -4.2 \cdot 10^{-50}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;a \leq -5 \cdot 10^{-123}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -2.8 \cdot 10^{-156}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;a \leq 8.8 \cdot 10^{-281}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 1.25 \cdot 10^{-275}:\\
\;\;\;\;\frac{z}{\frac{t}{x}}\\
\mathbf{elif}\;a \leq 9.5 \cdot 10^{+47}:\\
\;\;\;\;y - \frac{y}{\frac{t}{z}}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if a < -4.1000000000000001e65 or 9.50000000000000001e47 < a Initial program 68.2%
associate-/l*96.8%
Simplified96.8%
Taylor expanded in t around 0 57.0%
+-commutative57.0%
*-commutative57.0%
associate-/l*74.0%
Simplified74.0%
Taylor expanded in y around 0 53.4%
+-commutative53.4%
mul-1-neg53.4%
unsub-neg53.4%
associate-/l*61.5%
Simplified61.5%
if -4.1000000000000001e65 < a < -6.0999999999999998e-31 or -4.2000000000000002e-50 < a < -5.0000000000000003e-123 or -2.8000000000000002e-156 < a < 8.80000000000000016e-281Initial program 69.2%
associate-/l*79.7%
Simplified79.7%
Taylor expanded in t around -inf 76.4%
mul-1-neg76.4%
unsub-neg76.4%
div-sub76.4%
*-commutative76.4%
div-sub76.4%
distribute-rgt-out--76.4%
Simplified76.4%
Taylor expanded in a around 0 72.0%
Taylor expanded in y around inf 62.3%
if -6.0999999999999998e-31 < a < -4.2000000000000002e-50 or -5.0000000000000003e-123 < a < -2.8000000000000002e-156Initial program 71.1%
associate-/l*77.5%
Simplified77.5%
Taylor expanded in z around inf 80.6%
div-sub80.6%
associate-*r/71.7%
Simplified71.7%
Taylor expanded in y around 0 71.7%
associate-*r/71.7%
associate-*r*71.7%
*-rgt-identity71.7%
times-frac80.7%
mul-1-neg80.7%
/-rgt-identity80.7%
Simplified80.7%
if 8.80000000000000016e-281 < a < 1.24999999999999996e-275Initial program 42.3%
associate-/l*74.7%
Simplified74.7%
Taylor expanded in z around inf 100.0%
div-sub100.0%
associate-*r/62.1%
Simplified62.1%
Taylor expanded in y around 0 62.1%
associate-*r/62.1%
associate-*r*62.1%
*-rgt-identity62.1%
times-frac80.9%
mul-1-neg80.9%
/-rgt-identity80.9%
Simplified80.9%
Taylor expanded in a around 0 62.1%
associate-/l*99.4%
Simplified99.4%
if 1.24999999999999996e-275 < a < 9.50000000000000001e47Initial program 73.6%
associate-/l*82.1%
Simplified82.1%
Taylor expanded in t around -inf 72.2%
mul-1-neg72.2%
unsub-neg72.2%
div-sub70.9%
*-commutative70.9%
div-sub72.2%
distribute-rgt-out--72.2%
Simplified72.2%
Taylor expanded in a around 0 71.8%
Taylor expanded in y around inf 50.7%
associate-/l*53.3%
Simplified53.3%
Final simplification61.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (- 1.0 (/ z t))))
(t_2 (- x (* t (/ y a))))
(t_3 (* x (/ (- z) (- a t)))))
(if (<= a -3.2e+65)
t_2
(if (<= a -3.8e-31)
t_1
(if (<= a -3.9e-50)
t_3
(if (<= a -4.6e-123)
t_1
(if (<= a -2.3e-172)
t_3
(if (<= a 2.6e-280)
t_1
(if (<= a 1.25e-275)
(/ z (/ t x))
(if (<= a 1.8e+46) (- y (/ y (/ t z))) t_2))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * (1.0 - (z / t));
double t_2 = x - (t * (y / a));
double t_3 = x * (-z / (a - t));
double tmp;
if (a <= -3.2e+65) {
tmp = t_2;
} else if (a <= -3.8e-31) {
tmp = t_1;
} else if (a <= -3.9e-50) {
tmp = t_3;
} else if (a <= -4.6e-123) {
tmp = t_1;
} else if (a <= -2.3e-172) {
tmp = t_3;
} else if (a <= 2.6e-280) {
tmp = t_1;
} else if (a <= 1.25e-275) {
tmp = z / (t / x);
} else if (a <= 1.8e+46) {
tmp = y - (y / (t / z));
} 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) :: t_3
real(8) :: tmp
t_1 = y * (1.0d0 - (z / t))
t_2 = x - (t * (y / a))
t_3 = x * (-z / (a - t))
if (a <= (-3.2d+65)) then
tmp = t_2
else if (a <= (-3.8d-31)) then
tmp = t_1
else if (a <= (-3.9d-50)) then
tmp = t_3
else if (a <= (-4.6d-123)) then
tmp = t_1
else if (a <= (-2.3d-172)) then
tmp = t_3
else if (a <= 2.6d-280) then
tmp = t_1
else if (a <= 1.25d-275) then
tmp = z / (t / x)
else if (a <= 1.8d+46) then
tmp = y - (y / (t / z))
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 * (1.0 - (z / t));
double t_2 = x - (t * (y / a));
double t_3 = x * (-z / (a - t));
double tmp;
if (a <= -3.2e+65) {
tmp = t_2;
} else if (a <= -3.8e-31) {
tmp = t_1;
} else if (a <= -3.9e-50) {
tmp = t_3;
} else if (a <= -4.6e-123) {
tmp = t_1;
} else if (a <= -2.3e-172) {
tmp = t_3;
} else if (a <= 2.6e-280) {
tmp = t_1;
} else if (a <= 1.25e-275) {
tmp = z / (t / x);
} else if (a <= 1.8e+46) {
tmp = y - (y / (t / z));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * (1.0 - (z / t)) t_2 = x - (t * (y / a)) t_3 = x * (-z / (a - t)) tmp = 0 if a <= -3.2e+65: tmp = t_2 elif a <= -3.8e-31: tmp = t_1 elif a <= -3.9e-50: tmp = t_3 elif a <= -4.6e-123: tmp = t_1 elif a <= -2.3e-172: tmp = t_3 elif a <= 2.6e-280: tmp = t_1 elif a <= 1.25e-275: tmp = z / (t / x) elif a <= 1.8e+46: tmp = y - (y / (t / z)) else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(1.0 - Float64(z / t))) t_2 = Float64(x - Float64(t * Float64(y / a))) t_3 = Float64(x * Float64(Float64(-z) / Float64(a - t))) tmp = 0.0 if (a <= -3.2e+65) tmp = t_2; elseif (a <= -3.8e-31) tmp = t_1; elseif (a <= -3.9e-50) tmp = t_3; elseif (a <= -4.6e-123) tmp = t_1; elseif (a <= -2.3e-172) tmp = t_3; elseif (a <= 2.6e-280) tmp = t_1; elseif (a <= 1.25e-275) tmp = Float64(z / Float64(t / x)); elseif (a <= 1.8e+46) tmp = Float64(y - Float64(y / Float64(t / z))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * (1.0 - (z / t)); t_2 = x - (t * (y / a)); t_3 = x * (-z / (a - t)); tmp = 0.0; if (a <= -3.2e+65) tmp = t_2; elseif (a <= -3.8e-31) tmp = t_1; elseif (a <= -3.9e-50) tmp = t_3; elseif (a <= -4.6e-123) tmp = t_1; elseif (a <= -2.3e-172) tmp = t_3; elseif (a <= 2.6e-280) tmp = t_1; elseif (a <= 1.25e-275) tmp = z / (t / x); elseif (a <= 1.8e+46) tmp = y - (y / (t / z)); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(1.0 - N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(x * N[((-z) / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -3.2e+65], t$95$2, If[LessEqual[a, -3.8e-31], t$95$1, If[LessEqual[a, -3.9e-50], t$95$3, If[LessEqual[a, -4.6e-123], t$95$1, If[LessEqual[a, -2.3e-172], t$95$3, If[LessEqual[a, 2.6e-280], t$95$1, If[LessEqual[a, 1.25e-275], N[(z / N[(t / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.8e+46], N[(y - N[(y / N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(1 - \frac{z}{t}\right)\\
t_2 := x - t \cdot \frac{y}{a}\\
t_3 := x \cdot \frac{-z}{a - t}\\
\mathbf{if}\;a \leq -3.2 \cdot 10^{+65}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq -3.8 \cdot 10^{-31}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -3.9 \cdot 10^{-50}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;a \leq -4.6 \cdot 10^{-123}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -2.3 \cdot 10^{-172}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;a \leq 2.6 \cdot 10^{-280}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 1.25 \cdot 10^{-275}:\\
\;\;\;\;\frac{z}{\frac{t}{x}}\\
\mathbf{elif}\;a \leq 1.8 \cdot 10^{+46}:\\
\;\;\;\;y - \frac{y}{\frac{t}{z}}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if a < -3.20000000000000007e65 or 1.7999999999999999e46 < a Initial program 68.2%
*-commutative68.2%
associate-/l*93.9%
Simplified93.9%
Taylor expanded in y around inf 84.3%
Taylor expanded in a around inf 75.4%
Taylor expanded in z around 0 61.7%
mul-1-neg61.7%
*-commutative61.7%
associate-*r/62.7%
distribute-rgt-neg-in62.7%
distribute-neg-frac62.7%
Simplified62.7%
if -3.20000000000000007e65 < a < -3.8e-31 or -3.90000000000000021e-50 < a < -4.59999999999999973e-123 or -2.29999999999999995e-172 < a < 2.6e-280Initial program 69.2%
associate-/l*79.7%
Simplified79.7%
Taylor expanded in t around -inf 76.4%
mul-1-neg76.4%
unsub-neg76.4%
div-sub76.4%
*-commutative76.4%
div-sub76.4%
distribute-rgt-out--76.4%
Simplified76.4%
Taylor expanded in a around 0 72.0%
Taylor expanded in y around inf 62.3%
if -3.8e-31 < a < -3.90000000000000021e-50 or -4.59999999999999973e-123 < a < -2.29999999999999995e-172Initial program 71.1%
associate-/l*77.5%
Simplified77.5%
Taylor expanded in z around inf 80.6%
div-sub80.6%
associate-*r/71.7%
Simplified71.7%
Taylor expanded in y around 0 71.7%
associate-*r/71.7%
associate-*r*71.7%
*-rgt-identity71.7%
times-frac80.7%
mul-1-neg80.7%
/-rgt-identity80.7%
Simplified80.7%
if 2.6e-280 < a < 1.24999999999999996e-275Initial program 42.3%
associate-/l*74.7%
Simplified74.7%
Taylor expanded in z around inf 100.0%
div-sub100.0%
associate-*r/62.1%
Simplified62.1%
Taylor expanded in y around 0 62.1%
associate-*r/62.1%
associate-*r*62.1%
*-rgt-identity62.1%
times-frac80.9%
mul-1-neg80.9%
/-rgt-identity80.9%
Simplified80.9%
Taylor expanded in a around 0 62.1%
associate-/l*99.4%
Simplified99.4%
if 1.24999999999999996e-275 < a < 1.7999999999999999e46Initial program 73.6%
associate-/l*82.1%
Simplified82.1%
Taylor expanded in t around -inf 72.2%
mul-1-neg72.2%
unsub-neg72.2%
div-sub70.9%
*-commutative70.9%
div-sub72.2%
distribute-rgt-out--72.2%
Simplified72.2%
Taylor expanded in a around 0 71.8%
Taylor expanded in y around inf 50.7%
associate-/l*53.3%
Simplified53.3%
Final simplification61.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- x (/ z (/ a x)))) (t_2 (* y (/ (- z t) (- a t)))))
(if (<= y -5.6e-9)
t_2
(if (<= y -1.3e-159)
t_1
(if (<= y -3.25e-307)
(+ y (* x (/ z t)))
(if (or (<= y 2e-188) (and (not (<= y 1.25e-108)) (<= y 1.85e+50)))
t_1
t_2))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x - (z / (a / x));
double t_2 = y * ((z - t) / (a - t));
double tmp;
if (y <= -5.6e-9) {
tmp = t_2;
} else if (y <= -1.3e-159) {
tmp = t_1;
} else if (y <= -3.25e-307) {
tmp = y + (x * (z / t));
} else if ((y <= 2e-188) || (!(y <= 1.25e-108) && (y <= 1.85e+50))) {
tmp = t_1;
} 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 = x - (z / (a / x))
t_2 = y * ((z - t) / (a - t))
if (y <= (-5.6d-9)) then
tmp = t_2
else if (y <= (-1.3d-159)) then
tmp = t_1
else if (y <= (-3.25d-307)) then
tmp = y + (x * (z / t))
else if ((y <= 2d-188) .or. (.not. (y <= 1.25d-108)) .and. (y <= 1.85d+50)) then
tmp = t_1
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 = x - (z / (a / x));
double t_2 = y * ((z - t) / (a - t));
double tmp;
if (y <= -5.6e-9) {
tmp = t_2;
} else if (y <= -1.3e-159) {
tmp = t_1;
} else if (y <= -3.25e-307) {
tmp = y + (x * (z / t));
} else if ((y <= 2e-188) || (!(y <= 1.25e-108) && (y <= 1.85e+50))) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x - (z / (a / x)) t_2 = y * ((z - t) / (a - t)) tmp = 0 if y <= -5.6e-9: tmp = t_2 elif y <= -1.3e-159: tmp = t_1 elif y <= -3.25e-307: tmp = y + (x * (z / t)) elif (y <= 2e-188) or (not (y <= 1.25e-108) and (y <= 1.85e+50)): tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(x - Float64(z / Float64(a / x))) t_2 = Float64(y * Float64(Float64(z - t) / Float64(a - t))) tmp = 0.0 if (y <= -5.6e-9) tmp = t_2; elseif (y <= -1.3e-159) tmp = t_1; elseif (y <= -3.25e-307) tmp = Float64(y + Float64(x * Float64(z / t))); elseif ((y <= 2e-188) || (!(y <= 1.25e-108) && (y <= 1.85e+50))) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x - (z / (a / x)); t_2 = y * ((z - t) / (a - t)); tmp = 0.0; if (y <= -5.6e-9) tmp = t_2; elseif (y <= -1.3e-159) tmp = t_1; elseif (y <= -3.25e-307) tmp = y + (x * (z / t)); elseif ((y <= 2e-188) || (~((y <= 1.25e-108)) && (y <= 1.85e+50))) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(z / N[(a / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -5.6e-9], t$95$2, If[LessEqual[y, -1.3e-159], t$95$1, If[LessEqual[y, -3.25e-307], N[(y + N[(x * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[y, 2e-188], And[N[Not[LessEqual[y, 1.25e-108]], $MachinePrecision], LessEqual[y, 1.85e+50]]], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - \frac{z}{\frac{a}{x}}\\
t_2 := y \cdot \frac{z - t}{a - t}\\
\mathbf{if}\;y \leq -5.6 \cdot 10^{-9}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -1.3 \cdot 10^{-159}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -3.25 \cdot 10^{-307}:\\
\;\;\;\;y + x \cdot \frac{z}{t}\\
\mathbf{elif}\;y \leq 2 \cdot 10^{-188} \lor \neg \left(y \leq 1.25 \cdot 10^{-108}\right) \land y \leq 1.85 \cdot 10^{+50}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if y < -5.59999999999999969e-9 or 1.9999999999999999e-188 < y < 1.25e-108 or 1.85e50 < y Initial program 66.5%
associate-/l*89.6%
Simplified89.6%
Taylor expanded in x around 0 52.7%
associate-*r/73.6%
Simplified73.6%
if -5.59999999999999969e-9 < y < -1.2999999999999999e-159 or -3.2500000000000001e-307 < y < 1.9999999999999999e-188 or 1.25e-108 < y < 1.85e50Initial program 75.5%
associate-/l*85.8%
Simplified85.8%
Taylor expanded in t around 0 56.2%
+-commutative56.2%
*-commutative56.2%
associate-/l*61.4%
Simplified61.4%
Taylor expanded in y around 0 54.2%
+-commutative54.2%
mul-1-neg54.2%
unsub-neg54.2%
associate-/l*59.4%
Simplified59.4%
if -1.2999999999999999e-159 < y < -3.2500000000000001e-307Initial program 66.3%
associate-/l*75.8%
Simplified75.8%
Taylor expanded in t around -inf 72.9%
mul-1-neg72.9%
unsub-neg72.9%
div-sub72.9%
*-commutative72.9%
div-sub72.9%
distribute-rgt-out--72.9%
Simplified72.9%
Taylor expanded in a around 0 62.9%
Taylor expanded in z around 0 62.9%
*-commutative62.9%
associate-*r/60.3%
Simplified60.3%
Taylor expanded in y around 0 59.4%
mul-1-neg59.4%
associate-*l/56.4%
distribute-rgt-neg-out56.4%
Simplified56.4%
Final simplification66.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ y (* (/ z t) (- x y)))))
(if (<= t -1.5e+73)
t_1
(if (<= t -4.2e+28)
(+ x (/ z (/ a (- y x))))
(if (<= t -3.8e-18)
t_1
(if (<= t 1.35e-125)
(+ x (/ (- y x) (/ a z)))
(if (<= t 2.5e-17)
(* z (/ (- y x) (- a t)))
(if (<= t 2.9e+40) (- x (/ (- t z) (/ a y))) t_1))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y + ((z / t) * (x - y));
double tmp;
if (t <= -1.5e+73) {
tmp = t_1;
} else if (t <= -4.2e+28) {
tmp = x + (z / (a / (y - x)));
} else if (t <= -3.8e-18) {
tmp = t_1;
} else if (t <= 1.35e-125) {
tmp = x + ((y - x) / (a / z));
} else if (t <= 2.5e-17) {
tmp = z * ((y - x) / (a - t));
} else if (t <= 2.9e+40) {
tmp = x - ((t - z) / (a / y));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = y + ((z / t) * (x - y))
if (t <= (-1.5d+73)) then
tmp = t_1
else if (t <= (-4.2d+28)) then
tmp = x + (z / (a / (y - x)))
else if (t <= (-3.8d-18)) then
tmp = t_1
else if (t <= 1.35d-125) then
tmp = x + ((y - x) / (a / z))
else if (t <= 2.5d-17) then
tmp = z * ((y - x) / (a - t))
else if (t <= 2.9d+40) then
tmp = x - ((t - z) / (a / y))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y + ((z / t) * (x - y));
double tmp;
if (t <= -1.5e+73) {
tmp = t_1;
} else if (t <= -4.2e+28) {
tmp = x + (z / (a / (y - x)));
} else if (t <= -3.8e-18) {
tmp = t_1;
} else if (t <= 1.35e-125) {
tmp = x + ((y - x) / (a / z));
} else if (t <= 2.5e-17) {
tmp = z * ((y - x) / (a - t));
} else if (t <= 2.9e+40) {
tmp = x - ((t - z) / (a / y));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y + ((z / t) * (x - y)) tmp = 0 if t <= -1.5e+73: tmp = t_1 elif t <= -4.2e+28: tmp = x + (z / (a / (y - x))) elif t <= -3.8e-18: tmp = t_1 elif t <= 1.35e-125: tmp = x + ((y - x) / (a / z)) elif t <= 2.5e-17: tmp = z * ((y - x) / (a - t)) elif t <= 2.9e+40: tmp = x - ((t - z) / (a / y)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(y + Float64(Float64(z / t) * Float64(x - y))) tmp = 0.0 if (t <= -1.5e+73) tmp = t_1; elseif (t <= -4.2e+28) tmp = Float64(x + Float64(z / Float64(a / Float64(y - x)))); elseif (t <= -3.8e-18) tmp = t_1; elseif (t <= 1.35e-125) tmp = Float64(x + Float64(Float64(y - x) / Float64(a / z))); elseif (t <= 2.5e-17) tmp = Float64(z * Float64(Float64(y - x) / Float64(a - t))); elseif (t <= 2.9e+40) tmp = Float64(x - Float64(Float64(t - z) / Float64(a / y))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y + ((z / t) * (x - y)); tmp = 0.0; if (t <= -1.5e+73) tmp = t_1; elseif (t <= -4.2e+28) tmp = x + (z / (a / (y - x))); elseif (t <= -3.8e-18) tmp = t_1; elseif (t <= 1.35e-125) tmp = x + ((y - x) / (a / z)); elseif (t <= 2.5e-17) tmp = z * ((y - x) / (a - t)); elseif (t <= 2.9e+40) tmp = x - ((t - z) / (a / y)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y + N[(N[(z / t), $MachinePrecision] * N[(x - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.5e+73], t$95$1, If[LessEqual[t, -4.2e+28], N[(x + N[(z / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -3.8e-18], t$95$1, If[LessEqual[t, 1.35e-125], N[(x + N[(N[(y - x), $MachinePrecision] / N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.5e-17], N[(z * N[(N[(y - x), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.9e+40], N[(x - N[(N[(t - z), $MachinePrecision] / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + \frac{z}{t} \cdot \left(x - y\right)\\
\mathbf{if}\;t \leq -1.5 \cdot 10^{+73}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -4.2 \cdot 10^{+28}:\\
\;\;\;\;x + \frac{z}{\frac{a}{y - x}}\\
\mathbf{elif}\;t \leq -3.8 \cdot 10^{-18}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 1.35 \cdot 10^{-125}:\\
\;\;\;\;x + \frac{y - x}{\frac{a}{z}}\\
\mathbf{elif}\;t \leq 2.5 \cdot 10^{-17}:\\
\;\;\;\;z \cdot \frac{y - x}{a - t}\\
\mathbf{elif}\;t \leq 2.9 \cdot 10^{+40}:\\
\;\;\;\;x - \frac{t - z}{\frac{a}{y}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -1.50000000000000005e73 or -4.19999999999999978e28 < t < -3.7999999999999998e-18 or 2.90000000000000017e40 < t Initial program 53.4%
associate-/l*77.1%
Simplified77.1%
Taylor expanded in t around -inf 64.0%
mul-1-neg64.0%
unsub-neg64.0%
div-sub64.0%
*-commutative64.0%
div-sub64.0%
distribute-rgt-out--64.2%
Simplified64.2%
Taylor expanded in a around 0 64.1%
Taylor expanded in z around 0 64.1%
*-commutative64.1%
associate-*r/76.0%
Simplified76.0%
if -1.50000000000000005e73 < t < -4.19999999999999978e28Initial program 57.3%
associate-/l*89.0%
Simplified89.0%
Taylor expanded in t around 0 47.3%
+-commutative47.3%
*-commutative47.3%
associate-/l*79.1%
Simplified79.1%
if -3.7999999999999998e-18 < t < 1.3499999999999999e-125Initial program 84.8%
associate-/l*94.8%
Simplified94.8%
Taylor expanded in t around 0 80.5%
if 1.3499999999999999e-125 < t < 2.4999999999999999e-17Initial program 91.8%
associate-/l*97.4%
Simplified97.4%
Taylor expanded in z around inf 88.4%
div-sub88.4%
Simplified88.4%
if 2.4999999999999999e-17 < t < 2.90000000000000017e40Initial program 89.4%
*-commutative89.4%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in y around inf 100.0%
Taylor expanded in a around inf 92.7%
Final simplification79.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ y (* (/ z t) (- x y)))))
(if (<= t -2.6e+74)
t_1
(if (<= t -7.2e+28)
(+ x (/ z (/ a (- y x))))
(if (<= t -4.2e-19)
(- y (/ (* (- y x) z) t))
(if (<= t 1.18e-125)
(+ x (/ (- y x) (/ a z)))
(if (<= t 3.5e-17)
(* z (/ (- y x) (- a t)))
(if (<= t 5.2e+31) (- x (/ (- t z) (/ a y))) t_1))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y + ((z / t) * (x - y));
double tmp;
if (t <= -2.6e+74) {
tmp = t_1;
} else if (t <= -7.2e+28) {
tmp = x + (z / (a / (y - x)));
} else if (t <= -4.2e-19) {
tmp = y - (((y - x) * z) / t);
} else if (t <= 1.18e-125) {
tmp = x + ((y - x) / (a / z));
} else if (t <= 3.5e-17) {
tmp = z * ((y - x) / (a - t));
} else if (t <= 5.2e+31) {
tmp = x - ((t - z) / (a / y));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = y + ((z / t) * (x - y))
if (t <= (-2.6d+74)) then
tmp = t_1
else if (t <= (-7.2d+28)) then
tmp = x + (z / (a / (y - x)))
else if (t <= (-4.2d-19)) then
tmp = y - (((y - x) * z) / t)
else if (t <= 1.18d-125) then
tmp = x + ((y - x) / (a / z))
else if (t <= 3.5d-17) then
tmp = z * ((y - x) / (a - t))
else if (t <= 5.2d+31) then
tmp = x - ((t - z) / (a / y))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y + ((z / t) * (x - y));
double tmp;
if (t <= -2.6e+74) {
tmp = t_1;
} else if (t <= -7.2e+28) {
tmp = x + (z / (a / (y - x)));
} else if (t <= -4.2e-19) {
tmp = y - (((y - x) * z) / t);
} else if (t <= 1.18e-125) {
tmp = x + ((y - x) / (a / z));
} else if (t <= 3.5e-17) {
tmp = z * ((y - x) / (a - t));
} else if (t <= 5.2e+31) {
tmp = x - ((t - z) / (a / y));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y + ((z / t) * (x - y)) tmp = 0 if t <= -2.6e+74: tmp = t_1 elif t <= -7.2e+28: tmp = x + (z / (a / (y - x))) elif t <= -4.2e-19: tmp = y - (((y - x) * z) / t) elif t <= 1.18e-125: tmp = x + ((y - x) / (a / z)) elif t <= 3.5e-17: tmp = z * ((y - x) / (a - t)) elif t <= 5.2e+31: tmp = x - ((t - z) / (a / y)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(y + Float64(Float64(z / t) * Float64(x - y))) tmp = 0.0 if (t <= -2.6e+74) tmp = t_1; elseif (t <= -7.2e+28) tmp = Float64(x + Float64(z / Float64(a / Float64(y - x)))); elseif (t <= -4.2e-19) tmp = Float64(y - Float64(Float64(Float64(y - x) * z) / t)); elseif (t <= 1.18e-125) tmp = Float64(x + Float64(Float64(y - x) / Float64(a / z))); elseif (t <= 3.5e-17) tmp = Float64(z * Float64(Float64(y - x) / Float64(a - t))); elseif (t <= 5.2e+31) tmp = Float64(x - Float64(Float64(t - z) / Float64(a / y))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y + ((z / t) * (x - y)); tmp = 0.0; if (t <= -2.6e+74) tmp = t_1; elseif (t <= -7.2e+28) tmp = x + (z / (a / (y - x))); elseif (t <= -4.2e-19) tmp = y - (((y - x) * z) / t); elseif (t <= 1.18e-125) tmp = x + ((y - x) / (a / z)); elseif (t <= 3.5e-17) tmp = z * ((y - x) / (a - t)); elseif (t <= 5.2e+31) tmp = x - ((t - z) / (a / y)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y + N[(N[(z / t), $MachinePrecision] * N[(x - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.6e+74], t$95$1, If[LessEqual[t, -7.2e+28], N[(x + N[(z / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -4.2e-19], N[(y - N[(N[(N[(y - x), $MachinePrecision] * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.18e-125], N[(x + N[(N[(y - x), $MachinePrecision] / N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.5e-17], N[(z * N[(N[(y - x), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.2e+31], N[(x - N[(N[(t - z), $MachinePrecision] / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + \frac{z}{t} \cdot \left(x - y\right)\\
\mathbf{if}\;t \leq -2.6 \cdot 10^{+74}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -7.2 \cdot 10^{+28}:\\
\;\;\;\;x + \frac{z}{\frac{a}{y - x}}\\
\mathbf{elif}\;t \leq -4.2 \cdot 10^{-19}:\\
\;\;\;\;y - \frac{\left(y - x\right) \cdot z}{t}\\
\mathbf{elif}\;t \leq 1.18 \cdot 10^{-125}:\\
\;\;\;\;x + \frac{y - x}{\frac{a}{z}}\\
\mathbf{elif}\;t \leq 3.5 \cdot 10^{-17}:\\
\;\;\;\;z \cdot \frac{y - x}{a - t}\\
\mathbf{elif}\;t \leq 5.2 \cdot 10^{+31}:\\
\;\;\;\;x - \frac{t - z}{\frac{a}{y}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -2.6000000000000001e74 or 5.2e31 < t Initial program 49.0%
associate-/l*75.4%
Simplified75.4%
Taylor expanded in t around -inf 62.8%
mul-1-neg62.8%
unsub-neg62.8%
div-sub62.8%
*-commutative62.8%
div-sub62.8%
distribute-rgt-out--63.0%
Simplified63.0%
Taylor expanded in a around 0 63.7%
Taylor expanded in z around 0 63.7%
*-commutative63.7%
associate-*r/77.5%
Simplified77.5%
if -2.6000000000000001e74 < t < -7.1999999999999999e28Initial program 57.3%
associate-/l*89.0%
Simplified89.0%
Taylor expanded in t around 0 47.3%
+-commutative47.3%
*-commutative47.3%
associate-/l*79.1%
Simplified79.1%
if -7.1999999999999999e28 < t < -4.1999999999999998e-19Initial program 82.0%
associate-/l*87.8%
Simplified87.8%
Taylor expanded in t around -inf 72.0%
mul-1-neg72.0%
unsub-neg72.0%
div-sub72.0%
*-commutative72.0%
div-sub72.0%
distribute-rgt-out--72.0%
Simplified72.0%
Taylor expanded in a around 0 66.4%
if -4.1999999999999998e-19 < t < 1.17999999999999994e-125Initial program 84.8%
associate-/l*94.8%
Simplified94.8%
Taylor expanded in t around 0 80.5%
if 1.17999999999999994e-125 < t < 3.5000000000000002e-17Initial program 91.8%
associate-/l*97.4%
Simplified97.4%
Taylor expanded in z around inf 88.4%
div-sub88.4%
Simplified88.4%
if 3.5000000000000002e-17 < t < 5.2e31Initial program 89.4%
*-commutative89.4%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in y around inf 100.0%
Taylor expanded in a around inf 92.7%
Final simplification79.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (- 1.0 (/ z t)))) (t_2 (- x (/ z (/ a x)))))
(if (<= a -3.05e+65)
t_2
(if (<= a -6.3e-121)
t_1
(if (<= a -1.05e-147)
(/ (* x (- z a)) t)
(if (<= a 8.8e-281)
t_1
(if (<= a 4.7e-274)
(/ z (/ t x))
(if (<= a 3.6e+47) (- y (/ y (/ t z))) t_2))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * (1.0 - (z / t));
double t_2 = x - (z / (a / x));
double tmp;
if (a <= -3.05e+65) {
tmp = t_2;
} else if (a <= -6.3e-121) {
tmp = t_1;
} else if (a <= -1.05e-147) {
tmp = (x * (z - a)) / t;
} else if (a <= 8.8e-281) {
tmp = t_1;
} else if (a <= 4.7e-274) {
tmp = z / (t / x);
} else if (a <= 3.6e+47) {
tmp = y - (y / (t / z));
} 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 * (1.0d0 - (z / t))
t_2 = x - (z / (a / x))
if (a <= (-3.05d+65)) then
tmp = t_2
else if (a <= (-6.3d-121)) then
tmp = t_1
else if (a <= (-1.05d-147)) then
tmp = (x * (z - a)) / t
else if (a <= 8.8d-281) then
tmp = t_1
else if (a <= 4.7d-274) then
tmp = z / (t / x)
else if (a <= 3.6d+47) then
tmp = y - (y / (t / z))
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 * (1.0 - (z / t));
double t_2 = x - (z / (a / x));
double tmp;
if (a <= -3.05e+65) {
tmp = t_2;
} else if (a <= -6.3e-121) {
tmp = t_1;
} else if (a <= -1.05e-147) {
tmp = (x * (z - a)) / t;
} else if (a <= 8.8e-281) {
tmp = t_1;
} else if (a <= 4.7e-274) {
tmp = z / (t / x);
} else if (a <= 3.6e+47) {
tmp = y - (y / (t / z));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * (1.0 - (z / t)) t_2 = x - (z / (a / x)) tmp = 0 if a <= -3.05e+65: tmp = t_2 elif a <= -6.3e-121: tmp = t_1 elif a <= -1.05e-147: tmp = (x * (z - a)) / t elif a <= 8.8e-281: tmp = t_1 elif a <= 4.7e-274: tmp = z / (t / x) elif a <= 3.6e+47: tmp = y - (y / (t / z)) else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(1.0 - Float64(z / t))) t_2 = Float64(x - Float64(z / Float64(a / x))) tmp = 0.0 if (a <= -3.05e+65) tmp = t_2; elseif (a <= -6.3e-121) tmp = t_1; elseif (a <= -1.05e-147) tmp = Float64(Float64(x * Float64(z - a)) / t); elseif (a <= 8.8e-281) tmp = t_1; elseif (a <= 4.7e-274) tmp = Float64(z / Float64(t / x)); elseif (a <= 3.6e+47) tmp = Float64(y - Float64(y / Float64(t / z))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * (1.0 - (z / t)); t_2 = x - (z / (a / x)); tmp = 0.0; if (a <= -3.05e+65) tmp = t_2; elseif (a <= -6.3e-121) tmp = t_1; elseif (a <= -1.05e-147) tmp = (x * (z - a)) / t; elseif (a <= 8.8e-281) tmp = t_1; elseif (a <= 4.7e-274) tmp = z / (t / x); elseif (a <= 3.6e+47) tmp = y - (y / (t / z)); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(1.0 - N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(z / N[(a / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -3.05e+65], t$95$2, If[LessEqual[a, -6.3e-121], t$95$1, If[LessEqual[a, -1.05e-147], N[(N[(x * N[(z - a), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision], If[LessEqual[a, 8.8e-281], t$95$1, If[LessEqual[a, 4.7e-274], N[(z / N[(t / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.6e+47], N[(y - N[(y / N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(1 - \frac{z}{t}\right)\\
t_2 := x - \frac{z}{\frac{a}{x}}\\
\mathbf{if}\;a \leq -3.05 \cdot 10^{+65}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq -6.3 \cdot 10^{-121}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -1.05 \cdot 10^{-147}:\\
\;\;\;\;\frac{x \cdot \left(z - a\right)}{t}\\
\mathbf{elif}\;a \leq 8.8 \cdot 10^{-281}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 4.7 \cdot 10^{-274}:\\
\;\;\;\;\frac{z}{\frac{t}{x}}\\
\mathbf{elif}\;a \leq 3.6 \cdot 10^{+47}:\\
\;\;\;\;y - \frac{y}{\frac{t}{z}}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if a < -3.04999999999999982e65 or 3.60000000000000008e47 < a Initial program 68.2%
associate-/l*96.8%
Simplified96.8%
Taylor expanded in t around 0 57.0%
+-commutative57.0%
*-commutative57.0%
associate-/l*74.0%
Simplified74.0%
Taylor expanded in y around 0 53.4%
+-commutative53.4%
mul-1-neg53.4%
unsub-neg53.4%
associate-/l*61.5%
Simplified61.5%
if -3.04999999999999982e65 < a < -6.29999999999999961e-121 or -1.05e-147 < a < 8.80000000000000016e-281Initial program 70.0%
associate-/l*80.7%
Simplified80.7%
Taylor expanded in t around -inf 69.3%
mul-1-neg69.3%
unsub-neg69.3%
div-sub69.3%
*-commutative69.3%
div-sub69.3%
distribute-rgt-out--69.3%
Simplified69.3%
Taylor expanded in a around 0 66.9%
Taylor expanded in y around inf 58.6%
if -6.29999999999999961e-121 < a < -1.05e-147Initial program 65.5%
associate-/l*65.6%
Simplified65.6%
Taylor expanded in t around -inf 72.1%
mul-1-neg72.1%
unsub-neg72.1%
div-sub57.8%
*-commutative57.8%
div-sub72.1%
distribute-rgt-out--72.1%
Simplified72.1%
Taylor expanded in y around 0 72.1%
if 8.80000000000000016e-281 < a < 4.7000000000000004e-274Initial program 42.3%
associate-/l*74.7%
Simplified74.7%
Taylor expanded in z around inf 100.0%
div-sub100.0%
associate-*r/62.1%
Simplified62.1%
Taylor expanded in y around 0 62.1%
associate-*r/62.1%
associate-*r*62.1%
*-rgt-identity62.1%
times-frac80.9%
mul-1-neg80.9%
/-rgt-identity80.9%
Simplified80.9%
Taylor expanded in a around 0 62.1%
associate-/l*99.4%
Simplified99.4%
if 4.7000000000000004e-274 < a < 3.60000000000000008e47Initial program 73.6%
associate-/l*82.1%
Simplified82.1%
Taylor expanded in t around -inf 72.2%
mul-1-neg72.2%
unsub-neg72.2%
div-sub70.9%
*-commutative70.9%
div-sub72.2%
distribute-rgt-out--72.2%
Simplified72.2%
Taylor expanded in a around 0 71.8%
Taylor expanded in y around inf 50.7%
associate-/l*53.3%
Simplified53.3%
Final simplification59.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- x (* t (/ y a)))) (t_2 (+ y (* x (/ z t)))))
(if (<= t -8.6e-18)
t_2
(if (<= t -3e-137)
t_1
(if (<= t -1.3e-193)
(* z (/ (- y x) a))
(if (<= t 2.7e-165)
(- x (/ z (/ a x)))
(if (<= t 2.2e-36)
(/ y (/ (- a t) z))
(if (<= t 2e+32) t_1 t_2))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x - (t * (y / a));
double t_2 = y + (x * (z / t));
double tmp;
if (t <= -8.6e-18) {
tmp = t_2;
} else if (t <= -3e-137) {
tmp = t_1;
} else if (t <= -1.3e-193) {
tmp = z * ((y - x) / a);
} else if (t <= 2.7e-165) {
tmp = x - (z / (a / x));
} else if (t <= 2.2e-36) {
tmp = y / ((a - t) / z);
} else if (t <= 2e+32) {
tmp = t_1;
} 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 = x - (t * (y / a))
t_2 = y + (x * (z / t))
if (t <= (-8.6d-18)) then
tmp = t_2
else if (t <= (-3d-137)) then
tmp = t_1
else if (t <= (-1.3d-193)) then
tmp = z * ((y - x) / a)
else if (t <= 2.7d-165) then
tmp = x - (z / (a / x))
else if (t <= 2.2d-36) then
tmp = y / ((a - t) / z)
else if (t <= 2d+32) then
tmp = t_1
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 = x - (t * (y / a));
double t_2 = y + (x * (z / t));
double tmp;
if (t <= -8.6e-18) {
tmp = t_2;
} else if (t <= -3e-137) {
tmp = t_1;
} else if (t <= -1.3e-193) {
tmp = z * ((y - x) / a);
} else if (t <= 2.7e-165) {
tmp = x - (z / (a / x));
} else if (t <= 2.2e-36) {
tmp = y / ((a - t) / z);
} else if (t <= 2e+32) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x - (t * (y / a)) t_2 = y + (x * (z / t)) tmp = 0 if t <= -8.6e-18: tmp = t_2 elif t <= -3e-137: tmp = t_1 elif t <= -1.3e-193: tmp = z * ((y - x) / a) elif t <= 2.7e-165: tmp = x - (z / (a / x)) elif t <= 2.2e-36: tmp = y / ((a - t) / z) elif t <= 2e+32: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(x - Float64(t * Float64(y / a))) t_2 = Float64(y + Float64(x * Float64(z / t))) tmp = 0.0 if (t <= -8.6e-18) tmp = t_2; elseif (t <= -3e-137) tmp = t_1; elseif (t <= -1.3e-193) tmp = Float64(z * Float64(Float64(y - x) / a)); elseif (t <= 2.7e-165) tmp = Float64(x - Float64(z / Float64(a / x))); elseif (t <= 2.2e-36) tmp = Float64(y / Float64(Float64(a - t) / z)); elseif (t <= 2e+32) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x - (t * (y / a)); t_2 = y + (x * (z / t)); tmp = 0.0; if (t <= -8.6e-18) tmp = t_2; elseif (t <= -3e-137) tmp = t_1; elseif (t <= -1.3e-193) tmp = z * ((y - x) / a); elseif (t <= 2.7e-165) tmp = x - (z / (a / x)); elseif (t <= 2.2e-36) tmp = y / ((a - t) / z); elseif (t <= 2e+32) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y + N[(x * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -8.6e-18], t$95$2, If[LessEqual[t, -3e-137], t$95$1, If[LessEqual[t, -1.3e-193], N[(z * N[(N[(y - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.7e-165], N[(x - N[(z / N[(a / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.2e-36], N[(y / N[(N[(a - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2e+32], t$95$1, t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - t \cdot \frac{y}{a}\\
t_2 := y + x \cdot \frac{z}{t}\\
\mathbf{if}\;t \leq -8.6 \cdot 10^{-18}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -3 \cdot 10^{-137}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -1.3 \cdot 10^{-193}:\\
\;\;\;\;z \cdot \frac{y - x}{a}\\
\mathbf{elif}\;t \leq 2.7 \cdot 10^{-165}:\\
\;\;\;\;x - \frac{z}{\frac{a}{x}}\\
\mathbf{elif}\;t \leq 2.2 \cdot 10^{-36}:\\
\;\;\;\;\frac{y}{\frac{a - t}{z}}\\
\mathbf{elif}\;t \leq 2 \cdot 10^{+32}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -8.6000000000000005e-18 or 2.00000000000000011e32 < t Initial program 53.7%
associate-/l*77.9%
Simplified77.9%
Taylor expanded in t around -inf 62.0%
mul-1-neg62.0%
unsub-neg62.0%
div-sub62.0%
*-commutative62.0%
div-sub62.0%
distribute-rgt-out--62.1%
Simplified62.1%
Taylor expanded in a around 0 62.0%
Taylor expanded in z around 0 62.0%
*-commutative62.0%
associate-*r/73.1%
Simplified73.1%
Taylor expanded in y around 0 54.9%
mul-1-neg54.9%
associate-*l/61.4%
distribute-rgt-neg-out61.4%
Simplified61.4%
if -8.6000000000000005e-18 < t < -2.9999999999999998e-137 or 2.1999999999999999e-36 < t < 2.00000000000000011e32Initial program 80.0%
*-commutative80.0%
associate-/l*87.4%
Simplified87.4%
Taylor expanded in y around inf 75.7%
Taylor expanded in a around inf 66.2%
Taylor expanded in z around 0 54.1%
mul-1-neg54.1%
*-commutative54.1%
associate-*r/56.3%
distribute-rgt-neg-in56.3%
distribute-neg-frac56.3%
Simplified56.3%
if -2.9999999999999998e-137 < t < -1.30000000000000004e-193Initial program 91.1%
associate-/l*97.4%
Simplified97.4%
Taylor expanded in t around 0 69.6%
+-commutative69.6%
*-commutative69.6%
associate-/l*69.3%
Simplified69.3%
Taylor expanded in z around inf 69.1%
div-sub69.1%
Simplified69.1%
if -1.30000000000000004e-193 < t < 2.6999999999999998e-165Initial program 91.6%
associate-/l*98.2%
Simplified98.2%
Taylor expanded in t around 0 84.5%
+-commutative84.5%
*-commutative84.5%
associate-/l*90.1%
Simplified90.1%
Taylor expanded in y around 0 69.1%
+-commutative69.1%
mul-1-neg69.1%
unsub-neg69.1%
associate-/l*73.1%
Simplified73.1%
if 2.6999999999999998e-165 < t < 2.1999999999999999e-36Initial program 78.6%
associate-/l*93.0%
Simplified93.0%
Taylor expanded in z around inf 71.4%
div-sub71.4%
associate-*r/61.9%
Simplified61.9%
Taylor expanded in y around inf 37.4%
associate-/l*47.1%
Simplified47.1%
Final simplification62.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- x (/ z (/ a x)))) (t_2 (* y (/ (- z t) (- a t)))))
(if (<= y -7.6e-8)
t_2
(if (<= y -1.2e-159)
t_1
(if (<= y -1.12e-300)
(+ y (* x (/ z t)))
(if (<= y 2.05e-200)
t_1
(if (<= y 7e+111) (* z (/ (- y x) (- a t))) t_2)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x - (z / (a / x));
double t_2 = y * ((z - t) / (a - t));
double tmp;
if (y <= -7.6e-8) {
tmp = t_2;
} else if (y <= -1.2e-159) {
tmp = t_1;
} else if (y <= -1.12e-300) {
tmp = y + (x * (z / t));
} else if (y <= 2.05e-200) {
tmp = t_1;
} else if (y <= 7e+111) {
tmp = z * ((y - x) / (a - t));
} 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 = x - (z / (a / x))
t_2 = y * ((z - t) / (a - t))
if (y <= (-7.6d-8)) then
tmp = t_2
else if (y <= (-1.2d-159)) then
tmp = t_1
else if (y <= (-1.12d-300)) then
tmp = y + (x * (z / t))
else if (y <= 2.05d-200) then
tmp = t_1
else if (y <= 7d+111) then
tmp = z * ((y - x) / (a - t))
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 = x - (z / (a / x));
double t_2 = y * ((z - t) / (a - t));
double tmp;
if (y <= -7.6e-8) {
tmp = t_2;
} else if (y <= -1.2e-159) {
tmp = t_1;
} else if (y <= -1.12e-300) {
tmp = y + (x * (z / t));
} else if (y <= 2.05e-200) {
tmp = t_1;
} else if (y <= 7e+111) {
tmp = z * ((y - x) / (a - t));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x - (z / (a / x)) t_2 = y * ((z - t) / (a - t)) tmp = 0 if y <= -7.6e-8: tmp = t_2 elif y <= -1.2e-159: tmp = t_1 elif y <= -1.12e-300: tmp = y + (x * (z / t)) elif y <= 2.05e-200: tmp = t_1 elif y <= 7e+111: tmp = z * ((y - x) / (a - t)) else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(x - Float64(z / Float64(a / x))) t_2 = Float64(y * Float64(Float64(z - t) / Float64(a - t))) tmp = 0.0 if (y <= -7.6e-8) tmp = t_2; elseif (y <= -1.2e-159) tmp = t_1; elseif (y <= -1.12e-300) tmp = Float64(y + Float64(x * Float64(z / t))); elseif (y <= 2.05e-200) tmp = t_1; elseif (y <= 7e+111) tmp = Float64(z * Float64(Float64(y - x) / Float64(a - t))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x - (z / (a / x)); t_2 = y * ((z - t) / (a - t)); tmp = 0.0; if (y <= -7.6e-8) tmp = t_2; elseif (y <= -1.2e-159) tmp = t_1; elseif (y <= -1.12e-300) tmp = y + (x * (z / t)); elseif (y <= 2.05e-200) tmp = t_1; elseif (y <= 7e+111) tmp = z * ((y - x) / (a - t)); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(z / N[(a / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -7.6e-8], t$95$2, If[LessEqual[y, -1.2e-159], t$95$1, If[LessEqual[y, -1.12e-300], N[(y + N[(x * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.05e-200], t$95$1, If[LessEqual[y, 7e+111], N[(z * N[(N[(y - x), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - \frac{z}{\frac{a}{x}}\\
t_2 := y \cdot \frac{z - t}{a - t}\\
\mathbf{if}\;y \leq -7.6 \cdot 10^{-8}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -1.2 \cdot 10^{-159}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -1.12 \cdot 10^{-300}:\\
\;\;\;\;y + x \cdot \frac{z}{t}\\
\mathbf{elif}\;y \leq 2.05 \cdot 10^{-200}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 7 \cdot 10^{+111}:\\
\;\;\;\;z \cdot \frac{y - x}{a - t}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if y < -7.60000000000000056e-8 or 7.0000000000000004e111 < y Initial program 64.6%
associate-/l*91.7%
Simplified91.7%
Taylor expanded in x around 0 54.3%
associate-*r/79.7%
Simplified79.7%
if -7.60000000000000056e-8 < y < -1.19999999999999999e-159 or -1.12e-300 < y < 2.04999999999999993e-200Initial program 73.5%
associate-/l*82.9%
Simplified82.9%
Taylor expanded in t around 0 58.0%
+-commutative58.0%
*-commutative58.0%
associate-/l*63.7%
Simplified63.7%
Taylor expanded in y around 0 58.0%
+-commutative58.0%
mul-1-neg58.0%
unsub-neg58.0%
associate-/l*63.7%
Simplified63.7%
if -1.19999999999999999e-159 < y < -1.12e-300Initial program 66.3%
associate-/l*75.8%
Simplified75.8%
Taylor expanded in t around -inf 72.9%
mul-1-neg72.9%
unsub-neg72.9%
div-sub72.9%
*-commutative72.9%
div-sub72.9%
distribute-rgt-out--72.9%
Simplified72.9%
Taylor expanded in a around 0 62.9%
Taylor expanded in z around 0 62.9%
*-commutative62.9%
associate-*r/60.3%
Simplified60.3%
Taylor expanded in y around 0 59.4%
mul-1-neg59.4%
associate-*l/56.4%
distribute-rgt-neg-out56.4%
Simplified56.4%
if 2.04999999999999993e-200 < y < 7.0000000000000004e111Initial program 76.4%
associate-/l*86.1%
Simplified86.1%
Taylor expanded in z around inf 56.9%
div-sub56.9%
Simplified56.9%
Final simplification67.7%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* z (/ (- y x) a))))
(if (<= t -6.2e+21)
y
(if (<= t -1.8e-130)
x
(if (<= t 7.4e-221)
t_1
(if (<= t 2.35e-166)
x
(if (<= t 2.3e-17) t_1 (if (<= t 1.05e+153) (+ x y) y))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = z * ((y - x) / a);
double tmp;
if (t <= -6.2e+21) {
tmp = y;
} else if (t <= -1.8e-130) {
tmp = x;
} else if (t <= 7.4e-221) {
tmp = t_1;
} else if (t <= 2.35e-166) {
tmp = x;
} else if (t <= 2.3e-17) {
tmp = t_1;
} else if (t <= 1.05e+153) {
tmp = x + y;
} 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 - x) / a)
if (t <= (-6.2d+21)) then
tmp = y
else if (t <= (-1.8d-130)) then
tmp = x
else if (t <= 7.4d-221) then
tmp = t_1
else if (t <= 2.35d-166) then
tmp = x
else if (t <= 2.3d-17) then
tmp = t_1
else if (t <= 1.05d+153) then
tmp = x + y
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 - x) / a);
double tmp;
if (t <= -6.2e+21) {
tmp = y;
} else if (t <= -1.8e-130) {
tmp = x;
} else if (t <= 7.4e-221) {
tmp = t_1;
} else if (t <= 2.35e-166) {
tmp = x;
} else if (t <= 2.3e-17) {
tmp = t_1;
} else if (t <= 1.05e+153) {
tmp = x + y;
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = z * ((y - x) / a) tmp = 0 if t <= -6.2e+21: tmp = y elif t <= -1.8e-130: tmp = x elif t <= 7.4e-221: tmp = t_1 elif t <= 2.35e-166: tmp = x elif t <= 2.3e-17: tmp = t_1 elif t <= 1.05e+153: tmp = x + y else: tmp = y return tmp
function code(x, y, z, t, a) t_1 = Float64(z * Float64(Float64(y - x) / a)) tmp = 0.0 if (t <= -6.2e+21) tmp = y; elseif (t <= -1.8e-130) tmp = x; elseif (t <= 7.4e-221) tmp = t_1; elseif (t <= 2.35e-166) tmp = x; elseif (t <= 2.3e-17) tmp = t_1; elseif (t <= 1.05e+153) tmp = Float64(x + y); else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = z * ((y - x) / a); tmp = 0.0; if (t <= -6.2e+21) tmp = y; elseif (t <= -1.8e-130) tmp = x; elseif (t <= 7.4e-221) tmp = t_1; elseif (t <= 2.35e-166) tmp = x; elseif (t <= 2.3e-17) tmp = t_1; elseif (t <= 1.05e+153) tmp = x + y; else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(z * N[(N[(y - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -6.2e+21], y, If[LessEqual[t, -1.8e-130], x, If[LessEqual[t, 7.4e-221], t$95$1, If[LessEqual[t, 2.35e-166], x, If[LessEqual[t, 2.3e-17], t$95$1, If[LessEqual[t, 1.05e+153], N[(x + y), $MachinePrecision], y]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \frac{y - x}{a}\\
\mathbf{if}\;t \leq -6.2 \cdot 10^{+21}:\\
\;\;\;\;y\\
\mathbf{elif}\;t \leq -1.8 \cdot 10^{-130}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 7.4 \cdot 10^{-221}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 2.35 \cdot 10^{-166}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 2.3 \cdot 10^{-17}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 1.05 \cdot 10^{+153}:\\
\;\;\;\;x + y\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -6.2e21 or 1.05000000000000008e153 < t Initial program 47.0%
associate-/l*74.5%
Simplified74.5%
Taylor expanded in t around inf 49.5%
if -6.2e21 < t < -1.8000000000000001e-130 or 7.39999999999999971e-221 < t < 2.35000000000000007e-166Initial program 80.7%
associate-/l*92.7%
Simplified92.7%
Taylor expanded in a around inf 44.5%
if -1.8000000000000001e-130 < t < 7.39999999999999971e-221 or 2.35000000000000007e-166 < t < 2.30000000000000009e-17Initial program 89.3%
associate-/l*96.5%
Simplified96.5%
Taylor expanded in t around 0 73.0%
+-commutative73.0%
*-commutative73.0%
associate-/l*78.0%
Simplified78.0%
Taylor expanded in z around inf 53.6%
div-sub56.2%
Simplified56.2%
if 2.30000000000000009e-17 < t < 1.05000000000000008e153Initial program 70.3%
*-commutative70.3%
associate-/l*88.0%
Simplified88.0%
Taylor expanded in y around inf 73.4%
Taylor expanded in t around inf 41.1%
Final simplification49.4%
(FPCore (x y z t a)
:precision binary64
(if (<= a -3.5e+65)
x
(if (<= a 3.7e-283)
y
(if (<= a 1.2e-273)
(/ z (/ t x))
(if (<= a 2.9e-213) y (if (<= a 5.6e-76) (* z (/ (- y) t)) (+ x y)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -3.5e+65) {
tmp = x;
} else if (a <= 3.7e-283) {
tmp = y;
} else if (a <= 1.2e-273) {
tmp = z / (t / x);
} else if (a <= 2.9e-213) {
tmp = y;
} else if (a <= 5.6e-76) {
tmp = z * (-y / t);
} else {
tmp = x + 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 (a <= (-3.5d+65)) then
tmp = x
else if (a <= 3.7d-283) then
tmp = y
else if (a <= 1.2d-273) then
tmp = z / (t / x)
else if (a <= 2.9d-213) then
tmp = y
else if (a <= 5.6d-76) then
tmp = z * (-y / t)
else
tmp = x + y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -3.5e+65) {
tmp = x;
} else if (a <= 3.7e-283) {
tmp = y;
} else if (a <= 1.2e-273) {
tmp = z / (t / x);
} else if (a <= 2.9e-213) {
tmp = y;
} else if (a <= 5.6e-76) {
tmp = z * (-y / t);
} else {
tmp = x + y;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -3.5e+65: tmp = x elif a <= 3.7e-283: tmp = y elif a <= 1.2e-273: tmp = z / (t / x) elif a <= 2.9e-213: tmp = y elif a <= 5.6e-76: tmp = z * (-y / t) else: tmp = x + y return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -3.5e+65) tmp = x; elseif (a <= 3.7e-283) tmp = y; elseif (a <= 1.2e-273) tmp = Float64(z / Float64(t / x)); elseif (a <= 2.9e-213) tmp = y; elseif (a <= 5.6e-76) tmp = Float64(z * Float64(Float64(-y) / t)); else tmp = Float64(x + y); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -3.5e+65) tmp = x; elseif (a <= 3.7e-283) tmp = y; elseif (a <= 1.2e-273) tmp = z / (t / x); elseif (a <= 2.9e-213) tmp = y; elseif (a <= 5.6e-76) tmp = z * (-y / t); else tmp = x + y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -3.5e+65], x, If[LessEqual[a, 3.7e-283], y, If[LessEqual[a, 1.2e-273], N[(z / N[(t / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.9e-213], y, If[LessEqual[a, 5.6e-76], N[(z * N[((-y) / t), $MachinePrecision]), $MachinePrecision], N[(x + y), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -3.5 \cdot 10^{+65}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 3.7 \cdot 10^{-283}:\\
\;\;\;\;y\\
\mathbf{elif}\;a \leq 1.2 \cdot 10^{-273}:\\
\;\;\;\;\frac{z}{\frac{t}{x}}\\
\mathbf{elif}\;a \leq 2.9 \cdot 10^{-213}:\\
\;\;\;\;y\\
\mathbf{elif}\;a \leq 5.6 \cdot 10^{-76}:\\
\;\;\;\;z \cdot \frac{-y}{t}\\
\mathbf{else}:\\
\;\;\;\;x + y\\
\end{array}
\end{array}
if a < -3.5000000000000001e65Initial program 65.8%
associate-/l*96.0%
Simplified96.0%
Taylor expanded in a around inf 57.3%
if -3.5000000000000001e65 < a < 3.7e-283 or 1.19999999999999991e-273 < a < 2.8999999999999999e-213Initial program 68.5%
associate-/l*78.2%
Simplified78.2%
Taylor expanded in t around inf 37.8%
if 3.7e-283 < a < 1.19999999999999991e-273Initial program 42.3%
associate-/l*74.7%
Simplified74.7%
Taylor expanded in z around inf 100.0%
div-sub100.0%
associate-*r/62.1%
Simplified62.1%
Taylor expanded in y around 0 62.1%
associate-*r/62.1%
associate-*r*62.1%
*-rgt-identity62.1%
times-frac80.9%
mul-1-neg80.9%
/-rgt-identity80.9%
Simplified80.9%
Taylor expanded in a around 0 62.1%
associate-/l*99.4%
Simplified99.4%
if 2.8999999999999999e-213 < a < 5.6000000000000002e-76Initial program 77.1%
associate-/l*82.6%
Simplified82.6%
Taylor expanded in z around inf 72.2%
div-sub72.2%
associate-*r/69.8%
Simplified69.8%
Taylor expanded in y around inf 39.2%
Taylor expanded in a around 0 33.4%
mul-1-neg33.4%
associate-/l*36.0%
associate-/r/35.8%
distribute-rgt-neg-in35.8%
Simplified35.8%
if 5.6000000000000002e-76 < a Initial program 72.6%
*-commutative72.6%
associate-/l*88.9%
Simplified88.9%
Taylor expanded in y around inf 73.3%
Taylor expanded in t around inf 44.7%
Final simplification44.4%
(FPCore (x y z t a)
:precision binary64
(if (<= a -2.9e+65)
x
(if (<= a 1.05e-281)
y
(if (<= a 1.12e-271)
(/ z (/ t x))
(if (<= a 3.5e-213) y (if (<= a 1.1e-75) (* (/ z t) (- y)) (+ x y)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -2.9e+65) {
tmp = x;
} else if (a <= 1.05e-281) {
tmp = y;
} else if (a <= 1.12e-271) {
tmp = z / (t / x);
} else if (a <= 3.5e-213) {
tmp = y;
} else if (a <= 1.1e-75) {
tmp = (z / t) * -y;
} else {
tmp = x + 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 (a <= (-2.9d+65)) then
tmp = x
else if (a <= 1.05d-281) then
tmp = y
else if (a <= 1.12d-271) then
tmp = z / (t / x)
else if (a <= 3.5d-213) then
tmp = y
else if (a <= 1.1d-75) then
tmp = (z / t) * -y
else
tmp = x + y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -2.9e+65) {
tmp = x;
} else if (a <= 1.05e-281) {
tmp = y;
} else if (a <= 1.12e-271) {
tmp = z / (t / x);
} else if (a <= 3.5e-213) {
tmp = y;
} else if (a <= 1.1e-75) {
tmp = (z / t) * -y;
} else {
tmp = x + y;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -2.9e+65: tmp = x elif a <= 1.05e-281: tmp = y elif a <= 1.12e-271: tmp = z / (t / x) elif a <= 3.5e-213: tmp = y elif a <= 1.1e-75: tmp = (z / t) * -y else: tmp = x + y return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -2.9e+65) tmp = x; elseif (a <= 1.05e-281) tmp = y; elseif (a <= 1.12e-271) tmp = Float64(z / Float64(t / x)); elseif (a <= 3.5e-213) tmp = y; elseif (a <= 1.1e-75) tmp = Float64(Float64(z / t) * Float64(-y)); else tmp = Float64(x + y); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -2.9e+65) tmp = x; elseif (a <= 1.05e-281) tmp = y; elseif (a <= 1.12e-271) tmp = z / (t / x); elseif (a <= 3.5e-213) tmp = y; elseif (a <= 1.1e-75) tmp = (z / t) * -y; else tmp = x + y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -2.9e+65], x, If[LessEqual[a, 1.05e-281], y, If[LessEqual[a, 1.12e-271], N[(z / N[(t / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.5e-213], y, If[LessEqual[a, 1.1e-75], N[(N[(z / t), $MachinePrecision] * (-y)), $MachinePrecision], N[(x + y), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -2.9 \cdot 10^{+65}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 1.05 \cdot 10^{-281}:\\
\;\;\;\;y\\
\mathbf{elif}\;a \leq 1.12 \cdot 10^{-271}:\\
\;\;\;\;\frac{z}{\frac{t}{x}}\\
\mathbf{elif}\;a \leq 3.5 \cdot 10^{-213}:\\
\;\;\;\;y\\
\mathbf{elif}\;a \leq 1.1 \cdot 10^{-75}:\\
\;\;\;\;\frac{z}{t} \cdot \left(-y\right)\\
\mathbf{else}:\\
\;\;\;\;x + y\\
\end{array}
\end{array}
if a < -2.9e65Initial program 65.8%
associate-/l*96.0%
Simplified96.0%
Taylor expanded in a around inf 57.3%
if -2.9e65 < a < 1.0499999999999999e-281 or 1.11999999999999997e-271 < a < 3.50000000000000017e-213Initial program 68.5%
associate-/l*78.2%
Simplified78.2%
Taylor expanded in t around inf 37.8%
if 1.0499999999999999e-281 < a < 1.11999999999999997e-271Initial program 42.3%
associate-/l*74.7%
Simplified74.7%
Taylor expanded in z around inf 100.0%
div-sub100.0%
associate-*r/62.1%
Simplified62.1%
Taylor expanded in y around 0 62.1%
associate-*r/62.1%
associate-*r*62.1%
*-rgt-identity62.1%
times-frac80.9%
mul-1-neg80.9%
/-rgt-identity80.9%
Simplified80.9%
Taylor expanded in a around 0 62.1%
associate-/l*99.4%
Simplified99.4%
if 3.50000000000000017e-213 < a < 1.10000000000000003e-75Initial program 77.1%
associate-/l*82.6%
Simplified82.6%
Taylor expanded in z around inf 72.2%
div-sub72.2%
associate-*r/69.8%
Simplified69.8%
Taylor expanded in y around inf 39.2%
Taylor expanded in a around 0 33.4%
mul-1-neg33.4%
associate-/l*36.0%
associate-/r/35.8%
distribute-rgt-neg-in35.8%
Simplified35.8%
Taylor expanded in y around 0 33.4%
mul-1-neg33.4%
associate-*r/35.9%
*-commutative35.9%
distribute-rgt-neg-in35.9%
Simplified35.9%
if 1.10000000000000003e-75 < a Initial program 72.6%
*-commutative72.6%
associate-/l*88.9%
Simplified88.9%
Taylor expanded in y around inf 73.3%
Taylor expanded in t around inf 44.7%
Final simplification44.4%
(FPCore (x y z t a)
:precision binary64
(if (<= a -5.2e+65)
x
(if (<= a 1.9e-282)
y
(if (<= a 4e-271)
(/ z (/ t x))
(if (<= a 1.4e-216)
y
(if (<= a 3.35e-102)
(* x (/ z t))
(if (<= a 4.6e+212) (+ x y) x)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -5.2e+65) {
tmp = x;
} else if (a <= 1.9e-282) {
tmp = y;
} else if (a <= 4e-271) {
tmp = z / (t / x);
} else if (a <= 1.4e-216) {
tmp = y;
} else if (a <= 3.35e-102) {
tmp = x * (z / t);
} else if (a <= 4.6e+212) {
tmp = x + y;
} else {
tmp = x;
}
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 <= (-5.2d+65)) then
tmp = x
else if (a <= 1.9d-282) then
tmp = y
else if (a <= 4d-271) then
tmp = z / (t / x)
else if (a <= 1.4d-216) then
tmp = y
else if (a <= 3.35d-102) then
tmp = x * (z / t)
else if (a <= 4.6d+212) then
tmp = x + y
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -5.2e+65) {
tmp = x;
} else if (a <= 1.9e-282) {
tmp = y;
} else if (a <= 4e-271) {
tmp = z / (t / x);
} else if (a <= 1.4e-216) {
tmp = y;
} else if (a <= 3.35e-102) {
tmp = x * (z / t);
} else if (a <= 4.6e+212) {
tmp = x + y;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -5.2e+65: tmp = x elif a <= 1.9e-282: tmp = y elif a <= 4e-271: tmp = z / (t / x) elif a <= 1.4e-216: tmp = y elif a <= 3.35e-102: tmp = x * (z / t) elif a <= 4.6e+212: tmp = x + y else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -5.2e+65) tmp = x; elseif (a <= 1.9e-282) tmp = y; elseif (a <= 4e-271) tmp = Float64(z / Float64(t / x)); elseif (a <= 1.4e-216) tmp = y; elseif (a <= 3.35e-102) tmp = Float64(x * Float64(z / t)); elseif (a <= 4.6e+212) tmp = Float64(x + y); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -5.2e+65) tmp = x; elseif (a <= 1.9e-282) tmp = y; elseif (a <= 4e-271) tmp = z / (t / x); elseif (a <= 1.4e-216) tmp = y; elseif (a <= 3.35e-102) tmp = x * (z / t); elseif (a <= 4.6e+212) tmp = x + y; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -5.2e+65], x, If[LessEqual[a, 1.9e-282], y, If[LessEqual[a, 4e-271], N[(z / N[(t / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.4e-216], y, If[LessEqual[a, 3.35e-102], N[(x * N[(z / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 4.6e+212], N[(x + y), $MachinePrecision], x]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -5.2 \cdot 10^{+65}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 1.9 \cdot 10^{-282}:\\
\;\;\;\;y\\
\mathbf{elif}\;a \leq 4 \cdot 10^{-271}:\\
\;\;\;\;\frac{z}{\frac{t}{x}}\\
\mathbf{elif}\;a \leq 1.4 \cdot 10^{-216}:\\
\;\;\;\;y\\
\mathbf{elif}\;a \leq 3.35 \cdot 10^{-102}:\\
\;\;\;\;x \cdot \frac{z}{t}\\
\mathbf{elif}\;a \leq 4.6 \cdot 10^{+212}:\\
\;\;\;\;x + y\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -5.20000000000000005e65 or 4.5999999999999997e212 < a Initial program 65.9%
associate-/l*97.0%
Simplified97.0%
Taylor expanded in a around inf 58.2%
if -5.20000000000000005e65 < a < 1.89999999999999996e-282 or 3.99999999999999985e-271 < a < 1.4e-216Initial program 69.0%
associate-/l*79.0%
Simplified79.0%
Taylor expanded in t around inf 38.4%
if 1.89999999999999996e-282 < a < 3.99999999999999985e-271Initial program 42.3%
associate-/l*74.7%
Simplified74.7%
Taylor expanded in z around inf 100.0%
div-sub100.0%
associate-*r/62.1%
Simplified62.1%
Taylor expanded in y around 0 62.1%
associate-*r/62.1%
associate-*r*62.1%
*-rgt-identity62.1%
times-frac80.9%
mul-1-neg80.9%
/-rgt-identity80.9%
Simplified80.9%
Taylor expanded in a around 0 62.1%
associate-/l*99.4%
Simplified99.4%
if 1.4e-216 < a < 3.35e-102Initial program 72.8%
associate-/l*79.3%
Simplified79.3%
Taylor expanded in z around inf 74.0%
div-sub74.0%
associate-*r/71.1%
Simplified71.1%
Taylor expanded in y around 0 44.9%
associate-*r/44.9%
associate-*r*44.9%
*-rgt-identity44.9%
times-frac45.0%
mul-1-neg45.0%
/-rgt-identity45.0%
Simplified45.0%
Taylor expanded in a around 0 35.5%
if 3.35e-102 < a < 4.5999999999999997e212Initial program 76.0%
*-commutative76.0%
associate-/l*87.0%
Simplified87.0%
Taylor expanded in y around inf 68.6%
Taylor expanded in t around inf 41.4%
Final simplification45.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (- 1.0 (/ z t)))))
(if (<= a -6.2e+65)
x
(if (<= a 5.5e-281)
t_1
(if (<= a 1.25e-275) (/ z (/ t x)) (if (<= a 4e+49) t_1 x))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * (1.0 - (z / t));
double tmp;
if (a <= -6.2e+65) {
tmp = x;
} else if (a <= 5.5e-281) {
tmp = t_1;
} else if (a <= 1.25e-275) {
tmp = z / (t / x);
} else if (a <= 4e+49) {
tmp = t_1;
} else {
tmp = x;
}
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 * (1.0d0 - (z / t))
if (a <= (-6.2d+65)) then
tmp = x
else if (a <= 5.5d-281) then
tmp = t_1
else if (a <= 1.25d-275) then
tmp = z / (t / x)
else if (a <= 4d+49) then
tmp = t_1
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y * (1.0 - (z / t));
double tmp;
if (a <= -6.2e+65) {
tmp = x;
} else if (a <= 5.5e-281) {
tmp = t_1;
} else if (a <= 1.25e-275) {
tmp = z / (t / x);
} else if (a <= 4e+49) {
tmp = t_1;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * (1.0 - (z / t)) tmp = 0 if a <= -6.2e+65: tmp = x elif a <= 5.5e-281: tmp = t_1 elif a <= 1.25e-275: tmp = z / (t / x) elif a <= 4e+49: tmp = t_1 else: tmp = x return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(1.0 - Float64(z / t))) tmp = 0.0 if (a <= -6.2e+65) tmp = x; elseif (a <= 5.5e-281) tmp = t_1; elseif (a <= 1.25e-275) tmp = Float64(z / Float64(t / x)); elseif (a <= 4e+49) tmp = t_1; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * (1.0 - (z / t)); tmp = 0.0; if (a <= -6.2e+65) tmp = x; elseif (a <= 5.5e-281) tmp = t_1; elseif (a <= 1.25e-275) tmp = z / (t / x); elseif (a <= 4e+49) tmp = t_1; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(1.0 - N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -6.2e+65], x, If[LessEqual[a, 5.5e-281], t$95$1, If[LessEqual[a, 1.25e-275], N[(z / N[(t / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 4e+49], t$95$1, x]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(1 - \frac{z}{t}\right)\\
\mathbf{if}\;a \leq -6.2 \cdot 10^{+65}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 5.5 \cdot 10^{-281}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 1.25 \cdot 10^{-275}:\\
\;\;\;\;\frac{z}{\frac{t}{x}}\\
\mathbf{elif}\;a \leq 4 \cdot 10^{+49}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -6.19999999999999981e65 or 3.99999999999999979e49 < a Initial program 68.2%
associate-/l*96.8%
Simplified96.8%
Taylor expanded in a around inf 54.8%
if -6.19999999999999981e65 < a < 5.5000000000000003e-281 or 1.24999999999999996e-275 < a < 3.99999999999999979e49Initial program 71.6%
associate-/l*80.7%
Simplified80.7%
Taylor expanded in t around -inf 70.9%
mul-1-neg70.9%
unsub-neg70.9%
div-sub69.6%
*-commutative69.6%
div-sub70.9%
distribute-rgt-out--70.9%
Simplified70.9%
Taylor expanded in a around 0 68.3%
Taylor expanded in y around inf 53.4%
if 5.5000000000000003e-281 < a < 1.24999999999999996e-275Initial program 42.3%
associate-/l*74.7%
Simplified74.7%
Taylor expanded in z around inf 100.0%
div-sub100.0%
associate-*r/62.1%
Simplified62.1%
Taylor expanded in y around 0 62.1%
associate-*r/62.1%
associate-*r*62.1%
*-rgt-identity62.1%
times-frac80.9%
mul-1-neg80.9%
/-rgt-identity80.9%
Simplified80.9%
Taylor expanded in a around 0 62.1%
associate-/l*99.4%
Simplified99.4%
Final simplification54.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (- 1.0 (/ z t)))) (t_2 (- x (/ z (/ a x)))))
(if (<= a -3.9e+65)
t_2
(if (<= a 1.08e-280)
t_1
(if (<= a 1.25e-275) (/ z (/ t x)) (if (<= a 1.4e+46) t_1 t_2))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * (1.0 - (z / t));
double t_2 = x - (z / (a / x));
double tmp;
if (a <= -3.9e+65) {
tmp = t_2;
} else if (a <= 1.08e-280) {
tmp = t_1;
} else if (a <= 1.25e-275) {
tmp = z / (t / x);
} else if (a <= 1.4e+46) {
tmp = t_1;
} 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 * (1.0d0 - (z / t))
t_2 = x - (z / (a / x))
if (a <= (-3.9d+65)) then
tmp = t_2
else if (a <= 1.08d-280) then
tmp = t_1
else if (a <= 1.25d-275) then
tmp = z / (t / x)
else if (a <= 1.4d+46) then
tmp = t_1
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 * (1.0 - (z / t));
double t_2 = x - (z / (a / x));
double tmp;
if (a <= -3.9e+65) {
tmp = t_2;
} else if (a <= 1.08e-280) {
tmp = t_1;
} else if (a <= 1.25e-275) {
tmp = z / (t / x);
} else if (a <= 1.4e+46) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * (1.0 - (z / t)) t_2 = x - (z / (a / x)) tmp = 0 if a <= -3.9e+65: tmp = t_2 elif a <= 1.08e-280: tmp = t_1 elif a <= 1.25e-275: tmp = z / (t / x) elif a <= 1.4e+46: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(1.0 - Float64(z / t))) t_2 = Float64(x - Float64(z / Float64(a / x))) tmp = 0.0 if (a <= -3.9e+65) tmp = t_2; elseif (a <= 1.08e-280) tmp = t_1; elseif (a <= 1.25e-275) tmp = Float64(z / Float64(t / x)); elseif (a <= 1.4e+46) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * (1.0 - (z / t)); t_2 = x - (z / (a / x)); tmp = 0.0; if (a <= -3.9e+65) tmp = t_2; elseif (a <= 1.08e-280) tmp = t_1; elseif (a <= 1.25e-275) tmp = z / (t / x); elseif (a <= 1.4e+46) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(1.0 - N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(z / N[(a / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -3.9e+65], t$95$2, If[LessEqual[a, 1.08e-280], t$95$1, If[LessEqual[a, 1.25e-275], N[(z / N[(t / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.4e+46], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(1 - \frac{z}{t}\right)\\
t_2 := x - \frac{z}{\frac{a}{x}}\\
\mathbf{if}\;a \leq -3.9 \cdot 10^{+65}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq 1.08 \cdot 10^{-280}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 1.25 \cdot 10^{-275}:\\
\;\;\;\;\frac{z}{\frac{t}{x}}\\
\mathbf{elif}\;a \leq 1.4 \cdot 10^{+46}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if a < -3.8999999999999998e65 or 1.40000000000000009e46 < a Initial program 68.2%
associate-/l*96.8%
Simplified96.8%
Taylor expanded in t around 0 57.0%
+-commutative57.0%
*-commutative57.0%
associate-/l*74.0%
Simplified74.0%
Taylor expanded in y around 0 53.4%
+-commutative53.4%
mul-1-neg53.4%
unsub-neg53.4%
associate-/l*61.5%
Simplified61.5%
if -3.8999999999999998e65 < a < 1.07999999999999996e-280 or 1.24999999999999996e-275 < a < 1.40000000000000009e46Initial program 71.6%
associate-/l*80.7%
Simplified80.7%
Taylor expanded in t around -inf 70.9%
mul-1-neg70.9%
unsub-neg70.9%
div-sub69.6%
*-commutative69.6%
div-sub70.9%
distribute-rgt-out--70.9%
Simplified70.9%
Taylor expanded in a around 0 68.3%
Taylor expanded in y around inf 53.4%
if 1.07999999999999996e-280 < a < 1.24999999999999996e-275Initial program 42.3%
associate-/l*74.7%
Simplified74.7%
Taylor expanded in z around inf 100.0%
div-sub100.0%
associate-*r/62.1%
Simplified62.1%
Taylor expanded in y around 0 62.1%
associate-*r/62.1%
associate-*r*62.1%
*-rgt-identity62.1%
times-frac80.9%
mul-1-neg80.9%
/-rgt-identity80.9%
Simplified80.9%
Taylor expanded in a around 0 62.1%
associate-/l*99.4%
Simplified99.4%
Final simplification57.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- x (/ z (/ a x)))))
(if (<= a -3.5e+65)
t_1
(if (<= a 2.4e-282)
(* y (- 1.0 (/ z t)))
(if (<= a 9.8e-275)
(/ z (/ t x))
(if (<= a 6e+48) (- y (/ y (/ t z))) t_1))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x - (z / (a / x));
double tmp;
if (a <= -3.5e+65) {
tmp = t_1;
} else if (a <= 2.4e-282) {
tmp = y * (1.0 - (z / t));
} else if (a <= 9.8e-275) {
tmp = z / (t / x);
} else if (a <= 6e+48) {
tmp = y - (y / (t / z));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x - (z / (a / x))
if (a <= (-3.5d+65)) then
tmp = t_1
else if (a <= 2.4d-282) then
tmp = y * (1.0d0 - (z / t))
else if (a <= 9.8d-275) then
tmp = z / (t / x)
else if (a <= 6d+48) then
tmp = y - (y / (t / z))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x - (z / (a / x));
double tmp;
if (a <= -3.5e+65) {
tmp = t_1;
} else if (a <= 2.4e-282) {
tmp = y * (1.0 - (z / t));
} else if (a <= 9.8e-275) {
tmp = z / (t / x);
} else if (a <= 6e+48) {
tmp = y - (y / (t / z));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x - (z / (a / x)) tmp = 0 if a <= -3.5e+65: tmp = t_1 elif a <= 2.4e-282: tmp = y * (1.0 - (z / t)) elif a <= 9.8e-275: tmp = z / (t / x) elif a <= 6e+48: tmp = y - (y / (t / z)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(x - Float64(z / Float64(a / x))) tmp = 0.0 if (a <= -3.5e+65) tmp = t_1; elseif (a <= 2.4e-282) tmp = Float64(y * Float64(1.0 - Float64(z / t))); elseif (a <= 9.8e-275) tmp = Float64(z / Float64(t / x)); elseif (a <= 6e+48) tmp = Float64(y - Float64(y / Float64(t / z))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x - (z / (a / x)); tmp = 0.0; if (a <= -3.5e+65) tmp = t_1; elseif (a <= 2.4e-282) tmp = y * (1.0 - (z / t)); elseif (a <= 9.8e-275) tmp = z / (t / x); elseif (a <= 6e+48) tmp = y - (y / (t / z)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(z / N[(a / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -3.5e+65], t$95$1, If[LessEqual[a, 2.4e-282], N[(y * N[(1.0 - N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 9.8e-275], N[(z / N[(t / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 6e+48], N[(y - N[(y / N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - \frac{z}{\frac{a}{x}}\\
\mathbf{if}\;a \leq -3.5 \cdot 10^{+65}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 2.4 \cdot 10^{-282}:\\
\;\;\;\;y \cdot \left(1 - \frac{z}{t}\right)\\
\mathbf{elif}\;a \leq 9.8 \cdot 10^{-275}:\\
\;\;\;\;\frac{z}{\frac{t}{x}}\\
\mathbf{elif}\;a \leq 6 \cdot 10^{+48}:\\
\;\;\;\;y - \frac{y}{\frac{t}{z}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if a < -3.5000000000000001e65 or 5.9999999999999999e48 < a Initial program 68.2%
associate-/l*96.8%
Simplified96.8%
Taylor expanded in t around 0 57.0%
+-commutative57.0%
*-commutative57.0%
associate-/l*74.0%
Simplified74.0%
Taylor expanded in y around 0 53.4%
+-commutative53.4%
mul-1-neg53.4%
unsub-neg53.4%
associate-/l*61.5%
Simplified61.5%
if -3.5000000000000001e65 < a < 2.39999999999999997e-282Initial program 69.6%
associate-/l*79.3%
Simplified79.3%
Taylor expanded in t around -inf 69.6%
mul-1-neg69.6%
unsub-neg69.6%
div-sub68.3%
*-commutative68.3%
div-sub69.6%
distribute-rgt-out--69.6%
Simplified69.6%
Taylor expanded in a around 0 64.8%
Taylor expanded in y around inf 53.5%
if 2.39999999999999997e-282 < a < 9.79999999999999964e-275Initial program 42.3%
associate-/l*74.7%
Simplified74.7%
Taylor expanded in z around inf 100.0%
div-sub100.0%
associate-*r/62.1%
Simplified62.1%
Taylor expanded in y around 0 62.1%
associate-*r/62.1%
associate-*r*62.1%
*-rgt-identity62.1%
times-frac80.9%
mul-1-neg80.9%
/-rgt-identity80.9%
Simplified80.9%
Taylor expanded in a around 0 62.1%
associate-/l*99.4%
Simplified99.4%
if 9.79999999999999964e-275 < a < 5.9999999999999999e48Initial program 73.6%
associate-/l*82.1%
Simplified82.1%
Taylor expanded in t around -inf 72.2%
mul-1-neg72.2%
unsub-neg72.2%
div-sub70.9%
*-commutative70.9%
div-sub72.2%
distribute-rgt-out--72.2%
Simplified72.2%
Taylor expanded in a around 0 71.8%
Taylor expanded in y around inf 50.7%
associate-/l*53.3%
Simplified53.3%
Final simplification57.3%
(FPCore (x y z t a) :precision binary64 (if (or (<= a -5.6e-21) (not (<= a 7.6e+52))) (+ x (/ (- z t) (/ (- a t) y))) (+ y (* (/ z t) (- x y)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -5.6e-21) || !(a <= 7.6e+52)) {
tmp = x + ((z - t) / ((a - t) / y));
} else {
tmp = y + ((z / t) * (x - 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 ((a <= (-5.6d-21)) .or. (.not. (a <= 7.6d+52))) then
tmp = x + ((z - t) / ((a - t) / y))
else
tmp = y + ((z / t) * (x - y))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -5.6e-21) || !(a <= 7.6e+52)) {
tmp = x + ((z - t) / ((a - t) / y));
} else {
tmp = y + ((z / t) * (x - y));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (a <= -5.6e-21) or not (a <= 7.6e+52): tmp = x + ((z - t) / ((a - t) / y)) else: tmp = y + ((z / t) * (x - y)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((a <= -5.6e-21) || !(a <= 7.6e+52)) tmp = Float64(x + Float64(Float64(z - t) / Float64(Float64(a - t) / y))); else tmp = Float64(y + Float64(Float64(z / t) * Float64(x - y))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((a <= -5.6e-21) || ~((a <= 7.6e+52))) tmp = x + ((z - t) / ((a - t) / y)); else tmp = y + ((z / t) * (x - y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[a, -5.6e-21], N[Not[LessEqual[a, 7.6e+52]], $MachinePrecision]], N[(x + N[(N[(z - t), $MachinePrecision] / N[(N[(a - t), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y + N[(N[(z / t), $MachinePrecision] * N[(x - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -5.6 \cdot 10^{-21} \lor \neg \left(a \leq 7.6 \cdot 10^{+52}\right):\\
\;\;\;\;x + \frac{z - t}{\frac{a - t}{y}}\\
\mathbf{else}:\\
\;\;\;\;y + \frac{z}{t} \cdot \left(x - y\right)\\
\end{array}
\end{array}
if a < -5.60000000000000008e-21 or 7.5999999999999999e52 < a Initial program 68.2%
*-commutative68.2%
associate-/l*91.3%
Simplified91.3%
Taylor expanded in y around inf 83.9%
if -5.60000000000000008e-21 < a < 7.5999999999999999e52Initial program 70.9%
associate-/l*79.8%
Simplified79.8%
Taylor expanded in t around -inf 72.4%
mul-1-neg72.4%
unsub-neg72.4%
div-sub71.0%
*-commutative71.0%
div-sub72.4%
distribute-rgt-out--72.4%
Simplified72.4%
Taylor expanded in a around 0 70.2%
Taylor expanded in z around 0 70.2%
*-commutative70.2%
associate-*r/76.7%
Simplified76.7%
Final simplification79.8%
(FPCore (x y z t a) :precision binary64 (if (or (<= a -2.8e-24) (not (<= a 1.65e+52))) (+ x (/ (- z t) (/ (- a t) y))) (+ y (* (- y x) (/ (- a z) t)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -2.8e-24) || !(a <= 1.65e+52)) {
tmp = x + ((z - t) / ((a - t) / y));
} else {
tmp = y + ((y - x) * ((a - z) / 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 ((a <= (-2.8d-24)) .or. (.not. (a <= 1.65d+52))) then
tmp = x + ((z - t) / ((a - t) / y))
else
tmp = y + ((y - x) * ((a - z) / t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -2.8e-24) || !(a <= 1.65e+52)) {
tmp = x + ((z - t) / ((a - t) / y));
} else {
tmp = y + ((y - x) * ((a - z) / t));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (a <= -2.8e-24) or not (a <= 1.65e+52): tmp = x + ((z - t) / ((a - t) / y)) else: tmp = y + ((y - x) * ((a - z) / t)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((a <= -2.8e-24) || !(a <= 1.65e+52)) tmp = Float64(x + Float64(Float64(z - t) / Float64(Float64(a - t) / y))); else tmp = Float64(y + Float64(Float64(y - x) * Float64(Float64(a - z) / t))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((a <= -2.8e-24) || ~((a <= 1.65e+52))) tmp = x + ((z - t) / ((a - t) / y)); else tmp = y + ((y - x) * ((a - z) / t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[a, -2.8e-24], N[Not[LessEqual[a, 1.65e+52]], $MachinePrecision]], N[(x + N[(N[(z - t), $MachinePrecision] / N[(N[(a - t), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y + N[(N[(y - x), $MachinePrecision] * N[(N[(a - z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -2.8 \cdot 10^{-24} \lor \neg \left(a \leq 1.65 \cdot 10^{+52}\right):\\
\;\;\;\;x + \frac{z - t}{\frac{a - t}{y}}\\
\mathbf{else}:\\
\;\;\;\;y + \left(y - x\right) \cdot \frac{a - z}{t}\\
\end{array}
\end{array}
if a < -2.8000000000000002e-24 or 1.65e52 < a Initial program 68.2%
*-commutative68.2%
associate-/l*91.3%
Simplified91.3%
Taylor expanded in y around inf 83.9%
if -2.8000000000000002e-24 < a < 1.65e52Initial program 70.9%
associate-/l*79.8%
Simplified79.8%
div-inv79.8%
Applied egg-rr79.8%
Taylor expanded in t around inf 71.0%
+-commutative71.0%
*-commutative71.0%
associate--l+71.0%
associate-*r/71.0%
associate-*r/71.0%
div-sub72.4%
distribute-lft-out--72.4%
*-commutative72.4%
distribute-rgt-out--72.4%
associate-*r/72.4%
+-commutative72.4%
fma-def72.4%
associate-/l*80.0%
Simplified79.5%
Final simplification81.4%
(FPCore (x y z t a)
:precision binary64
(if (<= a -4.3e+65)
x
(if (<= a 6.5e-217)
y
(if (<= a 5.8e-102) (* x (/ z t)) (if (<= a 3.6e+212) (+ x y) x)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -4.3e+65) {
tmp = x;
} else if (a <= 6.5e-217) {
tmp = y;
} else if (a <= 5.8e-102) {
tmp = x * (z / t);
} else if (a <= 3.6e+212) {
tmp = x + y;
} else {
tmp = x;
}
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 <= (-4.3d+65)) then
tmp = x
else if (a <= 6.5d-217) then
tmp = y
else if (a <= 5.8d-102) then
tmp = x * (z / t)
else if (a <= 3.6d+212) then
tmp = x + y
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -4.3e+65) {
tmp = x;
} else if (a <= 6.5e-217) {
tmp = y;
} else if (a <= 5.8e-102) {
tmp = x * (z / t);
} else if (a <= 3.6e+212) {
tmp = x + y;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -4.3e+65: tmp = x elif a <= 6.5e-217: tmp = y elif a <= 5.8e-102: tmp = x * (z / t) elif a <= 3.6e+212: tmp = x + y else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -4.3e+65) tmp = x; elseif (a <= 6.5e-217) tmp = y; elseif (a <= 5.8e-102) tmp = Float64(x * Float64(z / t)); elseif (a <= 3.6e+212) tmp = Float64(x + y); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -4.3e+65) tmp = x; elseif (a <= 6.5e-217) tmp = y; elseif (a <= 5.8e-102) tmp = x * (z / t); elseif (a <= 3.6e+212) tmp = x + y; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -4.3e+65], x, If[LessEqual[a, 6.5e-217], y, If[LessEqual[a, 5.8e-102], N[(x * N[(z / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.6e+212], N[(x + y), $MachinePrecision], x]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -4.3 \cdot 10^{+65}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 6.5 \cdot 10^{-217}:\\
\;\;\;\;y\\
\mathbf{elif}\;a \leq 5.8 \cdot 10^{-102}:\\
\;\;\;\;x \cdot \frac{z}{t}\\
\mathbf{elif}\;a \leq 3.6 \cdot 10^{+212}:\\
\;\;\;\;x + y\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -4.30000000000000046e65 or 3.6e212 < a Initial program 65.9%
associate-/l*97.0%
Simplified97.0%
Taylor expanded in a around inf 58.2%
if -4.30000000000000046e65 < a < 6.4999999999999996e-217Initial program 67.6%
associate-/l*78.7%
Simplified78.7%
Taylor expanded in t around inf 36.6%
if 6.4999999999999996e-217 < a < 5.79999999999999973e-102Initial program 72.8%
associate-/l*79.3%
Simplified79.3%
Taylor expanded in z around inf 74.0%
div-sub74.0%
associate-*r/71.1%
Simplified71.1%
Taylor expanded in y around 0 44.9%
associate-*r/44.9%
associate-*r*44.9%
*-rgt-identity44.9%
times-frac45.0%
mul-1-neg45.0%
/-rgt-identity45.0%
Simplified45.0%
Taylor expanded in a around 0 35.5%
if 5.79999999999999973e-102 < a < 3.6e212Initial program 76.0%
*-commutative76.0%
associate-/l*87.0%
Simplified87.0%
Taylor expanded in y around inf 68.6%
Taylor expanded in t around inf 41.4%
Final simplification43.2%
(FPCore (x y z t a) :precision binary64 (if (<= a -5.4e+65) x (if (<= a 2.75e+45) y x)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -5.4e+65) {
tmp = x;
} else if (a <= 2.75e+45) {
tmp = y;
} else {
tmp = x;
}
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 <= (-5.4d+65)) then
tmp = x
else if (a <= 2.75d+45) then
tmp = y
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -5.4e+65) {
tmp = x;
} else if (a <= 2.75e+45) {
tmp = y;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -5.4e+65: tmp = x elif a <= 2.75e+45: tmp = y else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -5.4e+65) tmp = x; elseif (a <= 2.75e+45) tmp = y; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -5.4e+65) tmp = x; elseif (a <= 2.75e+45) tmp = y; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -5.4e+65], x, If[LessEqual[a, 2.75e+45], y, x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -5.4 \cdot 10^{+65}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 2.75 \cdot 10^{+45}:\\
\;\;\;\;y\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -5.40000000000000038e65 or 2.75e45 < a Initial program 68.5%
associate-/l*96.9%
Simplified96.9%
Taylor expanded in a around inf 54.3%
if -5.40000000000000038e65 < a < 2.75e45Initial program 70.5%
associate-/l*80.4%
Simplified80.4%
Taylor expanded in t around inf 32.3%
Final simplification40.6%
(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 69.7%
associate-/l*86.6%
Simplified86.6%
Taylor expanded in a around inf 25.4%
Final simplification25.4%
(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 2023221
(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))))