
(FPCore (x y z t a) :precision binary64 (+ x (/ (* (- y z) (- t x)) (- a z))))
double code(double x, double y, double z, double t, double a) {
return x + (((y - z) * (t - x)) / (a - z));
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = x + (((y - z) * (t - x)) / (a - z))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + (((y - z) * (t - x)) / (a - z));
}
def code(x, y, z, t, a): return x + (((y - z) * (t - x)) / (a - z))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(Float64(y - z) * Float64(t - x)) / Float64(a - z))) end
function tmp = code(x, y, z, t, a) tmp = x + (((y - z) * (t - x)) / (a - z)); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{\left(y - z\right) \cdot \left(t - x\right)}{a - z}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 25 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (+ x (/ (* (- y z) (- t x)) (- a z))))
double code(double x, double y, double z, double t, double a) {
return x + (((y - z) * (t - x)) / (a - z));
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = x + (((y - z) * (t - x)) / (a - z))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + (((y - z) * (t - x)) / (a - z));
}
def code(x, y, z, t, a): return x + (((y - z) * (t - x)) / (a - z))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(Float64(y - z) * Float64(t - x)) / Float64(a - z))) end
function tmp = code(x, y, z, t, a) tmp = x + (((y - z) * (t - x)) / (a - z)); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{\left(y - z\right) \cdot \left(t - x\right)}{a - z}
\end{array}
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- y z) (- a z))) (t_2 (- x (/ (* (- y z) (- x t)) (- a z)))))
(if (<= t_2 -2e-240)
(fma t_1 (- t x) x)
(if (<= t_2 0.0) (+ t (/ (* x (- y a)) z)) (+ x (* (- t x) t_1))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (y - z) / (a - z);
double t_2 = x - (((y - z) * (x - t)) / (a - z));
double tmp;
if (t_2 <= -2e-240) {
tmp = fma(t_1, (t - x), x);
} else if (t_2 <= 0.0) {
tmp = t + ((x * (y - a)) / z);
} else {
tmp = x + ((t - x) * t_1);
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(y - z) / Float64(a - z)) t_2 = Float64(x - Float64(Float64(Float64(y - z) * Float64(x - t)) / Float64(a - z))) tmp = 0.0 if (t_2 <= -2e-240) tmp = fma(t_1, Float64(t - x), x); elseif (t_2 <= 0.0) tmp = Float64(t + Float64(Float64(x * Float64(y - a)) / z)); else tmp = Float64(x + Float64(Float64(t - x) * t_1)); end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(N[(N[(y - z), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -2e-240], N[(t$95$1 * N[(t - x), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[t$95$2, 0.0], N[(t + N[(N[(x * N[(y - a), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(t - x), $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{y - z}{a - z}\\
t_2 := x - \frac{\left(y - z\right) \cdot \left(x - t\right)}{a - z}\\
\mathbf{if}\;t_2 \leq -2 \cdot 10^{-240}:\\
\;\;\;\;\mathsf{fma}\left(t_1, t - x, x\right)\\
\mathbf{elif}\;t_2 \leq 0:\\
\;\;\;\;t + \frac{x \cdot \left(y - a\right)}{z}\\
\mathbf{else}:\\
\;\;\;\;x + \left(t - x\right) \cdot t_1\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -1.9999999999999999e-240Initial program 79.1%
+-commutative79.1%
associate-*l/91.5%
fma-def91.5%
Simplified91.5%
if -1.9999999999999999e-240 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 0.0Initial program 6.0%
+-commutative6.0%
associate-*l/6.2%
fma-def6.2%
Simplified6.2%
Taylor expanded in z around inf 99.8%
+-commutative99.8%
associate-/l*92.4%
distribute-lft-out--92.4%
mul-1-neg92.4%
distribute-neg-frac92.4%
associate-/l*99.8%
*-commutative99.8%
distribute-rgt-out--99.8%
unsub-neg99.8%
distribute-rgt-out--99.8%
*-commutative99.8%
associate-/l*92.4%
Simplified92.4%
Taylor expanded in t around 0 99.8%
associate-*r/99.8%
*-commutative99.8%
associate-*r*99.8%
neg-mul-199.8%
Simplified99.8%
if 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) Initial program 77.4%
associate-*l/96.9%
Simplified96.9%
Final simplification94.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- x (/ (* (- y z) (- x t)) (- a z)))))
(if (or (<= t_1 -2e-240) (not (<= t_1 0.0)))
(+ x (* (- t x) (/ (- y z) (- a z))))
(+ t (/ (* x (- y a)) z)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x - (((y - z) * (x - t)) / (a - z));
double tmp;
if ((t_1 <= -2e-240) || !(t_1 <= 0.0)) {
tmp = x + ((t - x) * ((y - z) / (a - z)));
} else {
tmp = t + ((x * (y - a)) / z);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x - (((y - z) * (x - t)) / (a - z))
if ((t_1 <= (-2d-240)) .or. (.not. (t_1 <= 0.0d0))) then
tmp = x + ((t - x) * ((y - z) / (a - z)))
else
tmp = t + ((x * (y - a)) / z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x - (((y - z) * (x - t)) / (a - z));
double tmp;
if ((t_1 <= -2e-240) || !(t_1 <= 0.0)) {
tmp = x + ((t - x) * ((y - z) / (a - z)));
} else {
tmp = t + ((x * (y - a)) / z);
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x - (((y - z) * (x - t)) / (a - z)) tmp = 0 if (t_1 <= -2e-240) or not (t_1 <= 0.0): tmp = x + ((t - x) * ((y - z) / (a - z))) else: tmp = t + ((x * (y - a)) / z) return tmp
function code(x, y, z, t, a) t_1 = Float64(x - Float64(Float64(Float64(y - z) * Float64(x - t)) / Float64(a - z))) tmp = 0.0 if ((t_1 <= -2e-240) || !(t_1 <= 0.0)) tmp = Float64(x + Float64(Float64(t - x) * Float64(Float64(y - z) / Float64(a - z)))); else tmp = Float64(t + Float64(Float64(x * Float64(y - a)) / z)); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x - (((y - z) * (x - t)) / (a - z)); tmp = 0.0; if ((t_1 <= -2e-240) || ~((t_1 <= 0.0))) tmp = x + ((t - x) * ((y - z) / (a - z))); else tmp = t + ((x * (y - a)) / z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(N[(N[(y - z), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, -2e-240], N[Not[LessEqual[t$95$1, 0.0]], $MachinePrecision]], N[(x + N[(N[(t - x), $MachinePrecision] * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(N[(x * N[(y - a), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - \frac{\left(y - z\right) \cdot \left(x - t\right)}{a - z}\\
\mathbf{if}\;t_1 \leq -2 \cdot 10^{-240} \lor \neg \left(t_1 \leq 0\right):\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y - z}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t + \frac{x \cdot \left(y - a\right)}{z}\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -1.9999999999999999e-240 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) Initial program 78.3%
associate-*l/94.3%
Simplified94.3%
if -1.9999999999999999e-240 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 0.0Initial program 6.0%
+-commutative6.0%
associate-*l/6.2%
fma-def6.2%
Simplified6.2%
Taylor expanded in z around inf 99.8%
+-commutative99.8%
associate-/l*92.4%
distribute-lft-out--92.4%
mul-1-neg92.4%
distribute-neg-frac92.4%
associate-/l*99.8%
*-commutative99.8%
distribute-rgt-out--99.8%
unsub-neg99.8%
distribute-rgt-out--99.8%
*-commutative99.8%
associate-/l*92.4%
Simplified92.4%
Taylor expanded in t around 0 99.8%
associate-*r/99.8%
*-commutative99.8%
associate-*r*99.8%
neg-mul-199.8%
Simplified99.8%
Final simplification94.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* x (- 1.0 (/ y a)))) (t_2 (* t (/ (- y z) (- a z)))))
(if (<= t -1.42e-43)
t_2
(if (<= t -1.7e-116)
t_1
(if (<= t -4.8e-117)
t
(if (<= t -2.5e-259)
(* (- t x) (/ y (- a z)))
(if (<= t 5.5e-237)
t_1
(if (<= t 6.5e-190)
(/ (* x (- y a)) z)
(if (<= t 2.35e+36) t_1 t_2)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x * (1.0 - (y / a));
double t_2 = t * ((y - z) / (a - z));
double tmp;
if (t <= -1.42e-43) {
tmp = t_2;
} else if (t <= -1.7e-116) {
tmp = t_1;
} else if (t <= -4.8e-117) {
tmp = t;
} else if (t <= -2.5e-259) {
tmp = (t - x) * (y / (a - z));
} else if (t <= 5.5e-237) {
tmp = t_1;
} else if (t <= 6.5e-190) {
tmp = (x * (y - a)) / z;
} else if (t <= 2.35e+36) {
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 * (1.0d0 - (y / a))
t_2 = t * ((y - z) / (a - z))
if (t <= (-1.42d-43)) then
tmp = t_2
else if (t <= (-1.7d-116)) then
tmp = t_1
else if (t <= (-4.8d-117)) then
tmp = t
else if (t <= (-2.5d-259)) then
tmp = (t - x) * (y / (a - z))
else if (t <= 5.5d-237) then
tmp = t_1
else if (t <= 6.5d-190) then
tmp = (x * (y - a)) / z
else if (t <= 2.35d+36) 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 * (1.0 - (y / a));
double t_2 = t * ((y - z) / (a - z));
double tmp;
if (t <= -1.42e-43) {
tmp = t_2;
} else if (t <= -1.7e-116) {
tmp = t_1;
} else if (t <= -4.8e-117) {
tmp = t;
} else if (t <= -2.5e-259) {
tmp = (t - x) * (y / (a - z));
} else if (t <= 5.5e-237) {
tmp = t_1;
} else if (t <= 6.5e-190) {
tmp = (x * (y - a)) / z;
} else if (t <= 2.35e+36) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x * (1.0 - (y / a)) t_2 = t * ((y - z) / (a - z)) tmp = 0 if t <= -1.42e-43: tmp = t_2 elif t <= -1.7e-116: tmp = t_1 elif t <= -4.8e-117: tmp = t elif t <= -2.5e-259: tmp = (t - x) * (y / (a - z)) elif t <= 5.5e-237: tmp = t_1 elif t <= 6.5e-190: tmp = (x * (y - a)) / z elif t <= 2.35e+36: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(x * Float64(1.0 - Float64(y / a))) t_2 = Float64(t * Float64(Float64(y - z) / Float64(a - z))) tmp = 0.0 if (t <= -1.42e-43) tmp = t_2; elseif (t <= -1.7e-116) tmp = t_1; elseif (t <= -4.8e-117) tmp = t; elseif (t <= -2.5e-259) tmp = Float64(Float64(t - x) * Float64(y / Float64(a - z))); elseif (t <= 5.5e-237) tmp = t_1; elseif (t <= 6.5e-190) tmp = Float64(Float64(x * Float64(y - a)) / z); elseif (t <= 2.35e+36) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x * (1.0 - (y / a)); t_2 = t * ((y - z) / (a - z)); tmp = 0.0; if (t <= -1.42e-43) tmp = t_2; elseif (t <= -1.7e-116) tmp = t_1; elseif (t <= -4.8e-117) tmp = t; elseif (t <= -2.5e-259) tmp = (t - x) * (y / (a - z)); elseif (t <= 5.5e-237) tmp = t_1; elseif (t <= 6.5e-190) tmp = (x * (y - a)) / z; elseif (t <= 2.35e+36) 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[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.42e-43], t$95$2, If[LessEqual[t, -1.7e-116], t$95$1, If[LessEqual[t, -4.8e-117], t, If[LessEqual[t, -2.5e-259], N[(N[(t - x), $MachinePrecision] * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.5e-237], t$95$1, If[LessEqual[t, 6.5e-190], N[(N[(x * N[(y - a), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[t, 2.35e+36], t$95$1, t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(1 - \frac{y}{a}\right)\\
t_2 := t \cdot \frac{y - z}{a - z}\\
\mathbf{if}\;t \leq -1.42 \cdot 10^{-43}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -1.7 \cdot 10^{-116}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -4.8 \cdot 10^{-117}:\\
\;\;\;\;t\\
\mathbf{elif}\;t \leq -2.5 \cdot 10^{-259}:\\
\;\;\;\;\left(t - x\right) \cdot \frac{y}{a - z}\\
\mathbf{elif}\;t \leq 5.5 \cdot 10^{-237}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 6.5 \cdot 10^{-190}:\\
\;\;\;\;\frac{x \cdot \left(y - a\right)}{z}\\
\mathbf{elif}\;t \leq 2.35 \cdot 10^{+36}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -1.41999999999999993e-43 or 2.34999999999999994e36 < t Initial program 72.3%
+-commutative72.3%
associate-*l/94.6%
fma-def94.6%
Simplified94.6%
Taylor expanded in t around inf 77.0%
div-sub77.0%
Simplified77.0%
if -1.41999999999999993e-43 < t < -1.69999999999999996e-116 or -2.49999999999999989e-259 < t < 5.49999999999999981e-237 or 6.4999999999999997e-190 < t < 2.34999999999999994e36Initial program 79.2%
+-commutative79.2%
associate-*l/89.5%
fma-def89.5%
Simplified89.5%
Taylor expanded in z around 0 60.2%
+-commutative60.2%
associate-/l*63.4%
Simplified63.4%
Taylor expanded in t around 0 56.0%
mul-1-neg56.0%
associate-*l/62.1%
*-commutative62.1%
distribute-rgt-neg-in62.1%
Simplified62.1%
Taylor expanded in x around 0 62.1%
mul-1-neg62.1%
sub-neg62.1%
*-commutative62.1%
Simplified62.1%
if -1.69999999999999996e-116 < t < -4.80000000000000028e-117Initial program 4.2%
+-commutative4.2%
associate-*l/4.2%
fma-def4.2%
Simplified4.2%
Taylor expanded in z around inf 100.0%
if -4.80000000000000028e-117 < t < -2.49999999999999989e-259Initial program 59.5%
+-commutative59.5%
associate-*l/64.3%
fma-def64.3%
Simplified64.3%
Taylor expanded in y around -inf 49.0%
expm1-log1p-u44.1%
expm1-udef24.4%
Applied egg-rr24.4%
expm1-def44.1%
expm1-log1p49.0%
*-commutative49.0%
associate-*r/56.6%
Simplified56.6%
if 5.49999999999999981e-237 < t < 6.4999999999999997e-190Initial program 51.2%
+-commutative51.2%
associate-*l/51.5%
fma-def51.5%
Simplified51.5%
Taylor expanded in z around inf 78.2%
+-commutative78.2%
associate-/l*57.0%
distribute-lft-out--57.0%
mul-1-neg57.0%
distribute-neg-frac57.0%
associate-/l*78.2%
*-commutative78.2%
distribute-rgt-out--78.2%
unsub-neg78.2%
distribute-rgt-out--78.2%
*-commutative78.2%
associate-/l*57.0%
Simplified57.0%
Taylor expanded in t around 0 66.8%
Final simplification68.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ t (* (/ y z) (- x t)))))
(if (<= z -4.5e+134)
(+ t (/ (- a y) (- (/ z x))))
(if (<= z -3.6e+67)
(- x (* (- y z) (/ t z)))
(if (<= z -1.9e+14)
t_1
(if (<= z -0.027)
(- x (/ (- z y) (/ a t)))
(if (or (<= z -1.8e-33) (not (<= z 2.4e-22)))
t_1
(- x (/ (- z y) (/ a (- t x)))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t + ((y / z) * (x - t));
double tmp;
if (z <= -4.5e+134) {
tmp = t + ((a - y) / -(z / x));
} else if (z <= -3.6e+67) {
tmp = x - ((y - z) * (t / z));
} else if (z <= -1.9e+14) {
tmp = t_1;
} else if (z <= -0.027) {
tmp = x - ((z - y) / (a / t));
} else if ((z <= -1.8e-33) || !(z <= 2.4e-22)) {
tmp = t_1;
} else {
tmp = x - ((z - y) / (a / (t - 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 = t + ((y / z) * (x - t))
if (z <= (-4.5d+134)) then
tmp = t + ((a - y) / -(z / x))
else if (z <= (-3.6d+67)) then
tmp = x - ((y - z) * (t / z))
else if (z <= (-1.9d+14)) then
tmp = t_1
else if (z <= (-0.027d0)) then
tmp = x - ((z - y) / (a / t))
else if ((z <= (-1.8d-33)) .or. (.not. (z <= 2.4d-22))) then
tmp = t_1
else
tmp = x - ((z - y) / (a / (t - x)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t + ((y / z) * (x - t));
double tmp;
if (z <= -4.5e+134) {
tmp = t + ((a - y) / -(z / x));
} else if (z <= -3.6e+67) {
tmp = x - ((y - z) * (t / z));
} else if (z <= -1.9e+14) {
tmp = t_1;
} else if (z <= -0.027) {
tmp = x - ((z - y) / (a / t));
} else if ((z <= -1.8e-33) || !(z <= 2.4e-22)) {
tmp = t_1;
} else {
tmp = x - ((z - y) / (a / (t - x)));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t + ((y / z) * (x - t)) tmp = 0 if z <= -4.5e+134: tmp = t + ((a - y) / -(z / x)) elif z <= -3.6e+67: tmp = x - ((y - z) * (t / z)) elif z <= -1.9e+14: tmp = t_1 elif z <= -0.027: tmp = x - ((z - y) / (a / t)) elif (z <= -1.8e-33) or not (z <= 2.4e-22): tmp = t_1 else: tmp = x - ((z - y) / (a / (t - x))) return tmp
function code(x, y, z, t, a) t_1 = Float64(t + Float64(Float64(y / z) * Float64(x - t))) tmp = 0.0 if (z <= -4.5e+134) tmp = Float64(t + Float64(Float64(a - y) / Float64(-Float64(z / x)))); elseif (z <= -3.6e+67) tmp = Float64(x - Float64(Float64(y - z) * Float64(t / z))); elseif (z <= -1.9e+14) tmp = t_1; elseif (z <= -0.027) tmp = Float64(x - Float64(Float64(z - y) / Float64(a / t))); elseif ((z <= -1.8e-33) || !(z <= 2.4e-22)) tmp = t_1; else tmp = Float64(x - Float64(Float64(z - y) / Float64(a / Float64(t - x)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t + ((y / z) * (x - t)); tmp = 0.0; if (z <= -4.5e+134) tmp = t + ((a - y) / -(z / x)); elseif (z <= -3.6e+67) tmp = x - ((y - z) * (t / z)); elseif (z <= -1.9e+14) tmp = t_1; elseif (z <= -0.027) tmp = x - ((z - y) / (a / t)); elseif ((z <= -1.8e-33) || ~((z <= 2.4e-22))) tmp = t_1; else tmp = x - ((z - y) / (a / (t - x))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t + N[(N[(y / z), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -4.5e+134], N[(t + N[(N[(a - y), $MachinePrecision] / (-N[(z / x), $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.6e+67], N[(x - N[(N[(y - z), $MachinePrecision] * N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.9e+14], t$95$1, If[LessEqual[z, -0.027], N[(x - N[(N[(z - y), $MachinePrecision] / N[(a / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[z, -1.8e-33], N[Not[LessEqual[z, 2.4e-22]], $MachinePrecision]], t$95$1, N[(x - N[(N[(z - y), $MachinePrecision] / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + \frac{y}{z} \cdot \left(x - t\right)\\
\mathbf{if}\;z \leq -4.5 \cdot 10^{+134}:\\
\;\;\;\;t + \frac{a - y}{-\frac{z}{x}}\\
\mathbf{elif}\;z \leq -3.6 \cdot 10^{+67}:\\
\;\;\;\;x - \left(y - z\right) \cdot \frac{t}{z}\\
\mathbf{elif}\;z \leq -1.9 \cdot 10^{+14}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -0.027:\\
\;\;\;\;x - \frac{z - y}{\frac{a}{t}}\\
\mathbf{elif}\;z \leq -1.8 \cdot 10^{-33} \lor \neg \left(z \leq 2.4 \cdot 10^{-22}\right):\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;x - \frac{z - y}{\frac{a}{t - x}}\\
\end{array}
\end{array}
if z < -4.4999999999999997e134Initial program 24.8%
+-commutative24.8%
associate-*l/60.0%
fma-def60.0%
Simplified60.0%
Taylor expanded in z around inf 72.8%
+-commutative72.8%
associate-/l*86.3%
distribute-lft-out--86.3%
mul-1-neg86.3%
distribute-neg-frac86.3%
associate-/l*72.8%
*-commutative72.8%
distribute-rgt-out--72.5%
unsub-neg72.5%
distribute-rgt-out--72.8%
*-commutative72.8%
associate-/l*86.3%
Simplified86.3%
Taylor expanded in t around 0 85.9%
mul-1-neg85.9%
distribute-neg-frac85.9%
Simplified85.9%
if -4.4999999999999997e134 < z < -3.5999999999999999e67Initial program 75.5%
+-commutative75.5%
associate-*l/93.9%
fma-def93.9%
Simplified93.9%
fma-udef93.9%
associate-*l/75.5%
associate-*r/88.8%
Applied egg-rr88.8%
Taylor expanded in t around inf 83.0%
Taylor expanded in a around 0 77.1%
associate-*r/77.1%
neg-mul-177.1%
Simplified77.1%
if -3.5999999999999999e67 < z < -1.9e14 or -0.0269999999999999997 < z < -1.80000000000000017e-33 or 2.40000000000000002e-22 < z Initial program 65.1%
+-commutative65.1%
associate-*l/83.5%
fma-def83.5%
Simplified83.5%
Taylor expanded in z around inf 68.4%
+-commutative68.4%
associate-/l*73.3%
distribute-lft-out--73.3%
mul-1-neg73.3%
distribute-neg-frac73.3%
associate-/l*68.4%
*-commutative68.4%
distribute-rgt-out--68.3%
unsub-neg68.3%
distribute-rgt-out--68.4%
*-commutative68.4%
associate-/l*73.3%
Simplified73.3%
Taylor expanded in y around inf 68.7%
associate-*l/74.4%
Simplified74.4%
if -1.9e14 < z < -0.0269999999999999997Initial program 100.0%
+-commutative100.0%
associate-*l/100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in a around inf 96.3%
+-commutative96.3%
associate-/l*96.3%
Simplified96.3%
Taylor expanded in t around inf 96.3%
if -1.80000000000000017e-33 < z < 2.40000000000000002e-22Initial program 90.7%
+-commutative90.7%
associate-*l/96.0%
fma-def96.0%
Simplified96.0%
Taylor expanded in a around inf 77.2%
+-commutative77.2%
associate-/l*80.6%
Simplified80.6%
Final simplification79.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ t (* (/ y z) (- x t)))))
(if (<= z -2.2e+134)
(+ t (/ (- a y) (- (/ z x))))
(if (<= z -4e+65)
(- x (* (- y z) (/ t z)))
(if (<= z -8e+16)
t_1
(if (<= z -5.5e-8)
(- x (/ (- z y) (/ a t)))
(if (or (<= z -4.5e-33) (not (<= z 2.8e-22)))
t_1
(+ x (* (- t x) (/ y a))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t + ((y / z) * (x - t));
double tmp;
if (z <= -2.2e+134) {
tmp = t + ((a - y) / -(z / x));
} else if (z <= -4e+65) {
tmp = x - ((y - z) * (t / z));
} else if (z <= -8e+16) {
tmp = t_1;
} else if (z <= -5.5e-8) {
tmp = x - ((z - y) / (a / t));
} else if ((z <= -4.5e-33) || !(z <= 2.8e-22)) {
tmp = t_1;
} else {
tmp = x + ((t - x) * (y / a));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = t + ((y / z) * (x - t))
if (z <= (-2.2d+134)) then
tmp = t + ((a - y) / -(z / x))
else if (z <= (-4d+65)) then
tmp = x - ((y - z) * (t / z))
else if (z <= (-8d+16)) then
tmp = t_1
else if (z <= (-5.5d-8)) then
tmp = x - ((z - y) / (a / t))
else if ((z <= (-4.5d-33)) .or. (.not. (z <= 2.8d-22))) then
tmp = t_1
else
tmp = x + ((t - x) * (y / a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t + ((y / z) * (x - t));
double tmp;
if (z <= -2.2e+134) {
tmp = t + ((a - y) / -(z / x));
} else if (z <= -4e+65) {
tmp = x - ((y - z) * (t / z));
} else if (z <= -8e+16) {
tmp = t_1;
} else if (z <= -5.5e-8) {
tmp = x - ((z - y) / (a / t));
} else if ((z <= -4.5e-33) || !(z <= 2.8e-22)) {
tmp = t_1;
} else {
tmp = x + ((t - x) * (y / a));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t + ((y / z) * (x - t)) tmp = 0 if z <= -2.2e+134: tmp = t + ((a - y) / -(z / x)) elif z <= -4e+65: tmp = x - ((y - z) * (t / z)) elif z <= -8e+16: tmp = t_1 elif z <= -5.5e-8: tmp = x - ((z - y) / (a / t)) elif (z <= -4.5e-33) or not (z <= 2.8e-22): tmp = t_1 else: tmp = x + ((t - x) * (y / a)) return tmp
function code(x, y, z, t, a) t_1 = Float64(t + Float64(Float64(y / z) * Float64(x - t))) tmp = 0.0 if (z <= -2.2e+134) tmp = Float64(t + Float64(Float64(a - y) / Float64(-Float64(z / x)))); elseif (z <= -4e+65) tmp = Float64(x - Float64(Float64(y - z) * Float64(t / z))); elseif (z <= -8e+16) tmp = t_1; elseif (z <= -5.5e-8) tmp = Float64(x - Float64(Float64(z - y) / Float64(a / t))); elseif ((z <= -4.5e-33) || !(z <= 2.8e-22)) tmp = t_1; else tmp = Float64(x + Float64(Float64(t - x) * Float64(y / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t + ((y / z) * (x - t)); tmp = 0.0; if (z <= -2.2e+134) tmp = t + ((a - y) / -(z / x)); elseif (z <= -4e+65) tmp = x - ((y - z) * (t / z)); elseif (z <= -8e+16) tmp = t_1; elseif (z <= -5.5e-8) tmp = x - ((z - y) / (a / t)); elseif ((z <= -4.5e-33) || ~((z <= 2.8e-22))) tmp = t_1; else tmp = x + ((t - x) * (y / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t + N[(N[(y / z), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.2e+134], N[(t + N[(N[(a - y), $MachinePrecision] / (-N[(z / x), $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -4e+65], N[(x - N[(N[(y - z), $MachinePrecision] * N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -8e+16], t$95$1, If[LessEqual[z, -5.5e-8], N[(x - N[(N[(z - y), $MachinePrecision] / N[(a / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[z, -4.5e-33], N[Not[LessEqual[z, 2.8e-22]], $MachinePrecision]], t$95$1, N[(x + N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + \frac{y}{z} \cdot \left(x - t\right)\\
\mathbf{if}\;z \leq -2.2 \cdot 10^{+134}:\\
\;\;\;\;t + \frac{a - y}{-\frac{z}{x}}\\
\mathbf{elif}\;z \leq -4 \cdot 10^{+65}:\\
\;\;\;\;x - \left(y - z\right) \cdot \frac{t}{z}\\
\mathbf{elif}\;z \leq -8 \cdot 10^{+16}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -5.5 \cdot 10^{-8}:\\
\;\;\;\;x - \frac{z - y}{\frac{a}{t}}\\
\mathbf{elif}\;z \leq -4.5 \cdot 10^{-33} \lor \neg \left(z \leq 2.8 \cdot 10^{-22}\right):\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y}{a}\\
\end{array}
\end{array}
if z < -2.2e134Initial program 24.8%
+-commutative24.8%
associate-*l/60.0%
fma-def60.0%
Simplified60.0%
Taylor expanded in z around inf 72.8%
+-commutative72.8%
associate-/l*86.3%
distribute-lft-out--86.3%
mul-1-neg86.3%
distribute-neg-frac86.3%
associate-/l*72.8%
*-commutative72.8%
distribute-rgt-out--72.5%
unsub-neg72.5%
distribute-rgt-out--72.8%
*-commutative72.8%
associate-/l*86.3%
Simplified86.3%
Taylor expanded in t around 0 85.9%
mul-1-neg85.9%
distribute-neg-frac85.9%
Simplified85.9%
if -2.2e134 < z < -4e65Initial program 75.5%
+-commutative75.5%
associate-*l/93.9%
fma-def93.9%
Simplified93.9%
fma-udef93.9%
associate-*l/75.5%
associate-*r/88.8%
Applied egg-rr88.8%
Taylor expanded in t around inf 83.0%
Taylor expanded in a around 0 77.1%
associate-*r/77.1%
neg-mul-177.1%
Simplified77.1%
if -4e65 < z < -8e16 or -5.5000000000000003e-8 < z < -4.49999999999999991e-33 or 2.79999999999999995e-22 < z Initial program 65.1%
+-commutative65.1%
associate-*l/83.5%
fma-def83.5%
Simplified83.5%
Taylor expanded in z around inf 68.4%
+-commutative68.4%
associate-/l*73.3%
distribute-lft-out--73.3%
mul-1-neg73.3%
distribute-neg-frac73.3%
associate-/l*68.4%
*-commutative68.4%
distribute-rgt-out--68.3%
unsub-neg68.3%
distribute-rgt-out--68.4%
*-commutative68.4%
associate-/l*73.3%
Simplified73.3%
Taylor expanded in y around inf 68.7%
associate-*l/74.4%
Simplified74.4%
if -8e16 < z < -5.5000000000000003e-8Initial program 100.0%
+-commutative100.0%
associate-*l/100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in a around inf 96.3%
+-commutative96.3%
associate-/l*96.3%
Simplified96.3%
Taylor expanded in t around inf 96.3%
if -4.49999999999999991e-33 < z < 2.79999999999999995e-22Initial program 90.7%
associate-*l/96.0%
Simplified96.0%
Taylor expanded in z around 0 79.0%
Final simplification78.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ (- y z) (- a z)))) (t_2 (* x (- 1.0 (/ y a)))))
(if (<= x -1.4e+156)
t_2
(if (<= x -1.3e+39)
(/ (- y) (/ z (- t x)))
(if (<= x -30500.0)
(+ x (* t (/ y a)))
(if (<= x 2.7)
t_1
(if (<= x 1.8e+95) (+ x t) (if (<= x 4e+100) t_1 t_2))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double t_2 = x * (1.0 - (y / a));
double tmp;
if (x <= -1.4e+156) {
tmp = t_2;
} else if (x <= -1.3e+39) {
tmp = -y / (z / (t - x));
} else if (x <= -30500.0) {
tmp = x + (t * (y / a));
} else if (x <= 2.7) {
tmp = t_1;
} else if (x <= 1.8e+95) {
tmp = x + t;
} else if (x <= 4e+100) {
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 = t * ((y - z) / (a - z))
t_2 = x * (1.0d0 - (y / a))
if (x <= (-1.4d+156)) then
tmp = t_2
else if (x <= (-1.3d+39)) then
tmp = -y / (z / (t - x))
else if (x <= (-30500.0d0)) then
tmp = x + (t * (y / a))
else if (x <= 2.7d0) then
tmp = t_1
else if (x <= 1.8d+95) then
tmp = x + t
else if (x <= 4d+100) 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 = t * ((y - z) / (a - z));
double t_2 = x * (1.0 - (y / a));
double tmp;
if (x <= -1.4e+156) {
tmp = t_2;
} else if (x <= -1.3e+39) {
tmp = -y / (z / (t - x));
} else if (x <= -30500.0) {
tmp = x + (t * (y / a));
} else if (x <= 2.7) {
tmp = t_1;
} else if (x <= 1.8e+95) {
tmp = x + t;
} else if (x <= 4e+100) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * ((y - z) / (a - z)) t_2 = x * (1.0 - (y / a)) tmp = 0 if x <= -1.4e+156: tmp = t_2 elif x <= -1.3e+39: tmp = -y / (z / (t - x)) elif x <= -30500.0: tmp = x + (t * (y / a)) elif x <= 2.7: tmp = t_1 elif x <= 1.8e+95: tmp = x + t elif x <= 4e+100: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(Float64(y - z) / Float64(a - z))) t_2 = Float64(x * Float64(1.0 - Float64(y / a))) tmp = 0.0 if (x <= -1.4e+156) tmp = t_2; elseif (x <= -1.3e+39) tmp = Float64(Float64(-y) / Float64(z / Float64(t - x))); elseif (x <= -30500.0) tmp = Float64(x + Float64(t * Float64(y / a))); elseif (x <= 2.7) tmp = t_1; elseif (x <= 1.8e+95) tmp = Float64(x + t); elseif (x <= 4e+100) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * ((y - z) / (a - z)); t_2 = x * (1.0 - (y / a)); tmp = 0.0; if (x <= -1.4e+156) tmp = t_2; elseif (x <= -1.3e+39) tmp = -y / (z / (t - x)); elseif (x <= -30500.0) tmp = x + (t * (y / a)); elseif (x <= 2.7) tmp = t_1; elseif (x <= 1.8e+95) tmp = x + t; elseif (x <= 4e+100) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.4e+156], t$95$2, If[LessEqual[x, -1.3e+39], N[((-y) / N[(z / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -30500.0], N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.7], t$95$1, If[LessEqual[x, 1.8e+95], N[(x + t), $MachinePrecision], If[LessEqual[x, 4e+100], t$95$1, t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y - z}{a - z}\\
t_2 := x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{if}\;x \leq -1.4 \cdot 10^{+156}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;x \leq -1.3 \cdot 10^{+39}:\\
\;\;\;\;\frac{-y}{\frac{z}{t - x}}\\
\mathbf{elif}\;x \leq -30500:\\
\;\;\;\;x + t \cdot \frac{y}{a}\\
\mathbf{elif}\;x \leq 2.7:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \leq 1.8 \cdot 10^{+95}:\\
\;\;\;\;x + t\\
\mathbf{elif}\;x \leq 4 \cdot 10^{+100}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if x < -1.39999999999999994e156 or 4.00000000000000006e100 < x Initial program 63.2%
+-commutative63.2%
associate-*l/84.5%
fma-def84.5%
Simplified84.5%
Taylor expanded in z around 0 51.7%
+-commutative51.7%
associate-/l*57.4%
Simplified57.4%
Taylor expanded in t around 0 51.7%
mul-1-neg51.7%
associate-*l/61.6%
*-commutative61.6%
distribute-rgt-neg-in61.6%
Simplified61.6%
Taylor expanded in x around 0 61.6%
mul-1-neg61.6%
sub-neg61.6%
*-commutative61.6%
Simplified61.6%
if -1.39999999999999994e156 < x < -1.3e39Initial program 39.8%
+-commutative39.8%
associate-*l/70.6%
fma-def70.7%
Simplified70.7%
Taylor expanded in y around -inf 47.1%
Taylor expanded in a around 0 42.8%
mul-1-neg42.8%
associate-/l*51.5%
distribute-neg-frac51.5%
Simplified51.5%
if -1.3e39 < x < -30500Initial program 89.4%
+-commutative89.4%
associate-*l/100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in z around 0 69.5%
+-commutative69.5%
associate-/l*69.5%
Simplified69.5%
Taylor expanded in t around inf 69.5%
associate-*l/69.5%
*-commutative69.5%
Simplified69.5%
if -30500 < x < 2.7000000000000002 or 1.79999999999999989e95 < x < 4.00000000000000006e100Initial program 81.5%
+-commutative81.5%
associate-*l/89.9%
fma-def89.9%
Simplified89.9%
Taylor expanded in t around inf 70.9%
div-sub71.0%
Simplified71.0%
if 2.7000000000000002 < x < 1.79999999999999989e95Initial program 67.2%
+-commutative67.2%
associate-*l/85.5%
fma-def85.5%
Simplified85.5%
fma-udef85.5%
associate-*l/67.2%
associate-*r/76.5%
Applied egg-rr76.5%
Taylor expanded in t around inf 65.1%
Taylor expanded in z around inf 69.5%
Final simplification66.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ (- y z) (- a z)))) (t_2 (* x (- 1.0 (/ y a)))))
(if (<= x -7.5e+164)
t_2
(if (<= x -8.5e+36)
(* y (/ (- t x) (- a z)))
(if (<= x -45000.0)
(+ x (* t (/ y a)))
(if (<= x 230.0)
t_1
(if (<= x 5.3e+93) (+ x t) (if (<= x 4.5e+101) t_1 t_2))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double t_2 = x * (1.0 - (y / a));
double tmp;
if (x <= -7.5e+164) {
tmp = t_2;
} else if (x <= -8.5e+36) {
tmp = y * ((t - x) / (a - z));
} else if (x <= -45000.0) {
tmp = x + (t * (y / a));
} else if (x <= 230.0) {
tmp = t_1;
} else if (x <= 5.3e+93) {
tmp = x + t;
} else if (x <= 4.5e+101) {
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 = t * ((y - z) / (a - z))
t_2 = x * (1.0d0 - (y / a))
if (x <= (-7.5d+164)) then
tmp = t_2
else if (x <= (-8.5d+36)) then
tmp = y * ((t - x) / (a - z))
else if (x <= (-45000.0d0)) then
tmp = x + (t * (y / a))
else if (x <= 230.0d0) then
tmp = t_1
else if (x <= 5.3d+93) then
tmp = x + t
else if (x <= 4.5d+101) 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 = t * ((y - z) / (a - z));
double t_2 = x * (1.0 - (y / a));
double tmp;
if (x <= -7.5e+164) {
tmp = t_2;
} else if (x <= -8.5e+36) {
tmp = y * ((t - x) / (a - z));
} else if (x <= -45000.0) {
tmp = x + (t * (y / a));
} else if (x <= 230.0) {
tmp = t_1;
} else if (x <= 5.3e+93) {
tmp = x + t;
} else if (x <= 4.5e+101) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * ((y - z) / (a - z)) t_2 = x * (1.0 - (y / a)) tmp = 0 if x <= -7.5e+164: tmp = t_2 elif x <= -8.5e+36: tmp = y * ((t - x) / (a - z)) elif x <= -45000.0: tmp = x + (t * (y / a)) elif x <= 230.0: tmp = t_1 elif x <= 5.3e+93: tmp = x + t elif x <= 4.5e+101: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(Float64(y - z) / Float64(a - z))) t_2 = Float64(x * Float64(1.0 - Float64(y / a))) tmp = 0.0 if (x <= -7.5e+164) tmp = t_2; elseif (x <= -8.5e+36) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); elseif (x <= -45000.0) tmp = Float64(x + Float64(t * Float64(y / a))); elseif (x <= 230.0) tmp = t_1; elseif (x <= 5.3e+93) tmp = Float64(x + t); elseif (x <= 4.5e+101) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * ((y - z) / (a - z)); t_2 = x * (1.0 - (y / a)); tmp = 0.0; if (x <= -7.5e+164) tmp = t_2; elseif (x <= -8.5e+36) tmp = y * ((t - x) / (a - z)); elseif (x <= -45000.0) tmp = x + (t * (y / a)); elseif (x <= 230.0) tmp = t_1; elseif (x <= 5.3e+93) tmp = x + t; elseif (x <= 4.5e+101) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -7.5e+164], t$95$2, If[LessEqual[x, -8.5e+36], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -45000.0], N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 230.0], t$95$1, If[LessEqual[x, 5.3e+93], N[(x + t), $MachinePrecision], If[LessEqual[x, 4.5e+101], t$95$1, t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y - z}{a - z}\\
t_2 := x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{if}\;x \leq -7.5 \cdot 10^{+164}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;x \leq -8.5 \cdot 10^{+36}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{elif}\;x \leq -45000:\\
\;\;\;\;x + t \cdot \frac{y}{a}\\
\mathbf{elif}\;x \leq 230:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \leq 5.3 \cdot 10^{+93}:\\
\;\;\;\;x + t\\
\mathbf{elif}\;x \leq 4.5 \cdot 10^{+101}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if x < -7.49999999999999976e164 or 4.5000000000000002e101 < x Initial program 62.7%
+-commutative62.7%
associate-*l/84.3%
fma-def84.3%
Simplified84.3%
Taylor expanded in z around 0 51.0%
+-commutative51.0%
associate-/l*56.7%
Simplified56.7%
Taylor expanded in t around 0 50.9%
mul-1-neg50.9%
associate-*l/61.0%
*-commutative61.0%
distribute-rgt-neg-in61.0%
Simplified61.0%
Taylor expanded in x around 0 61.0%
mul-1-neg61.0%
sub-neg61.0%
*-commutative61.0%
Simplified61.0%
if -7.49999999999999976e164 < x < -8.50000000000000014e36Initial program 42.2%
+-commutative42.2%
associate-*l/71.8%
fma-def71.9%
Simplified71.9%
Taylor expanded in y around inf 57.7%
div-sub57.7%
*-commutative57.7%
Simplified57.7%
if -8.50000000000000014e36 < x < -45000Initial program 89.4%
+-commutative89.4%
associate-*l/100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in z around 0 69.5%
+-commutative69.5%
associate-/l*69.5%
Simplified69.5%
Taylor expanded in t around inf 69.5%
associate-*l/69.5%
*-commutative69.5%
Simplified69.5%
if -45000 < x < 230 or 5.3000000000000004e93 < x < 4.5000000000000002e101Initial program 81.5%
+-commutative81.5%
associate-*l/89.9%
fma-def89.9%
Simplified89.9%
Taylor expanded in t around inf 70.9%
div-sub71.0%
Simplified71.0%
if 230 < x < 5.3000000000000004e93Initial program 67.2%
+-commutative67.2%
associate-*l/85.5%
fma-def85.5%
Simplified85.5%
fma-udef85.5%
associate-*l/67.2%
associate-*r/76.5%
Applied egg-rr76.5%
Taylor expanded in t around inf 65.1%
Taylor expanded in z around inf 69.5%
Final simplification67.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* (- y z) (/ t (- a z))))))
(if (<= z -2e+135)
(+ t (/ (- a y) (- (/ z x))))
(if (<= z -7.4e-85)
t_1
(if (<= z 1.1e-129)
(+ x (* (- t x) (/ y a)))
(if (<= z 4.7e+33) t_1 (+ t (* (/ y z) (- x t)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((y - z) * (t / (a - z)));
double tmp;
if (z <= -2e+135) {
tmp = t + ((a - y) / -(z / x));
} else if (z <= -7.4e-85) {
tmp = t_1;
} else if (z <= 1.1e-129) {
tmp = x + ((t - x) * (y / a));
} else if (z <= 4.7e+33) {
tmp = t_1;
} else {
tmp = t + ((y / z) * (x - t));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x + ((y - z) * (t / (a - z)))
if (z <= (-2d+135)) then
tmp = t + ((a - y) / -(z / x))
else if (z <= (-7.4d-85)) then
tmp = t_1
else if (z <= 1.1d-129) then
tmp = x + ((t - x) * (y / a))
else if (z <= 4.7d+33) then
tmp = t_1
else
tmp = t + ((y / z) * (x - t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((y - z) * (t / (a - z)));
double tmp;
if (z <= -2e+135) {
tmp = t + ((a - y) / -(z / x));
} else if (z <= -7.4e-85) {
tmp = t_1;
} else if (z <= 1.1e-129) {
tmp = x + ((t - x) * (y / a));
} else if (z <= 4.7e+33) {
tmp = t_1;
} else {
tmp = t + ((y / z) * (x - t));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + ((y - z) * (t / (a - z))) tmp = 0 if z <= -2e+135: tmp = t + ((a - y) / -(z / x)) elif z <= -7.4e-85: tmp = t_1 elif z <= 1.1e-129: tmp = x + ((t - x) * (y / a)) elif z <= 4.7e+33: tmp = t_1 else: tmp = t + ((y / z) * (x - t)) return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(y - z) * Float64(t / Float64(a - z)))) tmp = 0.0 if (z <= -2e+135) tmp = Float64(t + Float64(Float64(a - y) / Float64(-Float64(z / x)))); elseif (z <= -7.4e-85) tmp = t_1; elseif (z <= 1.1e-129) tmp = Float64(x + Float64(Float64(t - x) * Float64(y / a))); elseif (z <= 4.7e+33) tmp = t_1; else tmp = Float64(t + Float64(Float64(y / z) * Float64(x - t))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + ((y - z) * (t / (a - z))); tmp = 0.0; if (z <= -2e+135) tmp = t + ((a - y) / -(z / x)); elseif (z <= -7.4e-85) tmp = t_1; elseif (z <= 1.1e-129) tmp = x + ((t - x) * (y / a)); elseif (z <= 4.7e+33) tmp = t_1; else tmp = t + ((y / z) * (x - t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(y - z), $MachinePrecision] * N[(t / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2e+135], N[(t + N[(N[(a - y), $MachinePrecision] / (-N[(z / x), $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -7.4e-85], t$95$1, If[LessEqual[z, 1.1e-129], N[(x + N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.7e+33], t$95$1, N[(t + N[(N[(y / z), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(y - z\right) \cdot \frac{t}{a - z}\\
\mathbf{if}\;z \leq -2 \cdot 10^{+135}:\\
\;\;\;\;t + \frac{a - y}{-\frac{z}{x}}\\
\mathbf{elif}\;z \leq -7.4 \cdot 10^{-85}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 1.1 \cdot 10^{-129}:\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y}{a}\\
\mathbf{elif}\;z \leq 4.7 \cdot 10^{+33}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t + \frac{y}{z} \cdot \left(x - t\right)\\
\end{array}
\end{array}
if z < -1.99999999999999992e135Initial program 24.8%
+-commutative24.8%
associate-*l/60.0%
fma-def60.0%
Simplified60.0%
Taylor expanded in z around inf 72.8%
+-commutative72.8%
associate-/l*86.3%
distribute-lft-out--86.3%
mul-1-neg86.3%
distribute-neg-frac86.3%
associate-/l*72.8%
*-commutative72.8%
distribute-rgt-out--72.5%
unsub-neg72.5%
distribute-rgt-out--72.8%
*-commutative72.8%
associate-/l*86.3%
Simplified86.3%
Taylor expanded in t around 0 85.9%
mul-1-neg85.9%
distribute-neg-frac85.9%
Simplified85.9%
if -1.99999999999999992e135 < z < -7.39999999999999966e-85 or 1.10000000000000001e-129 < z < 4.6999999999999998e33Initial program 86.1%
+-commutative86.1%
associate-*l/92.8%
fma-def92.8%
Simplified92.8%
fma-udef92.8%
associate-*l/86.1%
associate-*r/90.7%
Applied egg-rr90.7%
Taylor expanded in t around inf 72.6%
if -7.39999999999999966e-85 < z < 1.10000000000000001e-129Initial program 92.7%
associate-*l/96.6%
Simplified96.6%
Taylor expanded in z around 0 88.7%
if 4.6999999999999998e33 < z Initial program 54.2%
+-commutative54.2%
associate-*l/81.0%
fma-def81.1%
Simplified81.1%
Taylor expanded in z around inf 68.9%
+-commutative68.9%
associate-/l*77.4%
distribute-lft-out--77.4%
mul-1-neg77.4%
distribute-neg-frac77.4%
associate-/l*68.9%
*-commutative68.9%
distribute-rgt-out--68.7%
unsub-neg68.7%
distribute-rgt-out--68.9%
*-commutative68.9%
associate-/l*77.4%
Simplified77.4%
Taylor expanded in y around inf 70.7%
associate-*l/78.9%
Simplified78.9%
Final simplification80.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* (- y z) (/ t (- a z))))))
(if (<= z -9.6e+134)
(+ t (/ (- a y) (/ z (- t x))))
(if (<= z -1.3e-82)
t_1
(if (<= z 5.8e-154)
(+ x (* (- t x) (/ y a)))
(if (<= z 3.8e+33) t_1 (+ t (* (/ y z) (- x t)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((y - z) * (t / (a - z)));
double tmp;
if (z <= -9.6e+134) {
tmp = t + ((a - y) / (z / (t - x)));
} else if (z <= -1.3e-82) {
tmp = t_1;
} else if (z <= 5.8e-154) {
tmp = x + ((t - x) * (y / a));
} else if (z <= 3.8e+33) {
tmp = t_1;
} else {
tmp = t + ((y / z) * (x - t));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x + ((y - z) * (t / (a - z)))
if (z <= (-9.6d+134)) then
tmp = t + ((a - y) / (z / (t - x)))
else if (z <= (-1.3d-82)) then
tmp = t_1
else if (z <= 5.8d-154) then
tmp = x + ((t - x) * (y / a))
else if (z <= 3.8d+33) then
tmp = t_1
else
tmp = t + ((y / z) * (x - t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((y - z) * (t / (a - z)));
double tmp;
if (z <= -9.6e+134) {
tmp = t + ((a - y) / (z / (t - x)));
} else if (z <= -1.3e-82) {
tmp = t_1;
} else if (z <= 5.8e-154) {
tmp = x + ((t - x) * (y / a));
} else if (z <= 3.8e+33) {
tmp = t_1;
} else {
tmp = t + ((y / z) * (x - t));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + ((y - z) * (t / (a - z))) tmp = 0 if z <= -9.6e+134: tmp = t + ((a - y) / (z / (t - x))) elif z <= -1.3e-82: tmp = t_1 elif z <= 5.8e-154: tmp = x + ((t - x) * (y / a)) elif z <= 3.8e+33: tmp = t_1 else: tmp = t + ((y / z) * (x - t)) return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(y - z) * Float64(t / Float64(a - z)))) tmp = 0.0 if (z <= -9.6e+134) tmp = Float64(t + Float64(Float64(a - y) / Float64(z / Float64(t - x)))); elseif (z <= -1.3e-82) tmp = t_1; elseif (z <= 5.8e-154) tmp = Float64(x + Float64(Float64(t - x) * Float64(y / a))); elseif (z <= 3.8e+33) tmp = t_1; else tmp = Float64(t + Float64(Float64(y / z) * Float64(x - t))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + ((y - z) * (t / (a - z))); tmp = 0.0; if (z <= -9.6e+134) tmp = t + ((a - y) / (z / (t - x))); elseif (z <= -1.3e-82) tmp = t_1; elseif (z <= 5.8e-154) tmp = x + ((t - x) * (y / a)); elseif (z <= 3.8e+33) tmp = t_1; else tmp = t + ((y / z) * (x - t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(y - z), $MachinePrecision] * N[(t / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -9.6e+134], N[(t + N[(N[(a - y), $MachinePrecision] / N[(z / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.3e-82], t$95$1, If[LessEqual[z, 5.8e-154], N[(x + N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.8e+33], t$95$1, N[(t + N[(N[(y / z), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(y - z\right) \cdot \frac{t}{a - z}\\
\mathbf{if}\;z \leq -9.6 \cdot 10^{+134}:\\
\;\;\;\;t + \frac{a - y}{\frac{z}{t - x}}\\
\mathbf{elif}\;z \leq -1.3 \cdot 10^{-82}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 5.8 \cdot 10^{-154}:\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y}{a}\\
\mathbf{elif}\;z \leq 3.8 \cdot 10^{+33}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t + \frac{y}{z} \cdot \left(x - t\right)\\
\end{array}
\end{array}
if z < -9.60000000000000021e134Initial program 24.8%
+-commutative24.8%
associate-*l/60.0%
fma-def60.0%
Simplified60.0%
Taylor expanded in z around inf 72.8%
+-commutative72.8%
associate-/l*86.3%
distribute-lft-out--86.3%
mul-1-neg86.3%
distribute-neg-frac86.3%
associate-/l*72.8%
*-commutative72.8%
distribute-rgt-out--72.5%
unsub-neg72.5%
distribute-rgt-out--72.8%
*-commutative72.8%
associate-/l*86.3%
Simplified86.3%
if -9.60000000000000021e134 < z < -1.3e-82 or 5.8e-154 < z < 3.80000000000000002e33Initial program 86.1%
+-commutative86.1%
associate-*l/92.8%
fma-def92.8%
Simplified92.8%
fma-udef92.8%
associate-*l/86.1%
associate-*r/90.7%
Applied egg-rr90.7%
Taylor expanded in t around inf 72.6%
if -1.3e-82 < z < 5.8e-154Initial program 92.7%
associate-*l/96.6%
Simplified96.6%
Taylor expanded in z around 0 88.7%
if 3.80000000000000002e33 < z Initial program 54.2%
+-commutative54.2%
associate-*l/81.0%
fma-def81.1%
Simplified81.1%
Taylor expanded in z around inf 68.9%
+-commutative68.9%
associate-/l*77.4%
distribute-lft-out--77.4%
mul-1-neg77.4%
distribute-neg-frac77.4%
associate-/l*68.9%
*-commutative68.9%
distribute-rgt-out--68.7%
unsub-neg68.7%
distribute-rgt-out--68.9%
*-commutative68.9%
associate-/l*77.4%
Simplified77.4%
Taylor expanded in y around inf 70.7%
associate-*l/78.9%
Simplified78.9%
Final simplification80.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- t) (/ z (- y z)))))
(if (<= z -8.6e+116)
t_1
(if (<= z -1e+64)
(+ x t)
(if (<= z -6.8e+40)
(- (/ (* z t) (- a z)))
(if (<= z -8.5e-92)
(* (/ y z) (- x t))
(if (<= z 1.42e+41) (+ x (/ y (/ a t))) t_1)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = -t / (z / (y - z));
double tmp;
if (z <= -8.6e+116) {
tmp = t_1;
} else if (z <= -1e+64) {
tmp = x + t;
} else if (z <= -6.8e+40) {
tmp = -((z * t) / (a - z));
} else if (z <= -8.5e-92) {
tmp = (y / z) * (x - t);
} else if (z <= 1.42e+41) {
tmp = x + (y / (a / t));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = -t / (z / (y - z))
if (z <= (-8.6d+116)) then
tmp = t_1
else if (z <= (-1d+64)) then
tmp = x + t
else if (z <= (-6.8d+40)) then
tmp = -((z * t) / (a - z))
else if (z <= (-8.5d-92)) then
tmp = (y / z) * (x - t)
else if (z <= 1.42d+41) then
tmp = x + (y / (a / t))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = -t / (z / (y - z));
double tmp;
if (z <= -8.6e+116) {
tmp = t_1;
} else if (z <= -1e+64) {
tmp = x + t;
} else if (z <= -6.8e+40) {
tmp = -((z * t) / (a - z));
} else if (z <= -8.5e-92) {
tmp = (y / z) * (x - t);
} else if (z <= 1.42e+41) {
tmp = x + (y / (a / t));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = -t / (z / (y - z)) tmp = 0 if z <= -8.6e+116: tmp = t_1 elif z <= -1e+64: tmp = x + t elif z <= -6.8e+40: tmp = -((z * t) / (a - z)) elif z <= -8.5e-92: tmp = (y / z) * (x - t) elif z <= 1.42e+41: tmp = x + (y / (a / t)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(-t) / Float64(z / Float64(y - z))) tmp = 0.0 if (z <= -8.6e+116) tmp = t_1; elseif (z <= -1e+64) tmp = Float64(x + t); elseif (z <= -6.8e+40) tmp = Float64(-Float64(Float64(z * t) / Float64(a - z))); elseif (z <= -8.5e-92) tmp = Float64(Float64(y / z) * Float64(x - t)); elseif (z <= 1.42e+41) tmp = Float64(x + Float64(y / Float64(a / t))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = -t / (z / (y - z)); tmp = 0.0; if (z <= -8.6e+116) tmp = t_1; elseif (z <= -1e+64) tmp = x + t; elseif (z <= -6.8e+40) tmp = -((z * t) / (a - z)); elseif (z <= -8.5e-92) tmp = (y / z) * (x - t); elseif (z <= 1.42e+41) tmp = x + (y / (a / t)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[((-t) / N[(z / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -8.6e+116], t$95$1, If[LessEqual[z, -1e+64], N[(x + t), $MachinePrecision], If[LessEqual[z, -6.8e+40], (-N[(N[(z * t), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), If[LessEqual[z, -8.5e-92], N[(N[(y / z), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.42e+41], N[(x + N[(y / N[(a / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{-t}{\frac{z}{y - z}}\\
\mathbf{if}\;z \leq -8.6 \cdot 10^{+116}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -1 \cdot 10^{+64}:\\
\;\;\;\;x + t\\
\mathbf{elif}\;z \leq -6.8 \cdot 10^{+40}:\\
\;\;\;\;-\frac{z \cdot t}{a - z}\\
\mathbf{elif}\;z \leq -8.5 \cdot 10^{-92}:\\
\;\;\;\;\frac{y}{z} \cdot \left(x - t\right)\\
\mathbf{elif}\;z \leq 1.42 \cdot 10^{+41}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if z < -8.6e116 or 1.42000000000000007e41 < z Initial program 45.7%
+-commutative45.7%
associate-*l/75.6%
fma-def75.7%
Simplified75.7%
Taylor expanded in t around inf 62.6%
div-sub62.6%
associate-*r/40.2%
Simplified40.2%
Taylor expanded in a around 0 39.2%
mul-1-neg39.2%
associate-/l*59.0%
distribute-neg-frac59.0%
Simplified59.0%
if -8.6e116 < z < -1.00000000000000002e64Initial program 82.0%
+-commutative82.0%
associate-*l/91.1%
fma-def91.1%
Simplified91.1%
fma-udef91.1%
associate-*l/82.0%
associate-*r/83.8%
Applied egg-rr83.8%
Taylor expanded in t around inf 75.5%
Taylor expanded in z around inf 65.3%
if -1.00000000000000002e64 < z < -6.79999999999999977e40Initial program 85.7%
+-commutative85.7%
associate-*l/85.5%
fma-def85.5%
Simplified85.5%
Taylor expanded in t around inf 63.6%
div-sub63.6%
associate-*r/63.8%
Simplified63.8%
Taylor expanded in y around 0 63.7%
associate-*r/63.7%
mul-1-neg63.7%
Simplified63.7%
if -6.79999999999999977e40 < z < -8.50000000000000067e-92Initial program 86.2%
+-commutative86.2%
associate-*l/86.3%
fma-def86.3%
Simplified86.3%
Taylor expanded in z around inf 60.8%
+-commutative60.8%
associate-/l*57.7%
distribute-lft-out--57.7%
mul-1-neg57.7%
distribute-neg-frac57.7%
associate-/l*60.8%
*-commutative60.8%
distribute-rgt-out--60.8%
unsub-neg60.8%
distribute-rgt-out--60.8%
*-commutative60.8%
associate-/l*57.7%
Simplified57.7%
Taylor expanded in y around -inf 45.7%
mul-1-neg45.7%
associate-*l/45.8%
distribute-rgt-neg-in45.8%
Simplified45.8%
if -8.50000000000000067e-92 < z < 1.42000000000000007e41Initial program 90.7%
+-commutative90.7%
associate-*l/96.8%
fma-def96.8%
Simplified96.8%
Taylor expanded in z around 0 70.7%
+-commutative70.7%
associate-/l*74.3%
Simplified74.3%
Taylor expanded in t around inf 62.4%
Final simplification59.3%
(FPCore (x y z t a)
:precision binary64
(if (<= z -2e+128)
t
(if (<= z -7.2e+81)
(+ x (* x (/ y a)))
(if (<= z -1.45e+62)
(+ x t)
(if (<= z -9.5e-92)
(/ (* x (- y a)) z)
(if (<= z 7.2e+41) (+ x (/ y (/ a t))) t))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2e+128) {
tmp = t;
} else if (z <= -7.2e+81) {
tmp = x + (x * (y / a));
} else if (z <= -1.45e+62) {
tmp = x + t;
} else if (z <= -9.5e-92) {
tmp = (x * (y - a)) / z;
} else if (z <= 7.2e+41) {
tmp = x + (y / (a / t));
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-2d+128)) then
tmp = t
else if (z <= (-7.2d+81)) then
tmp = x + (x * (y / a))
else if (z <= (-1.45d+62)) then
tmp = x + t
else if (z <= (-9.5d-92)) then
tmp = (x * (y - a)) / z
else if (z <= 7.2d+41) then
tmp = x + (y / (a / t))
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2e+128) {
tmp = t;
} else if (z <= -7.2e+81) {
tmp = x + (x * (y / a));
} else if (z <= -1.45e+62) {
tmp = x + t;
} else if (z <= -9.5e-92) {
tmp = (x * (y - a)) / z;
} else if (z <= 7.2e+41) {
tmp = x + (y / (a / t));
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2e+128: tmp = t elif z <= -7.2e+81: tmp = x + (x * (y / a)) elif z <= -1.45e+62: tmp = x + t elif z <= -9.5e-92: tmp = (x * (y - a)) / z elif z <= 7.2e+41: tmp = x + (y / (a / t)) else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2e+128) tmp = t; elseif (z <= -7.2e+81) tmp = Float64(x + Float64(x * Float64(y / a))); elseif (z <= -1.45e+62) tmp = Float64(x + t); elseif (z <= -9.5e-92) tmp = Float64(Float64(x * Float64(y - a)) / z); elseif (z <= 7.2e+41) tmp = Float64(x + Float64(y / Float64(a / t))); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2e+128) tmp = t; elseif (z <= -7.2e+81) tmp = x + (x * (y / a)); elseif (z <= -1.45e+62) tmp = x + t; elseif (z <= -9.5e-92) tmp = (x * (y - a)) / z; elseif (z <= 7.2e+41) tmp = x + (y / (a / t)); else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2e+128], t, If[LessEqual[z, -7.2e+81], N[(x + N[(x * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.45e+62], N[(x + t), $MachinePrecision], If[LessEqual[z, -9.5e-92], N[(N[(x * N[(y - a), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, 7.2e+41], N[(x + N[(y / N[(a / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2 \cdot 10^{+128}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -7.2 \cdot 10^{+81}:\\
\;\;\;\;x + x \cdot \frac{y}{a}\\
\mathbf{elif}\;z \leq -1.45 \cdot 10^{+62}:\\
\;\;\;\;x + t\\
\mathbf{elif}\;z \leq -9.5 \cdot 10^{-92}:\\
\;\;\;\;\frac{x \cdot \left(y - a\right)}{z}\\
\mathbf{elif}\;z \leq 7.2 \cdot 10^{+41}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t}}\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -2.0000000000000002e128 or 7.20000000000000051e41 < z Initial program 45.6%
+-commutative45.6%
associate-*l/75.2%
fma-def75.2%
Simplified75.2%
Taylor expanded in z around inf 50.2%
if -2.0000000000000002e128 < z < -7.20000000000000011e81Initial program 70.3%
+-commutative70.3%
associate-*l/90.2%
fma-def90.2%
Simplified90.2%
Taylor expanded in z around 0 61.1%
+-commutative61.1%
associate-/l*61.1%
Simplified61.1%
Taylor expanded in t around 0 60.5%
mul-1-neg60.5%
associate-*l/60.5%
*-commutative60.5%
distribute-rgt-neg-in60.5%
Simplified60.5%
expm1-log1p-u60.2%
expm1-udef60.4%
add-sqr-sqrt60.0%
sqrt-unprod60.5%
sqr-neg60.5%
sqrt-unprod51.0%
add-sqr-sqrt61.9%
Applied egg-rr61.9%
expm1-def62.1%
expm1-log1p62.1%
Simplified62.1%
if -7.20000000000000011e81 < z < -1.44999999999999992e62Initial program 99.5%
+-commutative99.5%
associate-*l/100.0%
fma-def100.0%
Simplified100.0%
fma-udef100.0%
associate-*l/99.5%
associate-*r/99.5%
Applied egg-rr99.5%
Taylor expanded in t around inf 69.5%
Taylor expanded in z around inf 69.5%
if -1.44999999999999992e62 < z < -9.49999999999999946e-92Initial program 86.1%
+-commutative86.1%
associate-*l/86.2%
fma-def86.2%
Simplified86.2%
Taylor expanded in z around inf 61.3%
+-commutative61.3%
associate-/l*58.8%
distribute-lft-out--58.8%
mul-1-neg58.8%
distribute-neg-frac58.8%
associate-/l*61.3%
*-commutative61.3%
distribute-rgt-out--61.3%
unsub-neg61.3%
distribute-rgt-out--61.3%
*-commutative61.3%
associate-/l*58.8%
Simplified58.8%
Taylor expanded in t around 0 39.4%
if -9.49999999999999946e-92 < z < 7.20000000000000051e41Initial program 90.7%
+-commutative90.7%
associate-*l/96.8%
fma-def96.8%
Simplified96.8%
Taylor expanded in z around 0 70.7%
+-commutative70.7%
associate-/l*74.3%
Simplified74.3%
Taylor expanded in t around inf 62.4%
Final simplification54.3%
(FPCore (x y z t a)
:precision binary64
(if (<= z -1.6e+135)
(+ t (/ (* x (- y a)) z))
(if (<= z -3.8e+62)
(+ x (* (/ t z) (- z y)))
(if (or (<= z -4e-34) (not (<= z 2.7e-22)))
(+ t (* (/ y z) (- x t)))
(+ x (* (- t x) (/ y a)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.6e+135) {
tmp = t + ((x * (y - a)) / z);
} else if (z <= -3.8e+62) {
tmp = x + ((t / z) * (z - y));
} else if ((z <= -4e-34) || !(z <= 2.7e-22)) {
tmp = t + ((y / z) * (x - t));
} else {
tmp = x + ((t - x) * (y / a));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-1.6d+135)) then
tmp = t + ((x * (y - a)) / z)
else if (z <= (-3.8d+62)) then
tmp = x + ((t / z) * (z - y))
else if ((z <= (-4d-34)) .or. (.not. (z <= 2.7d-22))) then
tmp = t + ((y / z) * (x - t))
else
tmp = x + ((t - x) * (y / a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.6e+135) {
tmp = t + ((x * (y - a)) / z);
} else if (z <= -3.8e+62) {
tmp = x + ((t / z) * (z - y));
} else if ((z <= -4e-34) || !(z <= 2.7e-22)) {
tmp = t + ((y / z) * (x - t));
} else {
tmp = x + ((t - x) * (y / a));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1.6e+135: tmp = t + ((x * (y - a)) / z) elif z <= -3.8e+62: tmp = x + ((t / z) * (z - y)) elif (z <= -4e-34) or not (z <= 2.7e-22): tmp = t + ((y / z) * (x - t)) else: tmp = x + ((t - x) * (y / a)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.6e+135) tmp = Float64(t + Float64(Float64(x * Float64(y - a)) / z)); elseif (z <= -3.8e+62) tmp = Float64(x + Float64(Float64(t / z) * Float64(z - y))); elseif ((z <= -4e-34) || !(z <= 2.7e-22)) tmp = Float64(t + Float64(Float64(y / z) * Float64(x - t))); else tmp = Float64(x + Float64(Float64(t - x) * Float64(y / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1.6e+135) tmp = t + ((x * (y - a)) / z); elseif (z <= -3.8e+62) tmp = x + ((t / z) * (z - y)); elseif ((z <= -4e-34) || ~((z <= 2.7e-22))) tmp = t + ((y / z) * (x - t)); else tmp = x + ((t - x) * (y / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.6e+135], N[(t + N[(N[(x * N[(y - a), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.8e+62], N[(x + N[(N[(t / z), $MachinePrecision] * N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[z, -4e-34], N[Not[LessEqual[z, 2.7e-22]], $MachinePrecision]], N[(t + N[(N[(y / z), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.6 \cdot 10^{+135}:\\
\;\;\;\;t + \frac{x \cdot \left(y - a\right)}{z}\\
\mathbf{elif}\;z \leq -3.8 \cdot 10^{+62}:\\
\;\;\;\;x + \frac{t}{z} \cdot \left(z - y\right)\\
\mathbf{elif}\;z \leq -4 \cdot 10^{-34} \lor \neg \left(z \leq 2.7 \cdot 10^{-22}\right):\\
\;\;\;\;t + \frac{y}{z} \cdot \left(x - t\right)\\
\mathbf{else}:\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y}{a}\\
\end{array}
\end{array}
if z < -1.59999999999999987e135Initial program 24.8%
+-commutative24.8%
associate-*l/60.0%
fma-def60.0%
Simplified60.0%
Taylor expanded in z around inf 72.8%
+-commutative72.8%
associate-/l*86.3%
distribute-lft-out--86.3%
mul-1-neg86.3%
distribute-neg-frac86.3%
associate-/l*72.8%
*-commutative72.8%
distribute-rgt-out--72.5%
unsub-neg72.5%
distribute-rgt-out--72.8%
*-commutative72.8%
associate-/l*86.3%
Simplified86.3%
Taylor expanded in t around 0 79.3%
associate-*r/79.3%
*-commutative79.3%
associate-*r*79.3%
neg-mul-179.3%
Simplified79.3%
if -1.59999999999999987e135 < z < -3.79999999999999984e62Initial program 75.5%
+-commutative75.5%
associate-*l/93.9%
fma-def93.9%
Simplified93.9%
fma-udef93.9%
associate-*l/75.5%
associate-*r/88.8%
Applied egg-rr88.8%
Taylor expanded in t around inf 83.0%
Taylor expanded in a around 0 77.1%
associate-*r/77.1%
neg-mul-177.1%
Simplified77.1%
if -3.79999999999999984e62 < z < -3.99999999999999971e-34 or 2.7000000000000002e-22 < z Initial program 66.5%
+-commutative66.5%
associate-*l/84.1%
fma-def84.2%
Simplified84.2%
Taylor expanded in z around inf 66.8%
+-commutative66.8%
associate-/l*71.4%
distribute-lft-out--71.4%
mul-1-neg71.4%
distribute-neg-frac71.4%
associate-/l*66.8%
*-commutative66.8%
distribute-rgt-out--66.6%
unsub-neg66.6%
distribute-rgt-out--66.8%
*-commutative66.8%
associate-/l*71.4%
Simplified71.4%
Taylor expanded in y around inf 67.1%
associate-*l/72.6%
Simplified72.6%
if -3.99999999999999971e-34 < z < 2.7000000000000002e-22Initial program 90.7%
associate-*l/96.0%
Simplified96.0%
Taylor expanded in z around 0 79.0%
Final simplification76.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* (/ y z) (- x t))))
(if (<= z -2.8e+128)
t
(if (<= z -2.6e-92)
t_1
(if (<= z 1.95e+33) (+ x (/ y (/ a t))) (if (<= z 4.8e+173) t_1 t))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (y / z) * (x - t);
double tmp;
if (z <= -2.8e+128) {
tmp = t;
} else if (z <= -2.6e-92) {
tmp = t_1;
} else if (z <= 1.95e+33) {
tmp = x + (y / (a / t));
} else if (z <= 4.8e+173) {
tmp = t_1;
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = (y / z) * (x - t)
if (z <= (-2.8d+128)) then
tmp = t
else if (z <= (-2.6d-92)) then
tmp = t_1
else if (z <= 1.95d+33) then
tmp = x + (y / (a / t))
else if (z <= 4.8d+173) then
tmp = t_1
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (y / z) * (x - t);
double tmp;
if (z <= -2.8e+128) {
tmp = t;
} else if (z <= -2.6e-92) {
tmp = t_1;
} else if (z <= 1.95e+33) {
tmp = x + (y / (a / t));
} else if (z <= 4.8e+173) {
tmp = t_1;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (y / z) * (x - t) tmp = 0 if z <= -2.8e+128: tmp = t elif z <= -2.6e-92: tmp = t_1 elif z <= 1.95e+33: tmp = x + (y / (a / t)) elif z <= 4.8e+173: tmp = t_1 else: tmp = t return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(y / z) * Float64(x - t)) tmp = 0.0 if (z <= -2.8e+128) tmp = t; elseif (z <= -2.6e-92) tmp = t_1; elseif (z <= 1.95e+33) tmp = Float64(x + Float64(y / Float64(a / t))); elseif (z <= 4.8e+173) tmp = t_1; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (y / z) * (x - t); tmp = 0.0; if (z <= -2.8e+128) tmp = t; elseif (z <= -2.6e-92) tmp = t_1; elseif (z <= 1.95e+33) tmp = x + (y / (a / t)); elseif (z <= 4.8e+173) tmp = t_1; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(y / z), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.8e+128], t, If[LessEqual[z, -2.6e-92], t$95$1, If[LessEqual[z, 1.95e+33], N[(x + N[(y / N[(a / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.8e+173], t$95$1, t]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{y}{z} \cdot \left(x - t\right)\\
\mathbf{if}\;z \leq -2.8 \cdot 10^{+128}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -2.6 \cdot 10^{-92}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 1.95 \cdot 10^{+33}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t}}\\
\mathbf{elif}\;z \leq 4.8 \cdot 10^{+173}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -2.79999999999999983e128 or 4.7999999999999998e173 < z Initial program 29.1%
+-commutative29.1%
associate-*l/68.4%
fma-def68.4%
Simplified68.4%
Taylor expanded in z around inf 57.3%
if -2.79999999999999983e128 < z < -2.6e-92 or 1.9500000000000001e33 < z < 4.7999999999999998e173Initial program 81.2%
+-commutative81.2%
associate-*l/87.8%
fma-def87.8%
Simplified87.8%
Taylor expanded in z around inf 63.2%
+-commutative63.2%
associate-/l*63.1%
distribute-lft-out--63.1%
mul-1-neg63.1%
distribute-neg-frac63.1%
associate-/l*63.2%
*-commutative63.2%
distribute-rgt-out--63.2%
unsub-neg63.2%
distribute-rgt-out--63.2%
*-commutative63.2%
associate-/l*63.1%
Simplified63.1%
Taylor expanded in y around -inf 40.7%
mul-1-neg40.7%
associate-*l/43.8%
distribute-rgt-neg-in43.8%
Simplified43.8%
if -2.6e-92 < z < 1.9500000000000001e33Initial program 92.2%
+-commutative92.2%
associate-*l/97.7%
fma-def97.6%
Simplified97.6%
Taylor expanded in z around 0 72.7%
+-commutative72.7%
associate-/l*76.4%
Simplified76.4%
Taylor expanded in t around inf 64.1%
Final simplification55.6%
(FPCore (x y z t a)
:precision binary64
(if (<= z -4e+129)
t
(if (<= z -2.9e-25)
(- x (* z (/ t a)))
(if (<= z 3.25e+32)
(+ x (/ y (/ a t)))
(if (<= z 2.4e+173) (* (/ y z) (- x t)) t)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -4e+129) {
tmp = t;
} else if (z <= -2.9e-25) {
tmp = x - (z * (t / a));
} else if (z <= 3.25e+32) {
tmp = x + (y / (a / t));
} else if (z <= 2.4e+173) {
tmp = (y / z) * (x - t);
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-4d+129)) then
tmp = t
else if (z <= (-2.9d-25)) then
tmp = x - (z * (t / a))
else if (z <= 3.25d+32) then
tmp = x + (y / (a / t))
else if (z <= 2.4d+173) then
tmp = (y / z) * (x - t)
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -4e+129) {
tmp = t;
} else if (z <= -2.9e-25) {
tmp = x - (z * (t / a));
} else if (z <= 3.25e+32) {
tmp = x + (y / (a / t));
} else if (z <= 2.4e+173) {
tmp = (y / z) * (x - t);
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -4e+129: tmp = t elif z <= -2.9e-25: tmp = x - (z * (t / a)) elif z <= 3.25e+32: tmp = x + (y / (a / t)) elif z <= 2.4e+173: tmp = (y / z) * (x - t) else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -4e+129) tmp = t; elseif (z <= -2.9e-25) tmp = Float64(x - Float64(z * Float64(t / a))); elseif (z <= 3.25e+32) tmp = Float64(x + Float64(y / Float64(a / t))); elseif (z <= 2.4e+173) tmp = Float64(Float64(y / z) * Float64(x - t)); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -4e+129) tmp = t; elseif (z <= -2.9e-25) tmp = x - (z * (t / a)); elseif (z <= 3.25e+32) tmp = x + (y / (a / t)); elseif (z <= 2.4e+173) tmp = (y / z) * (x - t); else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -4e+129], t, If[LessEqual[z, -2.9e-25], N[(x - N[(z * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.25e+32], N[(x + N[(y / N[(a / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.4e+173], N[(N[(y / z), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision], t]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -4 \cdot 10^{+129}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -2.9 \cdot 10^{-25}:\\
\;\;\;\;x - z \cdot \frac{t}{a}\\
\mathbf{elif}\;z \leq 3.25 \cdot 10^{+32}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t}}\\
\mathbf{elif}\;z \leq 2.4 \cdot 10^{+173}:\\
\;\;\;\;\frac{y}{z} \cdot \left(x - t\right)\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -4e129 or 2.3999999999999999e173 < z Initial program 29.1%
+-commutative29.1%
associate-*l/68.4%
fma-def68.4%
Simplified68.4%
Taylor expanded in z around inf 57.3%
if -4e129 < z < -2.9000000000000001e-25Initial program 85.2%
+-commutative85.2%
associate-*l/90.8%
fma-def90.8%
Simplified90.8%
Taylor expanded in a around inf 47.3%
+-commutative47.3%
associate-/l*52.8%
Simplified52.8%
Taylor expanded in t around inf 50.2%
Taylor expanded in y around 0 44.5%
mul-1-neg44.5%
associate-*l/47.2%
distribute-rgt-neg-in47.2%
Simplified47.2%
if -2.9000000000000001e-25 < z < 3.2499999999999997e32Initial program 90.8%
+-commutative90.8%
associate-*l/95.5%
fma-def95.5%
Simplified95.5%
Taylor expanded in z around 0 68.9%
+-commutative68.9%
associate-/l*72.0%
Simplified72.0%
Taylor expanded in t around inf 59.6%
if 3.2499999999999997e32 < z < 2.3999999999999999e173Initial program 77.3%
+-commutative77.3%
associate-*l/87.8%
fma-def87.8%
Simplified87.8%
Taylor expanded in z around inf 70.9%
+-commutative70.9%
associate-/l*76.1%
distribute-lft-out--76.1%
mul-1-neg76.1%
distribute-neg-frac76.1%
associate-/l*70.9%
*-commutative70.9%
distribute-rgt-out--70.9%
unsub-neg70.9%
distribute-rgt-out--70.9%
*-commutative70.9%
associate-/l*76.1%
Simplified76.1%
Taylor expanded in y around -inf 39.2%
mul-1-neg39.2%
associate-*l/46.8%
distribute-rgt-neg-in46.8%
Simplified46.8%
Final simplification55.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- t) (/ z (- y z)))))
(if (<= z -1.48e+103)
t_1
(if (<= z -8.5e-92)
(* (/ y z) (- x t))
(if (<= z 4.3e+41) (+ x (/ y (/ a t))) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = -t / (z / (y - z));
double tmp;
if (z <= -1.48e+103) {
tmp = t_1;
} else if (z <= -8.5e-92) {
tmp = (y / z) * (x - t);
} else if (z <= 4.3e+41) {
tmp = x + (y / (a / t));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = -t / (z / (y - z))
if (z <= (-1.48d+103)) then
tmp = t_1
else if (z <= (-8.5d-92)) then
tmp = (y / z) * (x - t)
else if (z <= 4.3d+41) then
tmp = x + (y / (a / t))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = -t / (z / (y - z));
double tmp;
if (z <= -1.48e+103) {
tmp = t_1;
} else if (z <= -8.5e-92) {
tmp = (y / z) * (x - t);
} else if (z <= 4.3e+41) {
tmp = x + (y / (a / t));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = -t / (z / (y - z)) tmp = 0 if z <= -1.48e+103: tmp = t_1 elif z <= -8.5e-92: tmp = (y / z) * (x - t) elif z <= 4.3e+41: tmp = x + (y / (a / t)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(-t) / Float64(z / Float64(y - z))) tmp = 0.0 if (z <= -1.48e+103) tmp = t_1; elseif (z <= -8.5e-92) tmp = Float64(Float64(y / z) * Float64(x - t)); elseif (z <= 4.3e+41) tmp = Float64(x + Float64(y / Float64(a / t))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = -t / (z / (y - z)); tmp = 0.0; if (z <= -1.48e+103) tmp = t_1; elseif (z <= -8.5e-92) tmp = (y / z) * (x - t); elseif (z <= 4.3e+41) tmp = x + (y / (a / t)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[((-t) / N[(z / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.48e+103], t$95$1, If[LessEqual[z, -8.5e-92], N[(N[(y / z), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.3e+41], N[(x + N[(y / N[(a / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{-t}{\frac{z}{y - z}}\\
\mathbf{if}\;z \leq -1.48 \cdot 10^{+103}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -8.5 \cdot 10^{-92}:\\
\;\;\;\;\frac{y}{z} \cdot \left(x - t\right)\\
\mathbf{elif}\;z \leq 4.3 \cdot 10^{+41}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if z < -1.48000000000000009e103 or 4.30000000000000024e41 < z Initial program 46.3%
+-commutative46.3%
associate-*l/76.4%
fma-def76.4%
Simplified76.4%
Taylor expanded in t around inf 61.8%
div-sub61.8%
associate-*r/40.1%
Simplified40.1%
Taylor expanded in a around 0 39.1%
mul-1-neg39.1%
associate-/l*58.3%
distribute-neg-frac58.3%
Simplified58.3%
if -1.48000000000000009e103 < z < -8.50000000000000067e-92Initial program 86.4%
+-commutative86.4%
associate-*l/86.4%
fma-def86.4%
Simplified86.4%
Taylor expanded in z around inf 59.8%
+-commutative59.8%
associate-/l*55.6%
distribute-lft-out--55.6%
mul-1-neg55.6%
distribute-neg-frac55.6%
associate-/l*59.8%
*-commutative59.8%
distribute-rgt-out--59.8%
unsub-neg59.8%
distribute-rgt-out--59.8%
*-commutative59.8%
associate-/l*55.6%
Simplified55.6%
Taylor expanded in y around -inf 43.7%
mul-1-neg43.7%
associate-*l/43.8%
distribute-rgt-neg-in43.8%
Simplified43.8%
if -8.50000000000000067e-92 < z < 4.30000000000000024e41Initial program 90.7%
+-commutative90.7%
associate-*l/96.8%
fma-def96.8%
Simplified96.8%
Taylor expanded in z around 0 70.7%
+-commutative70.7%
associate-/l*74.3%
Simplified74.3%
Taylor expanded in t around inf 62.4%
Final simplification57.4%
(FPCore (x y z t a)
:precision binary64
(if (<= z -1.22e+126)
t
(if (<= z -6.1e-92)
(/ (* y (- x t)) z)
(if (<= z 3e+41) (+ x (/ y (/ a t))) t))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.22e+126) {
tmp = t;
} else if (z <= -6.1e-92) {
tmp = (y * (x - t)) / z;
} else if (z <= 3e+41) {
tmp = x + (y / (a / t));
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-1.22d+126)) then
tmp = t
else if (z <= (-6.1d-92)) then
tmp = (y * (x - t)) / z
else if (z <= 3d+41) then
tmp = x + (y / (a / t))
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.22e+126) {
tmp = t;
} else if (z <= -6.1e-92) {
tmp = (y * (x - t)) / z;
} else if (z <= 3e+41) {
tmp = x + (y / (a / t));
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1.22e+126: tmp = t elif z <= -6.1e-92: tmp = (y * (x - t)) / z elif z <= 3e+41: tmp = x + (y / (a / t)) else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.22e+126) tmp = t; elseif (z <= -6.1e-92) tmp = Float64(Float64(y * Float64(x - t)) / z); elseif (z <= 3e+41) tmp = Float64(x + Float64(y / Float64(a / t))); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1.22e+126) tmp = t; elseif (z <= -6.1e-92) tmp = (y * (x - t)) / z; elseif (z <= 3e+41) tmp = x + (y / (a / t)); else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.22e+126], t, If[LessEqual[z, -6.1e-92], N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, 3e+41], N[(x + N[(y / N[(a / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.22 \cdot 10^{+126}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -6.1 \cdot 10^{-92}:\\
\;\;\;\;\frac{y \cdot \left(x - t\right)}{z}\\
\mathbf{elif}\;z \leq 3 \cdot 10^{+41}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t}}\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -1.21999999999999995e126 or 2.9999999999999998e41 < z Initial program 45.6%
+-commutative45.6%
associate-*l/75.2%
fma-def75.2%
Simplified75.2%
Taylor expanded in z around inf 50.2%
if -1.21999999999999995e126 < z < -6.09999999999999988e-92Initial program 83.8%
+-commutative83.8%
associate-*l/87.8%
fma-def87.8%
Simplified87.8%
Taylor expanded in y around -inf 45.3%
Taylor expanded in a around 0 41.7%
mul-1-neg41.7%
Simplified41.7%
if -6.09999999999999988e-92 < z < 2.9999999999999998e41Initial program 90.7%
+-commutative90.7%
associate-*l/96.8%
fma-def96.8%
Simplified96.8%
Taylor expanded in z around 0 70.7%
+-commutative70.7%
associate-/l*74.3%
Simplified74.3%
Taylor expanded in t around inf 62.4%
Final simplification53.6%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -3.9e-33) (not (<= z 6.1e-34))) (* t (/ (- y z) (- a z))) (+ x (* (- t x) (/ y a)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -3.9e-33) || !(z <= 6.1e-34)) {
tmp = t * ((y - z) / (a - z));
} else {
tmp = x + ((t - x) * (y / a));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((z <= (-3.9d-33)) .or. (.not. (z <= 6.1d-34))) then
tmp = t * ((y - z) / (a - z))
else
tmp = x + ((t - x) * (y / a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -3.9e-33) || !(z <= 6.1e-34)) {
tmp = t * ((y - z) / (a - z));
} else {
tmp = x + ((t - x) * (y / a));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -3.9e-33) or not (z <= 6.1e-34): tmp = t * ((y - z) / (a - z)) else: tmp = x + ((t - x) * (y / a)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -3.9e-33) || !(z <= 6.1e-34)) tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z))); else tmp = Float64(x + Float64(Float64(t - x) * Float64(y / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -3.9e-33) || ~((z <= 6.1e-34))) tmp = t * ((y - z) / (a - z)); else tmp = x + ((t - x) * (y / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -3.9e-33], N[Not[LessEqual[z, 6.1e-34]], $MachinePrecision]], N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3.9 \cdot 10^{-33} \lor \neg \left(z \leq 6.1 \cdot 10^{-34}\right):\\
\;\;\;\;t \cdot \frac{y - z}{a - z}\\
\mathbf{else}:\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y}{a}\\
\end{array}
\end{array}
if z < -3.89999999999999974e-33 or 6.0999999999999998e-34 < z Initial program 58.3%
+-commutative58.3%
associate-*l/79.9%
fma-def79.9%
Simplified79.9%
Taylor expanded in t around inf 56.9%
div-sub56.9%
Simplified56.9%
if -3.89999999999999974e-33 < z < 6.0999999999999998e-34Initial program 92.2%
associate-*l/96.7%
Simplified96.7%
Taylor expanded in z around 0 80.1%
Final simplification66.3%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -6.1e-34) (not (<= z 2.3e-22))) (+ t (* (/ y z) (- x t))) (+ x (* (- t x) (/ y a)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -6.1e-34) || !(z <= 2.3e-22)) {
tmp = t + ((y / z) * (x - t));
} else {
tmp = x + ((t - x) * (y / a));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((z <= (-6.1d-34)) .or. (.not. (z <= 2.3d-22))) then
tmp = t + ((y / z) * (x - t))
else
tmp = x + ((t - x) * (y / a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -6.1e-34) || !(z <= 2.3e-22)) {
tmp = t + ((y / z) * (x - t));
} else {
tmp = x + ((t - x) * (y / a));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -6.1e-34) or not (z <= 2.3e-22): tmp = t + ((y / z) * (x - t)) else: tmp = x + ((t - x) * (y / a)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -6.1e-34) || !(z <= 2.3e-22)) tmp = Float64(t + Float64(Float64(y / z) * Float64(x - t))); else tmp = Float64(x + Float64(Float64(t - x) * Float64(y / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -6.1e-34) || ~((z <= 2.3e-22))) tmp = t + ((y / z) * (x - t)); else tmp = x + ((t - x) * (y / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -6.1e-34], N[Not[LessEqual[z, 2.3e-22]], $MachinePrecision]], N[(t + N[(N[(y / z), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -6.1 \cdot 10^{-34} \lor \neg \left(z \leq 2.3 \cdot 10^{-22}\right):\\
\;\;\;\;t + \frac{y}{z} \cdot \left(x - t\right)\\
\mathbf{else}:\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y}{a}\\
\end{array}
\end{array}
if z < -6.0999999999999998e-34 or 2.2999999999999998e-22 < z Initial program 58.4%
+-commutative58.4%
associate-*l/80.0%
fma-def80.0%
Simplified80.0%
Taylor expanded in z around inf 67.2%
+-commutative67.2%
associate-/l*72.6%
distribute-lft-out--72.6%
mul-1-neg72.6%
distribute-neg-frac72.6%
associate-/l*67.2%
*-commutative67.2%
distribute-rgt-out--67.0%
unsub-neg67.0%
distribute-rgt-out--67.2%
*-commutative67.2%
associate-/l*72.6%
Simplified72.6%
Taylor expanded in y around inf 64.0%
associate-*l/70.4%
Simplified70.4%
if -6.0999999999999998e-34 < z < 2.2999999999999998e-22Initial program 90.7%
associate-*l/96.0%
Simplified96.0%
Taylor expanded in z around 0 79.0%
Final simplification74.0%
(FPCore (x y z t a) :precision binary64 (if (<= z -1.95e+125) t (if (<= z 9.2e-34) (* x (- 1.0 (/ y a))) (if (<= z 6e+239) (+ x t) t))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.95e+125) {
tmp = t;
} else if (z <= 9.2e-34) {
tmp = x * (1.0 - (y / a));
} else if (z <= 6e+239) {
tmp = x + t;
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-1.95d+125)) then
tmp = t
else if (z <= 9.2d-34) then
tmp = x * (1.0d0 - (y / a))
else if (z <= 6d+239) then
tmp = x + t
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.95e+125) {
tmp = t;
} else if (z <= 9.2e-34) {
tmp = x * (1.0 - (y / a));
} else if (z <= 6e+239) {
tmp = x + t;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1.95e+125: tmp = t elif z <= 9.2e-34: tmp = x * (1.0 - (y / a)) elif z <= 6e+239: tmp = x + t else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.95e+125) tmp = t; elseif (z <= 9.2e-34) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (z <= 6e+239) tmp = Float64(x + t); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1.95e+125) tmp = t; elseif (z <= 9.2e-34) tmp = x * (1.0 - (y / a)); elseif (z <= 6e+239) tmp = x + t; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.95e+125], t, If[LessEqual[z, 9.2e-34], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 6e+239], N[(x + t), $MachinePrecision], t]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.95 \cdot 10^{+125}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 9.2 \cdot 10^{-34}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;z \leq 6 \cdot 10^{+239}:\\
\;\;\;\;x + t\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -1.9500000000000001e125 or 5.9999999999999997e239 < z Initial program 30.0%
+-commutative30.0%
associate-*l/65.6%
fma-def65.6%
Simplified65.6%
Taylor expanded in z around inf 60.4%
if -1.9500000000000001e125 < z < 9.20000000000000045e-34Initial program 90.0%
+-commutative90.0%
associate-*l/94.6%
fma-def94.6%
Simplified94.6%
Taylor expanded in z around 0 64.1%
+-commutative64.1%
associate-/l*66.1%
Simplified66.1%
Taylor expanded in t around 0 50.6%
mul-1-neg50.6%
associate-*l/54.5%
*-commutative54.5%
distribute-rgt-neg-in54.5%
Simplified54.5%
Taylor expanded in x around 0 54.5%
mul-1-neg54.5%
sub-neg54.5%
*-commutative54.5%
Simplified54.5%
if 9.20000000000000045e-34 < z < 5.9999999999999997e239Initial program 66.2%
+-commutative66.2%
associate-*l/86.4%
fma-def86.4%
Simplified86.4%
fma-udef86.4%
associate-*l/66.2%
associate-*r/83.3%
Applied egg-rr83.3%
Taylor expanded in t around inf 62.6%
Taylor expanded in z around inf 43.2%
Final simplification53.1%
(FPCore (x y z t a) :precision binary64 (if (<= z -1.25e+125) t (if (<= z 1.05e+42) (+ x (* t (/ y a))) t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.25e+125) {
tmp = t;
} else if (z <= 1.05e+42) {
tmp = x + (t * (y / a));
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-1.25d+125)) then
tmp = t
else if (z <= 1.05d+42) then
tmp = x + (t * (y / a))
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.25e+125) {
tmp = t;
} else if (z <= 1.05e+42) {
tmp = x + (t * (y / a));
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1.25e+125: tmp = t elif z <= 1.05e+42: tmp = x + (t * (y / a)) else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.25e+125) tmp = t; elseif (z <= 1.05e+42) tmp = Float64(x + Float64(t * Float64(y / a))); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1.25e+125) tmp = t; elseif (z <= 1.05e+42) tmp = x + (t * (y / a)); else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.25e+125], t, If[LessEqual[z, 1.05e+42], N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.25 \cdot 10^{+125}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 1.05 \cdot 10^{+42}:\\
\;\;\;\;x + t \cdot \frac{y}{a}\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -1.24999999999999991e125 or 1.04999999999999998e42 < z Initial program 45.6%
+-commutative45.6%
associate-*l/75.2%
fma-def75.2%
Simplified75.2%
Taylor expanded in z around inf 50.2%
if -1.24999999999999991e125 < z < 1.04999999999999998e42Initial program 88.5%
+-commutative88.5%
associate-*l/93.9%
fma-def93.9%
Simplified93.9%
Taylor expanded in z around 0 60.5%
+-commutative60.5%
associate-/l*62.9%
Simplified62.9%
Taylor expanded in t around inf 51.9%
associate-*l/53.0%
*-commutative53.0%
Simplified53.0%
Final simplification51.9%
(FPCore (x y z t a) :precision binary64 (if (<= z -3.2e+125) t (if (<= z 1.5e+42) (+ x (/ y (/ a t))) t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -3.2e+125) {
tmp = t;
} else if (z <= 1.5e+42) {
tmp = x + (y / (a / t));
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-3.2d+125)) then
tmp = t
else if (z <= 1.5d+42) then
tmp = x + (y / (a / t))
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -3.2e+125) {
tmp = t;
} else if (z <= 1.5e+42) {
tmp = x + (y / (a / t));
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -3.2e+125: tmp = t elif z <= 1.5e+42: tmp = x + (y / (a / t)) else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -3.2e+125) tmp = t; elseif (z <= 1.5e+42) tmp = Float64(x + Float64(y / Float64(a / t))); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -3.2e+125) tmp = t; elseif (z <= 1.5e+42) tmp = x + (y / (a / t)); else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -3.2e+125], t, If[LessEqual[z, 1.5e+42], N[(x + N[(y / N[(a / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3.2 \cdot 10^{+125}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 1.5 \cdot 10^{+42}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t}}\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -3.19999999999999983e125 or 1.50000000000000014e42 < z Initial program 45.6%
+-commutative45.6%
associate-*l/75.2%
fma-def75.2%
Simplified75.2%
Taylor expanded in z around inf 50.2%
if -3.19999999999999983e125 < z < 1.50000000000000014e42Initial program 88.5%
+-commutative88.5%
associate-*l/93.9%
fma-def93.9%
Simplified93.9%
Taylor expanded in z around 0 60.5%
+-commutative60.5%
associate-/l*62.9%
Simplified62.9%
Taylor expanded in t around inf 53.0%
Final simplification51.9%
(FPCore (x y z t a) :precision binary64 (if (<= z -2.5e+125) t (if (<= z 5.2e-115) x (if (<= z 2.7e+240) (+ x t) t))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.5e+125) {
tmp = t;
} else if (z <= 5.2e-115) {
tmp = x;
} else if (z <= 2.7e+240) {
tmp = x + t;
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-2.5d+125)) then
tmp = t
else if (z <= 5.2d-115) then
tmp = x
else if (z <= 2.7d+240) then
tmp = x + t
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.5e+125) {
tmp = t;
} else if (z <= 5.2e-115) {
tmp = x;
} else if (z <= 2.7e+240) {
tmp = x + t;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.5e+125: tmp = t elif z <= 5.2e-115: tmp = x elif z <= 2.7e+240: tmp = x + t else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.5e+125) tmp = t; elseif (z <= 5.2e-115) tmp = x; elseif (z <= 2.7e+240) tmp = Float64(x + t); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.5e+125) tmp = t; elseif (z <= 5.2e-115) tmp = x; elseif (z <= 2.7e+240) tmp = x + t; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.5e+125], t, If[LessEqual[z, 5.2e-115], x, If[LessEqual[z, 2.7e+240], N[(x + t), $MachinePrecision], t]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.5 \cdot 10^{+125}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 5.2 \cdot 10^{-115}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 2.7 \cdot 10^{+240}:\\
\;\;\;\;x + t\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -2.49999999999999981e125 or 2.6999999999999999e240 < z Initial program 30.0%
+-commutative30.0%
associate-*l/65.6%
fma-def65.6%
Simplified65.6%
Taylor expanded in z around inf 60.4%
if -2.49999999999999981e125 < z < 5.20000000000000008e-115Initial program 89.8%
+-commutative89.8%
associate-*l/93.8%
fma-def93.8%
Simplified93.8%
Taylor expanded in a around inf 37.6%
if 5.20000000000000008e-115 < z < 2.6999999999999999e240Initial program 72.6%
+-commutative72.6%
associate-*l/89.9%
fma-def89.9%
Simplified89.9%
fma-udef89.9%
associate-*l/72.6%
associate-*r/87.6%
Applied egg-rr87.6%
Taylor expanded in t around inf 67.8%
Taylor expanded in z around inf 42.5%
Final simplification43.9%
(FPCore (x y z t a) :precision binary64 (if (<= z -2.55e+128) t (if (<= z 1.6e-37) x t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.55e+128) {
tmp = t;
} else if (z <= 1.6e-37) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-2.55d+128)) then
tmp = t
else if (z <= 1.6d-37) then
tmp = x
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.55e+128) {
tmp = t;
} else if (z <= 1.6e-37) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.55e+128: tmp = t elif z <= 1.6e-37: tmp = x else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.55e+128) tmp = t; elseif (z <= 1.6e-37) tmp = x; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.55e+128) tmp = t; elseif (z <= 1.6e-37) tmp = x; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.55e+128], t, If[LessEqual[z, 1.6e-37], x, t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.55 \cdot 10^{+128}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 1.6 \cdot 10^{-37}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -2.5499999999999999e128 or 1.5999999999999999e-37 < z Initial program 49.1%
+-commutative49.1%
associate-*l/76.9%
fma-def76.9%
Simplified76.9%
Taylor expanded in z around inf 46.1%
if -2.5499999999999999e128 < z < 1.5999999999999999e-37Initial program 90.5%
+-commutative90.5%
associate-*l/94.6%
fma-def94.6%
Simplified94.6%
Taylor expanded in a around inf 38.5%
Final simplification41.9%
(FPCore (x y z t a) :precision binary64 0.0)
double code(double x, double y, double z, double t, double a) {
return 0.0;
}
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 = 0.0d0
end function
public static double code(double x, double y, double z, double t, double a) {
return 0.0;
}
def code(x, y, z, t, a): return 0.0
function code(x, y, z, t, a) return 0.0 end
function tmp = code(x, y, z, t, a) tmp = 0.0; end
code[x_, y_, z_, t_, a_] := 0.0
\begin{array}{l}
\\
0
\end{array}
Initial program 72.1%
+-commutative72.1%
associate-*r/82.0%
fma-def82.0%
Simplified82.0%
Taylor expanded in t around 0 43.3%
neg-mul-143.3%
distribute-neg-frac43.3%
Simplified43.3%
Taylor expanded in z around inf 2.8%
mul-1-neg2.8%
+-commutative2.8%
sub-neg2.8%
+-inverses2.8%
Simplified2.8%
Final simplification2.8%
(FPCore (x y z t a) :precision binary64 t)
double code(double x, double y, double z, double t, double a) {
return t;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = t
end function
public static double code(double x, double y, double z, double t, double a) {
return t;
}
def code(x, y, z, t, a): return t
function code(x, y, z, t, a) return t end
function tmp = code(x, y, z, t, a) tmp = t; end
code[x_, y_, z_, t_, a_] := t
\begin{array}{l}
\\
t
\end{array}
Initial program 72.1%
+-commutative72.1%
associate-*l/86.7%
fma-def86.7%
Simplified86.7%
Taylor expanded in z around inf 25.7%
Final simplification25.7%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- t (* (/ y z) (- t x)))))
(if (< z -1.2536131056095036e+188)
t_1
(if (< z 4.446702369113811e+64)
(+ x (/ (- y z) (/ (- a z) (- t x))))
t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t - ((y / z) * (t - x));
double tmp;
if (z < -1.2536131056095036e+188) {
tmp = t_1;
} else if (z < 4.446702369113811e+64) {
tmp = x + ((y - z) / ((a - z) / (t - x)));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = t - ((y / z) * (t - x))
if (z < (-1.2536131056095036d+188)) then
tmp = t_1
else if (z < 4.446702369113811d+64) then
tmp = x + ((y - z) / ((a - z) / (t - x)))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t - ((y / z) * (t - x));
double tmp;
if (z < -1.2536131056095036e+188) {
tmp = t_1;
} else if (z < 4.446702369113811e+64) {
tmp = x + ((y - z) / ((a - z) / (t - x)));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t - ((y / z) * (t - x)) tmp = 0 if z < -1.2536131056095036e+188: tmp = t_1 elif z < 4.446702369113811e+64: tmp = x + ((y - z) / ((a - z) / (t - x))) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t - Float64(Float64(y / z) * Float64(t - x))) tmp = 0.0 if (z < -1.2536131056095036e+188) tmp = t_1; elseif (z < 4.446702369113811e+64) tmp = Float64(x + Float64(Float64(y - z) / Float64(Float64(a - z) / Float64(t - x)))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t - ((y / z) * (t - x)); tmp = 0.0; if (z < -1.2536131056095036e+188) tmp = t_1; elseif (z < 4.446702369113811e+64) tmp = x + ((y - z) / ((a - z) / (t - x))); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t - N[(N[(y / z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[z, -1.2536131056095036e+188], t$95$1, If[Less[z, 4.446702369113811e+64], N[(x + N[(N[(y - z), $MachinePrecision] / N[(N[(a - z), $MachinePrecision] / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t - \frac{y}{z} \cdot \left(t - x\right)\\
\mathbf{if}\;z < -1.2536131056095036 \cdot 10^{+188}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z < 4.446702369113811 \cdot 10^{+64}:\\
\;\;\;\;x + \frac{y - z}{\frac{a - z}{t - x}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
herbie shell --seed 2023230
(FPCore (x y z t a)
:name "Graphics.Rendering.Chart.Axis.Types:invLinMap from Chart-1.5.3"
:precision binary64
:herbie-target
(if (< z -1.2536131056095036e+188) (- t (* (/ y z) (- t x))) (if (< z 4.446702369113811e+64) (+ x (/ (- y z) (/ (- a z) (- t x)))) (- t (* (/ y z) (- t x)))))
(+ x (/ (* (- y z) (- t x)) (- a z))))