
(FPCore (x y z t a) :precision binary64 (+ x (/ (* (- y x) (- z t)) (- a t))))
double code(double x, double y, double z, double t, double a) {
return x + (((y - x) * (z - t)) / (a - t));
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = x + (((y - x) * (z - t)) / (a - t))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + (((y - x) * (z - t)) / (a - t));
}
def code(x, y, z, t, a): return x + (((y - x) * (z - t)) / (a - t))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(Float64(y - x) * Float64(z - t)) / Float64(a - t))) end
function tmp = code(x, y, z, t, a) tmp = x + (((y - x) * (z - t)) / (a - t)); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(N[(y - x), $MachinePrecision] * N[(z - t), $MachinePrecision]), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{\left(y - x\right) \cdot \left(z - t\right)}{a - t}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 30 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (+ x (/ (* (- y x) (- z t)) (- a t))))
double code(double x, double y, double z, double t, double a) {
return x + (((y - x) * (z - t)) / (a - t));
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = x + (((y - x) * (z - t)) / (a - t))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + (((y - x) * (z - t)) / (a - t));
}
def code(x, y, z, t, a): return x + (((y - x) * (z - t)) / (a - t))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(Float64(y - x) * Float64(z - t)) / Float64(a - t))) end
function tmp = code(x, y, z, t, a) tmp = x + (((y - x) * (z - t)) / (a - t)); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(N[(y - x), $MachinePrecision] * N[(z - t), $MachinePrecision]), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{\left(y - x\right) \cdot \left(z - t\right)}{a - t}
\end{array}
(FPCore (x y z t a) :precision binary64 (if (or (<= t -7.5e+74) (not (<= t 2.7e+75))) (+ y (/ (- x y) (/ t (- z a)))) (fma (/ (- z t) (- a t)) (- y x) x)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((t <= -7.5e+74) || !(t <= 2.7e+75)) {
tmp = y + ((x - y) / (t / (z - a)));
} else {
tmp = fma(((z - t) / (a - t)), (y - x), x);
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if ((t <= -7.5e+74) || !(t <= 2.7e+75)) tmp = Float64(y + Float64(Float64(x - y) / Float64(t / Float64(z - a)))); else tmp = fma(Float64(Float64(z - t) / Float64(a - t)), Float64(y - x), x); end return tmp end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[t, -7.5e+74], N[Not[LessEqual[t, 2.7e+75]], $MachinePrecision]], N[(y + N[(N[(x - y), $MachinePrecision] / N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision] * N[(y - x), $MachinePrecision] + x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -7.5 \cdot 10^{+74} \lor \neg \left(t \leq 2.7 \cdot 10^{+75}\right):\\
\;\;\;\;y + \frac{x - y}{\frac{t}{z - a}}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{z - t}{a - t}, y - x, x\right)\\
\end{array}
\end{array}
if t < -7.5e74 or 2.69999999999999998e75 < t Initial program 33.5%
associate-*l/58.8%
Simplified58.8%
Taylor expanded in t around inf 69.7%
associate--l+69.7%
associate-*r/69.7%
associate-*r/69.7%
div-sub69.7%
distribute-lft-out--69.7%
associate-*r/69.7%
mul-1-neg69.7%
unsub-neg69.7%
distribute-rgt-out--71.0%
associate-/l*87.6%
Simplified87.6%
if -7.5e74 < t < 2.69999999999999998e75Initial program 86.3%
+-commutative86.3%
*-commutative86.3%
associate-/l*91.3%
associate-/r/91.4%
fma-def91.4%
Simplified91.4%
Final simplification90.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* x (/ (- z) (- a t)))) (t_2 (/ (- y) (/ t (- z t)))))
(if (<= a -4.5e+91)
x
(if (<= a -8.5e+35)
(/ (- t) (/ (- a t) y))
(if (<= a -102.0)
x
(if (<= a -7.6e-134)
t_2
(if (<= a -1.02e-210)
t_1
(if (<= a 2.7e-234)
t_2
(if (<= a 1.04e-181)
(/ x (/ t (- z a)))
(if (<= a 5.8e-123)
t_2
(if (<= a 6.8e-53)
t_1
(if (<= a 5.6e-12)
x
(if (<= a 2.8e+128)
(/ z (/ a (- y x)))
(* x (+ (/ t (- a t)) 1.0)))))))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x * (-z / (a - t));
double t_2 = -y / (t / (z - t));
double tmp;
if (a <= -4.5e+91) {
tmp = x;
} else if (a <= -8.5e+35) {
tmp = -t / ((a - t) / y);
} else if (a <= -102.0) {
tmp = x;
} else if (a <= -7.6e-134) {
tmp = t_2;
} else if (a <= -1.02e-210) {
tmp = t_1;
} else if (a <= 2.7e-234) {
tmp = t_2;
} else if (a <= 1.04e-181) {
tmp = x / (t / (z - a));
} else if (a <= 5.8e-123) {
tmp = t_2;
} else if (a <= 6.8e-53) {
tmp = t_1;
} else if (a <= 5.6e-12) {
tmp = x;
} else if (a <= 2.8e+128) {
tmp = z / (a / (y - x));
} else {
tmp = x * ((t / (a - t)) + 1.0);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x * (-z / (a - t))
t_2 = -y / (t / (z - t))
if (a <= (-4.5d+91)) then
tmp = x
else if (a <= (-8.5d+35)) then
tmp = -t / ((a - t) / y)
else if (a <= (-102.0d0)) then
tmp = x
else if (a <= (-7.6d-134)) then
tmp = t_2
else if (a <= (-1.02d-210)) then
tmp = t_1
else if (a <= 2.7d-234) then
tmp = t_2
else if (a <= 1.04d-181) then
tmp = x / (t / (z - a))
else if (a <= 5.8d-123) then
tmp = t_2
else if (a <= 6.8d-53) then
tmp = t_1
else if (a <= 5.6d-12) then
tmp = x
else if (a <= 2.8d+128) then
tmp = z / (a / (y - x))
else
tmp = x * ((t / (a - t)) + 1.0d0)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x * (-z / (a - t));
double t_2 = -y / (t / (z - t));
double tmp;
if (a <= -4.5e+91) {
tmp = x;
} else if (a <= -8.5e+35) {
tmp = -t / ((a - t) / y);
} else if (a <= -102.0) {
tmp = x;
} else if (a <= -7.6e-134) {
tmp = t_2;
} else if (a <= -1.02e-210) {
tmp = t_1;
} else if (a <= 2.7e-234) {
tmp = t_2;
} else if (a <= 1.04e-181) {
tmp = x / (t / (z - a));
} else if (a <= 5.8e-123) {
tmp = t_2;
} else if (a <= 6.8e-53) {
tmp = t_1;
} else if (a <= 5.6e-12) {
tmp = x;
} else if (a <= 2.8e+128) {
tmp = z / (a / (y - x));
} else {
tmp = x * ((t / (a - t)) + 1.0);
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x * (-z / (a - t)) t_2 = -y / (t / (z - t)) tmp = 0 if a <= -4.5e+91: tmp = x elif a <= -8.5e+35: tmp = -t / ((a - t) / y) elif a <= -102.0: tmp = x elif a <= -7.6e-134: tmp = t_2 elif a <= -1.02e-210: tmp = t_1 elif a <= 2.7e-234: tmp = t_2 elif a <= 1.04e-181: tmp = x / (t / (z - a)) elif a <= 5.8e-123: tmp = t_2 elif a <= 6.8e-53: tmp = t_1 elif a <= 5.6e-12: tmp = x elif a <= 2.8e+128: tmp = z / (a / (y - x)) else: tmp = x * ((t / (a - t)) + 1.0) return tmp
function code(x, y, z, t, a) t_1 = Float64(x * Float64(Float64(-z) / Float64(a - t))) t_2 = Float64(Float64(-y) / Float64(t / Float64(z - t))) tmp = 0.0 if (a <= -4.5e+91) tmp = x; elseif (a <= -8.5e+35) tmp = Float64(Float64(-t) / Float64(Float64(a - t) / y)); elseif (a <= -102.0) tmp = x; elseif (a <= -7.6e-134) tmp = t_2; elseif (a <= -1.02e-210) tmp = t_1; elseif (a <= 2.7e-234) tmp = t_2; elseif (a <= 1.04e-181) tmp = Float64(x / Float64(t / Float64(z - a))); elseif (a <= 5.8e-123) tmp = t_2; elseif (a <= 6.8e-53) tmp = t_1; elseif (a <= 5.6e-12) tmp = x; elseif (a <= 2.8e+128) tmp = Float64(z / Float64(a / Float64(y - x))); else tmp = Float64(x * Float64(Float64(t / Float64(a - t)) + 1.0)); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x * (-z / (a - t)); t_2 = -y / (t / (z - t)); tmp = 0.0; if (a <= -4.5e+91) tmp = x; elseif (a <= -8.5e+35) tmp = -t / ((a - t) / y); elseif (a <= -102.0) tmp = x; elseif (a <= -7.6e-134) tmp = t_2; elseif (a <= -1.02e-210) tmp = t_1; elseif (a <= 2.7e-234) tmp = t_2; elseif (a <= 1.04e-181) tmp = x / (t / (z - a)); elseif (a <= 5.8e-123) tmp = t_2; elseif (a <= 6.8e-53) tmp = t_1; elseif (a <= 5.6e-12) tmp = x; elseif (a <= 2.8e+128) tmp = z / (a / (y - x)); else tmp = x * ((t / (a - t)) + 1.0); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x * N[((-z) / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[((-y) / N[(t / N[(z - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -4.5e+91], x, If[LessEqual[a, -8.5e+35], N[((-t) / N[(N[(a - t), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -102.0], x, If[LessEqual[a, -7.6e-134], t$95$2, If[LessEqual[a, -1.02e-210], t$95$1, If[LessEqual[a, 2.7e-234], t$95$2, If[LessEqual[a, 1.04e-181], N[(x / N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 5.8e-123], t$95$2, If[LessEqual[a, 6.8e-53], t$95$1, If[LessEqual[a, 5.6e-12], x, If[LessEqual[a, 2.8e+128], N[(z / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(N[(t / N[(a - t), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{-z}{a - t}\\
t_2 := \frac{-y}{\frac{t}{z - t}}\\
\mathbf{if}\;a \leq -4.5 \cdot 10^{+91}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -8.5 \cdot 10^{+35}:\\
\;\;\;\;\frac{-t}{\frac{a - t}{y}}\\
\mathbf{elif}\;a \leq -102:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -7.6 \cdot 10^{-134}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq -1.02 \cdot 10^{-210}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 2.7 \cdot 10^{-234}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq 1.04 \cdot 10^{-181}:\\
\;\;\;\;\frac{x}{\frac{t}{z - a}}\\
\mathbf{elif}\;a \leq 5.8 \cdot 10^{-123}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq 6.8 \cdot 10^{-53}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 5.6 \cdot 10^{-12}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 2.8 \cdot 10^{+128}:\\
\;\;\;\;\frac{z}{\frac{a}{y - x}}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(\frac{t}{a - t} + 1\right)\\
\end{array}
\end{array}
if a < -4.5e91 or -8.4999999999999995e35 < a < -102 or 6.8e-53 < a < 5.6000000000000004e-12Initial program 76.9%
associate-*l/91.4%
Simplified91.4%
Taylor expanded in a around inf 56.0%
if -4.5e91 < a < -8.4999999999999995e35Initial program 74.2%
associate-*l/91.1%
Simplified91.1%
Taylor expanded in x around 0 47.8%
Taylor expanded in z around 0 39.2%
mul-1-neg39.2%
associate-/l*56.6%
distribute-neg-frac56.6%
Simplified56.6%
if -102 < a < -7.60000000000000006e-134 or -1.02000000000000002e-210 < a < 2.7000000000000002e-234 or 1.04000000000000002e-181 < a < 5.80000000000000007e-123Initial program 72.0%
associate-*l/75.2%
Simplified75.2%
Taylor expanded in x around 0 65.3%
Taylor expanded in a around 0 54.0%
mul-1-neg54.0%
associate-/l*66.5%
distribute-neg-frac66.5%
Simplified66.5%
if -7.60000000000000006e-134 < a < -1.02000000000000002e-210 or 5.80000000000000007e-123 < a < 6.8e-53Initial program 64.8%
associate-*l/77.1%
Simplified77.1%
Taylor expanded in x around -inf 77.1%
mul-1-neg77.1%
*-commutative77.1%
distribute-rgt-neg-in77.1%
associate--r+64.2%
sub-neg64.2%
metadata-eval64.2%
Simplified64.2%
Taylor expanded in z around inf 68.8%
if 2.7000000000000002e-234 < a < 1.04000000000000002e-181Initial program 47.4%
associate-*l/47.8%
Simplified47.8%
Taylor expanded in x around -inf 70.5%
mul-1-neg70.5%
*-commutative70.5%
distribute-rgt-neg-in70.5%
associate--r+40.0%
sub-neg40.0%
metadata-eval40.0%
Simplified40.0%
Taylor expanded in t around -inf 70.2%
associate-/l*77.2%
Simplified77.2%
if 5.6000000000000004e-12 < a < 2.79999999999999983e128Initial program 72.7%
+-commutative72.7%
associate-*l/85.4%
fma-def85.8%
Simplified85.8%
fma-udef85.4%
associate-/r/85.4%
div-inv85.4%
clear-num85.5%
Applied egg-rr85.5%
clear-num85.4%
un-div-inv85.4%
Applied egg-rr85.4%
Taylor expanded in z around -inf 49.1%
associate-/l*58.1%
Simplified58.1%
Taylor expanded in a around inf 48.4%
if 2.79999999999999983e128 < a Initial program 63.7%
associate-*l/90.6%
Simplified90.6%
Taylor expanded in x around -inf 62.5%
mul-1-neg62.5%
*-commutative62.5%
distribute-rgt-neg-in62.5%
associate--r+62.5%
sub-neg62.5%
metadata-eval62.5%
Simplified62.5%
Taylor expanded in z around 0 55.5%
+-commutative55.5%
Simplified55.5%
Final simplification61.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* x (/ (- z) (- a t)))) (t_2 (/ (- y) (/ t (- z t)))))
(if (<= a -4.5e+91)
x
(if (<= a -5.2e+35)
(/ (- t) (/ (- a t) y))
(if (<= a -0.245)
x
(if (<= a -1.4e-129)
t_2
(if (<= a -4.8e-210)
t_1
(if (<= a 2.8e-235)
t_2
(if (<= a 2.9e-181)
(/ x (/ t (- z a)))
(if (<= a 2.8e-122)
t_2
(if (<= a 2.2e-53)
t_1
(if (<= a 4.5e-9)
x
(if (<= a 1.8e+127) (/ z (/ a (- y x))) x)))))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x * (-z / (a - t));
double t_2 = -y / (t / (z - t));
double tmp;
if (a <= -4.5e+91) {
tmp = x;
} else if (a <= -5.2e+35) {
tmp = -t / ((a - t) / y);
} else if (a <= -0.245) {
tmp = x;
} else if (a <= -1.4e-129) {
tmp = t_2;
} else if (a <= -4.8e-210) {
tmp = t_1;
} else if (a <= 2.8e-235) {
tmp = t_2;
} else if (a <= 2.9e-181) {
tmp = x / (t / (z - a));
} else if (a <= 2.8e-122) {
tmp = t_2;
} else if (a <= 2.2e-53) {
tmp = t_1;
} else if (a <= 4.5e-9) {
tmp = x;
} else if (a <= 1.8e+127) {
tmp = z / (a / (y - x));
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x * (-z / (a - t))
t_2 = -y / (t / (z - t))
if (a <= (-4.5d+91)) then
tmp = x
else if (a <= (-5.2d+35)) then
tmp = -t / ((a - t) / y)
else if (a <= (-0.245d0)) then
tmp = x
else if (a <= (-1.4d-129)) then
tmp = t_2
else if (a <= (-4.8d-210)) then
tmp = t_1
else if (a <= 2.8d-235) then
tmp = t_2
else if (a <= 2.9d-181) then
tmp = x / (t / (z - a))
else if (a <= 2.8d-122) then
tmp = t_2
else if (a <= 2.2d-53) then
tmp = t_1
else if (a <= 4.5d-9) then
tmp = x
else if (a <= 1.8d+127) then
tmp = z / (a / (y - x))
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x * (-z / (a - t));
double t_2 = -y / (t / (z - t));
double tmp;
if (a <= -4.5e+91) {
tmp = x;
} else if (a <= -5.2e+35) {
tmp = -t / ((a - t) / y);
} else if (a <= -0.245) {
tmp = x;
} else if (a <= -1.4e-129) {
tmp = t_2;
} else if (a <= -4.8e-210) {
tmp = t_1;
} else if (a <= 2.8e-235) {
tmp = t_2;
} else if (a <= 2.9e-181) {
tmp = x / (t / (z - a));
} else if (a <= 2.8e-122) {
tmp = t_2;
} else if (a <= 2.2e-53) {
tmp = t_1;
} else if (a <= 4.5e-9) {
tmp = x;
} else if (a <= 1.8e+127) {
tmp = z / (a / (y - x));
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x * (-z / (a - t)) t_2 = -y / (t / (z - t)) tmp = 0 if a <= -4.5e+91: tmp = x elif a <= -5.2e+35: tmp = -t / ((a - t) / y) elif a <= -0.245: tmp = x elif a <= -1.4e-129: tmp = t_2 elif a <= -4.8e-210: tmp = t_1 elif a <= 2.8e-235: tmp = t_2 elif a <= 2.9e-181: tmp = x / (t / (z - a)) elif a <= 2.8e-122: tmp = t_2 elif a <= 2.2e-53: tmp = t_1 elif a <= 4.5e-9: tmp = x elif a <= 1.8e+127: tmp = z / (a / (y - x)) else: tmp = x return tmp
function code(x, y, z, t, a) t_1 = Float64(x * Float64(Float64(-z) / Float64(a - t))) t_2 = Float64(Float64(-y) / Float64(t / Float64(z - t))) tmp = 0.0 if (a <= -4.5e+91) tmp = x; elseif (a <= -5.2e+35) tmp = Float64(Float64(-t) / Float64(Float64(a - t) / y)); elseif (a <= -0.245) tmp = x; elseif (a <= -1.4e-129) tmp = t_2; elseif (a <= -4.8e-210) tmp = t_1; elseif (a <= 2.8e-235) tmp = t_2; elseif (a <= 2.9e-181) tmp = Float64(x / Float64(t / Float64(z - a))); elseif (a <= 2.8e-122) tmp = t_2; elseif (a <= 2.2e-53) tmp = t_1; elseif (a <= 4.5e-9) tmp = x; elseif (a <= 1.8e+127) tmp = Float64(z / Float64(a / Float64(y - x))); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x * (-z / (a - t)); t_2 = -y / (t / (z - t)); tmp = 0.0; if (a <= -4.5e+91) tmp = x; elseif (a <= -5.2e+35) tmp = -t / ((a - t) / y); elseif (a <= -0.245) tmp = x; elseif (a <= -1.4e-129) tmp = t_2; elseif (a <= -4.8e-210) tmp = t_1; elseif (a <= 2.8e-235) tmp = t_2; elseif (a <= 2.9e-181) tmp = x / (t / (z - a)); elseif (a <= 2.8e-122) tmp = t_2; elseif (a <= 2.2e-53) tmp = t_1; elseif (a <= 4.5e-9) tmp = x; elseif (a <= 1.8e+127) tmp = z / (a / (y - x)); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x * N[((-z) / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[((-y) / N[(t / N[(z - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -4.5e+91], x, If[LessEqual[a, -5.2e+35], N[((-t) / N[(N[(a - t), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -0.245], x, If[LessEqual[a, -1.4e-129], t$95$2, If[LessEqual[a, -4.8e-210], t$95$1, If[LessEqual[a, 2.8e-235], t$95$2, If[LessEqual[a, 2.9e-181], N[(x / N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.8e-122], t$95$2, If[LessEqual[a, 2.2e-53], t$95$1, If[LessEqual[a, 4.5e-9], x, If[LessEqual[a, 1.8e+127], N[(z / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{-z}{a - t}\\
t_2 := \frac{-y}{\frac{t}{z - t}}\\
\mathbf{if}\;a \leq -4.5 \cdot 10^{+91}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -5.2 \cdot 10^{+35}:\\
\;\;\;\;\frac{-t}{\frac{a - t}{y}}\\
\mathbf{elif}\;a \leq -0.245:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -1.4 \cdot 10^{-129}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq -4.8 \cdot 10^{-210}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 2.8 \cdot 10^{-235}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq 2.9 \cdot 10^{-181}:\\
\;\;\;\;\frac{x}{\frac{t}{z - a}}\\
\mathbf{elif}\;a \leq 2.8 \cdot 10^{-122}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq 2.2 \cdot 10^{-53}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 4.5 \cdot 10^{-9}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 1.8 \cdot 10^{+127}:\\
\;\;\;\;\frac{z}{\frac{a}{y - x}}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -4.5e91 or -5.20000000000000013e35 < a < -0.245 or 2.20000000000000018e-53 < a < 4.49999999999999976e-9 or 1.79999999999999989e127 < a Initial program 72.3%
associate-*l/91.1%
Simplified91.1%
Taylor expanded in a around inf 54.8%
if -4.5e91 < a < -5.20000000000000013e35Initial program 74.2%
associate-*l/91.1%
Simplified91.1%
Taylor expanded in x around 0 47.8%
Taylor expanded in z around 0 39.2%
mul-1-neg39.2%
associate-/l*56.6%
distribute-neg-frac56.6%
Simplified56.6%
if -0.245 < a < -1.4e-129 or -4.80000000000000008e-210 < a < 2.79999999999999995e-235 or 2.8999999999999998e-181 < a < 2.7999999999999999e-122Initial program 72.0%
associate-*l/75.2%
Simplified75.2%
Taylor expanded in x around 0 65.3%
Taylor expanded in a around 0 54.0%
mul-1-neg54.0%
associate-/l*66.5%
distribute-neg-frac66.5%
Simplified66.5%
if -1.4e-129 < a < -4.80000000000000008e-210 or 2.7999999999999999e-122 < a < 2.20000000000000018e-53Initial program 64.8%
associate-*l/77.1%
Simplified77.1%
Taylor expanded in x around -inf 77.1%
mul-1-neg77.1%
*-commutative77.1%
distribute-rgt-neg-in77.1%
associate--r+64.2%
sub-neg64.2%
metadata-eval64.2%
Simplified64.2%
Taylor expanded in z around inf 68.8%
if 2.79999999999999995e-235 < a < 2.8999999999999998e-181Initial program 47.4%
associate-*l/47.8%
Simplified47.8%
Taylor expanded in x around -inf 70.5%
mul-1-neg70.5%
*-commutative70.5%
distribute-rgt-neg-in70.5%
associate--r+40.0%
sub-neg40.0%
metadata-eval40.0%
Simplified40.0%
Taylor expanded in t around -inf 70.2%
associate-/l*77.2%
Simplified77.2%
if 4.49999999999999976e-9 < a < 1.79999999999999989e127Initial program 72.7%
+-commutative72.7%
associate-*l/85.4%
fma-def85.8%
Simplified85.8%
fma-udef85.4%
associate-/r/85.4%
div-inv85.4%
clear-num85.5%
Applied egg-rr85.5%
clear-num85.4%
un-div-inv85.4%
Applied egg-rr85.4%
Taylor expanded in z around -inf 49.1%
associate-/l*58.1%
Simplified58.1%
Taylor expanded in a around inf 48.4%
Final simplification60.7%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ x (/ t (- z a)))))
(if (<= t -5.8e+279)
t_1
(if (<= t -9.2e-54)
(* y (+ (/ a t) 1.0))
(if (<= t -2.4e-122)
x
(if (<= t -4.8e-287)
(/ z (/ a (- y x)))
(if (<= t 2.9e-94)
x
(if (<= t 1.48e-27)
(* x (/ (- z) (- a t)))
(if (<= t 8e+45)
(/ y (/ a (- z t)))
(if (<= t 1.2e+192)
t_1
(if (<= t 5.5e+195) (/ (- t) (/ a y)) y)))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x / (t / (z - a));
double tmp;
if (t <= -5.8e+279) {
tmp = t_1;
} else if (t <= -9.2e-54) {
tmp = y * ((a / t) + 1.0);
} else if (t <= -2.4e-122) {
tmp = x;
} else if (t <= -4.8e-287) {
tmp = z / (a / (y - x));
} else if (t <= 2.9e-94) {
tmp = x;
} else if (t <= 1.48e-27) {
tmp = x * (-z / (a - t));
} else if (t <= 8e+45) {
tmp = y / (a / (z - t));
} else if (t <= 1.2e+192) {
tmp = t_1;
} else if (t <= 5.5e+195) {
tmp = -t / (a / y);
} else {
tmp = y;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x / (t / (z - a))
if (t <= (-5.8d+279)) then
tmp = t_1
else if (t <= (-9.2d-54)) then
tmp = y * ((a / t) + 1.0d0)
else if (t <= (-2.4d-122)) then
tmp = x
else if (t <= (-4.8d-287)) then
tmp = z / (a / (y - x))
else if (t <= 2.9d-94) then
tmp = x
else if (t <= 1.48d-27) then
tmp = x * (-z / (a - t))
else if (t <= 8d+45) then
tmp = y / (a / (z - t))
else if (t <= 1.2d+192) then
tmp = t_1
else if (t <= 5.5d+195) then
tmp = -t / (a / y)
else
tmp = y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x / (t / (z - a));
double tmp;
if (t <= -5.8e+279) {
tmp = t_1;
} else if (t <= -9.2e-54) {
tmp = y * ((a / t) + 1.0);
} else if (t <= -2.4e-122) {
tmp = x;
} else if (t <= -4.8e-287) {
tmp = z / (a / (y - x));
} else if (t <= 2.9e-94) {
tmp = x;
} else if (t <= 1.48e-27) {
tmp = x * (-z / (a - t));
} else if (t <= 8e+45) {
tmp = y / (a / (z - t));
} else if (t <= 1.2e+192) {
tmp = t_1;
} else if (t <= 5.5e+195) {
tmp = -t / (a / y);
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x / (t / (z - a)) tmp = 0 if t <= -5.8e+279: tmp = t_1 elif t <= -9.2e-54: tmp = y * ((a / t) + 1.0) elif t <= -2.4e-122: tmp = x elif t <= -4.8e-287: tmp = z / (a / (y - x)) elif t <= 2.9e-94: tmp = x elif t <= 1.48e-27: tmp = x * (-z / (a - t)) elif t <= 8e+45: tmp = y / (a / (z - t)) elif t <= 1.2e+192: tmp = t_1 elif t <= 5.5e+195: tmp = -t / (a / y) else: tmp = y return tmp
function code(x, y, z, t, a) t_1 = Float64(x / Float64(t / Float64(z - a))) tmp = 0.0 if (t <= -5.8e+279) tmp = t_1; elseif (t <= -9.2e-54) tmp = Float64(y * Float64(Float64(a / t) + 1.0)); elseif (t <= -2.4e-122) tmp = x; elseif (t <= -4.8e-287) tmp = Float64(z / Float64(a / Float64(y - x))); elseif (t <= 2.9e-94) tmp = x; elseif (t <= 1.48e-27) tmp = Float64(x * Float64(Float64(-z) / Float64(a - t))); elseif (t <= 8e+45) tmp = Float64(y / Float64(a / Float64(z - t))); elseif (t <= 1.2e+192) tmp = t_1; elseif (t <= 5.5e+195) tmp = Float64(Float64(-t) / Float64(a / y)); else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x / (t / (z - a)); tmp = 0.0; if (t <= -5.8e+279) tmp = t_1; elseif (t <= -9.2e-54) tmp = y * ((a / t) + 1.0); elseif (t <= -2.4e-122) tmp = x; elseif (t <= -4.8e-287) tmp = z / (a / (y - x)); elseif (t <= 2.9e-94) tmp = x; elseif (t <= 1.48e-27) tmp = x * (-z / (a - t)); elseif (t <= 8e+45) tmp = y / (a / (z - t)); elseif (t <= 1.2e+192) tmp = t_1; elseif (t <= 5.5e+195) tmp = -t / (a / y); else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x / N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -5.8e+279], t$95$1, If[LessEqual[t, -9.2e-54], N[(y * N[(N[(a / t), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -2.4e-122], x, If[LessEqual[t, -4.8e-287], N[(z / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.9e-94], x, If[LessEqual[t, 1.48e-27], N[(x * N[((-z) / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8e+45], N[(y / N[(a / N[(z - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.2e+192], t$95$1, If[LessEqual[t, 5.5e+195], N[((-t) / N[(a / y), $MachinePrecision]), $MachinePrecision], y]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{\frac{t}{z - a}}\\
\mathbf{if}\;t \leq -5.8 \cdot 10^{+279}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -9.2 \cdot 10^{-54}:\\
\;\;\;\;y \cdot \left(\frac{a}{t} + 1\right)\\
\mathbf{elif}\;t \leq -2.4 \cdot 10^{-122}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq -4.8 \cdot 10^{-287}:\\
\;\;\;\;\frac{z}{\frac{a}{y - x}}\\
\mathbf{elif}\;t \leq 2.9 \cdot 10^{-94}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 1.48 \cdot 10^{-27}:\\
\;\;\;\;x \cdot \frac{-z}{a - t}\\
\mathbf{elif}\;t \leq 8 \cdot 10^{+45}:\\
\;\;\;\;\frac{y}{\frac{a}{z - t}}\\
\mathbf{elif}\;t \leq 1.2 \cdot 10^{+192}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 5.5 \cdot 10^{+195}:\\
\;\;\;\;\frac{-t}{\frac{a}{y}}\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -5.7999999999999995e279 or 7.9999999999999994e45 < t < 1.1999999999999999e192Initial program 39.2%
associate-*l/45.6%
Simplified45.6%
Taylor expanded in x around -inf 49.9%
mul-1-neg49.9%
*-commutative49.9%
distribute-rgt-neg-in49.9%
associate--r+21.4%
sub-neg21.4%
metadata-eval21.4%
Simplified21.4%
Taylor expanded in t around -inf 34.6%
associate-/l*54.2%
Simplified54.2%
if -5.7999999999999995e279 < t < -9.1999999999999996e-54Initial program 59.6%
associate-*l/76.3%
Simplified76.3%
Taylor expanded in t around inf 69.2%
associate--l+69.2%
associate-*r/69.2%
associate-*r/69.2%
div-sub69.3%
distribute-lft-out--69.3%
associate-*r/69.3%
mul-1-neg69.3%
unsub-neg69.3%
distribute-rgt-out--69.4%
associate-/l*76.9%
Simplified76.9%
Taylor expanded in z around 0 45.5%
associate-*r/45.5%
neg-mul-145.5%
Simplified45.5%
Taylor expanded in y around inf 39.8%
sub-neg39.8%
mul-1-neg39.8%
remove-double-neg39.8%
Simplified39.8%
if -9.1999999999999996e-54 < t < -2.39999999999999987e-122 or -4.79999999999999999e-287 < t < 2.89999999999999995e-94Initial program 89.8%
associate-*l/95.7%
Simplified95.7%
Taylor expanded in a around inf 53.0%
if -2.39999999999999987e-122 < t < -4.79999999999999999e-287Initial program 92.6%
+-commutative92.6%
associate-*l/94.8%
fma-def94.9%
Simplified94.9%
fma-udef94.8%
associate-/r/92.4%
div-inv92.4%
clear-num92.5%
Applied egg-rr92.5%
clear-num92.4%
un-div-inv92.4%
Applied egg-rr92.4%
Taylor expanded in z around -inf 65.4%
associate-/l*67.8%
Simplified67.8%
Taylor expanded in a around inf 52.6%
if 2.89999999999999995e-94 < t < 1.48000000000000008e-27Initial program 79.5%
associate-*l/79.4%
Simplified79.4%
Taylor expanded in x around -inf 69.2%
mul-1-neg69.2%
*-commutative69.2%
distribute-rgt-neg-in69.2%
associate--r+58.7%
sub-neg58.7%
metadata-eval58.7%
Simplified58.7%
Taylor expanded in z around inf 58.9%
if 1.48000000000000008e-27 < t < 7.9999999999999994e45Initial program 94.0%
associate-*l/100.0%
Simplified100.0%
Taylor expanded in x around 0 57.1%
Taylor expanded in a around inf 51.6%
associate-/l*51.7%
Simplified51.7%
if 1.1999999999999999e192 < t < 5.49999999999999994e195Initial program 4.9%
associate-*l/99.2%
Simplified99.2%
Taylor expanded in x around 0 4.9%
Taylor expanded in z around 0 4.9%
associate-*r/4.9%
mul-1-neg4.9%
distribute-lft-neg-out4.9%
*-commutative4.9%
Simplified4.9%
Taylor expanded in t around 0 4.9%
mul-1-neg4.9%
associate-/l*99.2%
distribute-neg-frac99.2%
Simplified99.2%
if 5.49999999999999994e195 < t Initial program 23.1%
associate-*l/66.2%
Simplified66.2%
Taylor expanded in t around inf 76.0%
Final simplification52.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- t) (/ (- a t) y))) (t_2 (/ x (/ t (- z a)))))
(if (<= t -5e+279)
t_2
(if (<= t -3.8e-58)
t_1
(if (<= t -2.7e-122)
x
(if (<= t -4.1e-285)
(/ z (/ a (- y x)))
(if (<= t 6e-93)
x
(if (<= t 1.5e-27)
(* x (/ (- z) (- a t)))
(if (<= t 3.5e+46)
(/ y (/ a (- z t)))
(if (<= t 1.7e+190) t_2 t_1))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = -t / ((a - t) / y);
double t_2 = x / (t / (z - a));
double tmp;
if (t <= -5e+279) {
tmp = t_2;
} else if (t <= -3.8e-58) {
tmp = t_1;
} else if (t <= -2.7e-122) {
tmp = x;
} else if (t <= -4.1e-285) {
tmp = z / (a / (y - x));
} else if (t <= 6e-93) {
tmp = x;
} else if (t <= 1.5e-27) {
tmp = x * (-z / (a - t));
} else if (t <= 3.5e+46) {
tmp = y / (a / (z - t));
} else if (t <= 1.7e+190) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = -t / ((a - t) / y)
t_2 = x / (t / (z - a))
if (t <= (-5d+279)) then
tmp = t_2
else if (t <= (-3.8d-58)) then
tmp = t_1
else if (t <= (-2.7d-122)) then
tmp = x
else if (t <= (-4.1d-285)) then
tmp = z / (a / (y - x))
else if (t <= 6d-93) then
tmp = x
else if (t <= 1.5d-27) then
tmp = x * (-z / (a - t))
else if (t <= 3.5d+46) then
tmp = y / (a / (z - t))
else if (t <= 1.7d+190) then
tmp = t_2
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = -t / ((a - t) / y);
double t_2 = x / (t / (z - a));
double tmp;
if (t <= -5e+279) {
tmp = t_2;
} else if (t <= -3.8e-58) {
tmp = t_1;
} else if (t <= -2.7e-122) {
tmp = x;
} else if (t <= -4.1e-285) {
tmp = z / (a / (y - x));
} else if (t <= 6e-93) {
tmp = x;
} else if (t <= 1.5e-27) {
tmp = x * (-z / (a - t));
} else if (t <= 3.5e+46) {
tmp = y / (a / (z - t));
} else if (t <= 1.7e+190) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = -t / ((a - t) / y) t_2 = x / (t / (z - a)) tmp = 0 if t <= -5e+279: tmp = t_2 elif t <= -3.8e-58: tmp = t_1 elif t <= -2.7e-122: tmp = x elif t <= -4.1e-285: tmp = z / (a / (y - x)) elif t <= 6e-93: tmp = x elif t <= 1.5e-27: tmp = x * (-z / (a - t)) elif t <= 3.5e+46: tmp = y / (a / (z - t)) elif t <= 1.7e+190: tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(-t) / Float64(Float64(a - t) / y)) t_2 = Float64(x / Float64(t / Float64(z - a))) tmp = 0.0 if (t <= -5e+279) tmp = t_2; elseif (t <= -3.8e-58) tmp = t_1; elseif (t <= -2.7e-122) tmp = x; elseif (t <= -4.1e-285) tmp = Float64(z / Float64(a / Float64(y - x))); elseif (t <= 6e-93) tmp = x; elseif (t <= 1.5e-27) tmp = Float64(x * Float64(Float64(-z) / Float64(a - t))); elseif (t <= 3.5e+46) tmp = Float64(y / Float64(a / Float64(z - t))); elseif (t <= 1.7e+190) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = -t / ((a - t) / y); t_2 = x / (t / (z - a)); tmp = 0.0; if (t <= -5e+279) tmp = t_2; elseif (t <= -3.8e-58) tmp = t_1; elseif (t <= -2.7e-122) tmp = x; elseif (t <= -4.1e-285) tmp = z / (a / (y - x)); elseif (t <= 6e-93) tmp = x; elseif (t <= 1.5e-27) tmp = x * (-z / (a - t)); elseif (t <= 3.5e+46) tmp = y / (a / (z - t)); elseif (t <= 1.7e+190) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[((-t) / N[(N[(a - t), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x / N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -5e+279], t$95$2, If[LessEqual[t, -3.8e-58], t$95$1, If[LessEqual[t, -2.7e-122], x, If[LessEqual[t, -4.1e-285], N[(z / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 6e-93], x, If[LessEqual[t, 1.5e-27], N[(x * N[((-z) / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.5e+46], N[(y / N[(a / N[(z - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.7e+190], t$95$2, t$95$1]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{-t}{\frac{a - t}{y}}\\
t_2 := \frac{x}{\frac{t}{z - a}}\\
\mathbf{if}\;t \leq -5 \cdot 10^{+279}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -3.8 \cdot 10^{-58}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -2.7 \cdot 10^{-122}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq -4.1 \cdot 10^{-285}:\\
\;\;\;\;\frac{z}{\frac{a}{y - x}}\\
\mathbf{elif}\;t \leq 6 \cdot 10^{-93}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 1.5 \cdot 10^{-27}:\\
\;\;\;\;x \cdot \frac{-z}{a - t}\\
\mathbf{elif}\;t \leq 3.5 \cdot 10^{+46}:\\
\;\;\;\;\frac{y}{\frac{a}{z - t}}\\
\mathbf{elif}\;t \leq 1.7 \cdot 10^{+190}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -5.0000000000000002e279 or 3.49999999999999985e46 < t < 1.7e190Initial program 39.2%
associate-*l/45.6%
Simplified45.6%
Taylor expanded in x around -inf 49.9%
mul-1-neg49.9%
*-commutative49.9%
distribute-rgt-neg-in49.9%
associate--r+21.4%
sub-neg21.4%
metadata-eval21.4%
Simplified21.4%
Taylor expanded in t around -inf 34.6%
associate-/l*54.2%
Simplified54.2%
if -5.0000000000000002e279 < t < -3.7999999999999997e-58 or 1.7e190 < t Initial program 50.2%
associate-*l/74.8%
Simplified74.8%
Taylor expanded in x around 0 45.5%
Taylor expanded in z around 0 36.3%
mul-1-neg36.3%
associate-/l*51.1%
distribute-neg-frac51.1%
Simplified51.1%
if -3.7999999999999997e-58 < t < -2.70000000000000009e-122 or -4.1e-285 < t < 6.0000000000000003e-93Initial program 89.6%
associate-*l/95.6%
Simplified95.6%
Taylor expanded in a around inf 53.8%
if -2.70000000000000009e-122 < t < -4.1e-285Initial program 92.6%
+-commutative92.6%
associate-*l/94.8%
fma-def94.9%
Simplified94.9%
fma-udef94.8%
associate-/r/92.4%
div-inv92.4%
clear-num92.5%
Applied egg-rr92.5%
clear-num92.4%
un-div-inv92.4%
Applied egg-rr92.4%
Taylor expanded in z around -inf 65.4%
associate-/l*67.8%
Simplified67.8%
Taylor expanded in a around inf 52.6%
if 6.0000000000000003e-93 < t < 1.5000000000000001e-27Initial program 79.5%
associate-*l/79.4%
Simplified79.4%
Taylor expanded in x around -inf 69.2%
mul-1-neg69.2%
*-commutative69.2%
distribute-rgt-neg-in69.2%
associate--r+58.7%
sub-neg58.7%
metadata-eval58.7%
Simplified58.7%
Taylor expanded in z around inf 58.9%
if 1.5000000000000001e-27 < t < 3.49999999999999985e46Initial program 94.0%
associate-*l/100.0%
Simplified100.0%
Taylor expanded in x around 0 57.1%
Taylor expanded in a around inf 51.6%
associate-/l*51.7%
Simplified51.7%
Final simplification53.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ x (/ t (- z a)))))
(if (<= t -5.8e+279)
t_1
(if (<= t -1.1e-53)
(* y (+ (/ a t) 1.0))
(if (<= t -1.4e-122)
x
(if (<= t -3e-285)
(/ z (/ a (- y x)))
(if (<= t 2.05e-91)
x
(if (<= t 5e-26)
(* x (/ z t))
(if (<= t 9.2e+45)
(/ y (/ a (- z t)))
(if (<= t 1.5e+195) t_1 y))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x / (t / (z - a));
double tmp;
if (t <= -5.8e+279) {
tmp = t_1;
} else if (t <= -1.1e-53) {
tmp = y * ((a / t) + 1.0);
} else if (t <= -1.4e-122) {
tmp = x;
} else if (t <= -3e-285) {
tmp = z / (a / (y - x));
} else if (t <= 2.05e-91) {
tmp = x;
} else if (t <= 5e-26) {
tmp = x * (z / t);
} else if (t <= 9.2e+45) {
tmp = y / (a / (z - t));
} else if (t <= 1.5e+195) {
tmp = t_1;
} else {
tmp = y;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x / (t / (z - a))
if (t <= (-5.8d+279)) then
tmp = t_1
else if (t <= (-1.1d-53)) then
tmp = y * ((a / t) + 1.0d0)
else if (t <= (-1.4d-122)) then
tmp = x
else if (t <= (-3d-285)) then
tmp = z / (a / (y - x))
else if (t <= 2.05d-91) then
tmp = x
else if (t <= 5d-26) then
tmp = x * (z / t)
else if (t <= 9.2d+45) then
tmp = y / (a / (z - t))
else if (t <= 1.5d+195) then
tmp = t_1
else
tmp = y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x / (t / (z - a));
double tmp;
if (t <= -5.8e+279) {
tmp = t_1;
} else if (t <= -1.1e-53) {
tmp = y * ((a / t) + 1.0);
} else if (t <= -1.4e-122) {
tmp = x;
} else if (t <= -3e-285) {
tmp = z / (a / (y - x));
} else if (t <= 2.05e-91) {
tmp = x;
} else if (t <= 5e-26) {
tmp = x * (z / t);
} else if (t <= 9.2e+45) {
tmp = y / (a / (z - t));
} else if (t <= 1.5e+195) {
tmp = t_1;
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x / (t / (z - a)) tmp = 0 if t <= -5.8e+279: tmp = t_1 elif t <= -1.1e-53: tmp = y * ((a / t) + 1.0) elif t <= -1.4e-122: tmp = x elif t <= -3e-285: tmp = z / (a / (y - x)) elif t <= 2.05e-91: tmp = x elif t <= 5e-26: tmp = x * (z / t) elif t <= 9.2e+45: tmp = y / (a / (z - t)) elif t <= 1.5e+195: tmp = t_1 else: tmp = y return tmp
function code(x, y, z, t, a) t_1 = Float64(x / Float64(t / Float64(z - a))) tmp = 0.0 if (t <= -5.8e+279) tmp = t_1; elseif (t <= -1.1e-53) tmp = Float64(y * Float64(Float64(a / t) + 1.0)); elseif (t <= -1.4e-122) tmp = x; elseif (t <= -3e-285) tmp = Float64(z / Float64(a / Float64(y - x))); elseif (t <= 2.05e-91) tmp = x; elseif (t <= 5e-26) tmp = Float64(x * Float64(z / t)); elseif (t <= 9.2e+45) tmp = Float64(y / Float64(a / Float64(z - t))); elseif (t <= 1.5e+195) tmp = t_1; else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x / (t / (z - a)); tmp = 0.0; if (t <= -5.8e+279) tmp = t_1; elseif (t <= -1.1e-53) tmp = y * ((a / t) + 1.0); elseif (t <= -1.4e-122) tmp = x; elseif (t <= -3e-285) tmp = z / (a / (y - x)); elseif (t <= 2.05e-91) tmp = x; elseif (t <= 5e-26) tmp = x * (z / t); elseif (t <= 9.2e+45) tmp = y / (a / (z - t)); elseif (t <= 1.5e+195) tmp = t_1; else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x / N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -5.8e+279], t$95$1, If[LessEqual[t, -1.1e-53], N[(y * N[(N[(a / t), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.4e-122], x, If[LessEqual[t, -3e-285], N[(z / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.05e-91], x, If[LessEqual[t, 5e-26], N[(x * N[(z / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 9.2e+45], N[(y / N[(a / N[(z - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.5e+195], t$95$1, y]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{\frac{t}{z - a}}\\
\mathbf{if}\;t \leq -5.8 \cdot 10^{+279}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -1.1 \cdot 10^{-53}:\\
\;\;\;\;y \cdot \left(\frac{a}{t} + 1\right)\\
\mathbf{elif}\;t \leq -1.4 \cdot 10^{-122}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq -3 \cdot 10^{-285}:\\
\;\;\;\;\frac{z}{\frac{a}{y - x}}\\
\mathbf{elif}\;t \leq 2.05 \cdot 10^{-91}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 5 \cdot 10^{-26}:\\
\;\;\;\;x \cdot \frac{z}{t}\\
\mathbf{elif}\;t \leq 9.2 \cdot 10^{+45}:\\
\;\;\;\;\frac{y}{\frac{a}{z - t}}\\
\mathbf{elif}\;t \leq 1.5 \cdot 10^{+195}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -5.7999999999999995e279 or 9.20000000000000049e45 < t < 1.5e195Initial program 38.2%
associate-*l/47.2%
Simplified47.2%
Taylor expanded in x around -inf 48.6%
mul-1-neg48.6%
*-commutative48.6%
distribute-rgt-neg-in48.6%
associate--r+21.0%
sub-neg21.0%
metadata-eval21.0%
Simplified21.0%
Taylor expanded in t around -inf 33.5%
associate-/l*52.5%
Simplified52.5%
if -5.7999999999999995e279 < t < -1.10000000000000009e-53Initial program 59.6%
associate-*l/76.3%
Simplified76.3%
Taylor expanded in t around inf 69.2%
associate--l+69.2%
associate-*r/69.2%
associate-*r/69.2%
div-sub69.3%
distribute-lft-out--69.3%
associate-*r/69.3%
mul-1-neg69.3%
unsub-neg69.3%
distribute-rgt-out--69.4%
associate-/l*76.9%
Simplified76.9%
Taylor expanded in z around 0 45.5%
associate-*r/45.5%
neg-mul-145.5%
Simplified45.5%
Taylor expanded in y around inf 39.8%
sub-neg39.8%
mul-1-neg39.8%
remove-double-neg39.8%
Simplified39.8%
if -1.10000000000000009e-53 < t < -1.3999999999999999e-122 or -3.00000000000000003e-285 < t < 2.05000000000000012e-91Initial program 89.8%
associate-*l/95.7%
Simplified95.7%
Taylor expanded in a around inf 53.0%
if -1.3999999999999999e-122 < t < -3.00000000000000003e-285Initial program 92.6%
+-commutative92.6%
associate-*l/94.8%
fma-def94.9%
Simplified94.9%
fma-udef94.8%
associate-/r/92.4%
div-inv92.4%
clear-num92.5%
Applied egg-rr92.5%
clear-num92.4%
un-div-inv92.4%
Applied egg-rr92.4%
Taylor expanded in z around -inf 65.4%
associate-/l*67.8%
Simplified67.8%
Taylor expanded in a around inf 52.6%
if 2.05000000000000012e-91 < t < 5.00000000000000019e-26Initial program 80.5%
associate-*l/80.5%
Simplified80.5%
Taylor expanded in x around -inf 70.7%
mul-1-neg70.7%
*-commutative70.7%
distribute-rgt-neg-in70.7%
associate--r+60.8%
sub-neg60.8%
metadata-eval60.8%
Simplified60.8%
Taylor expanded in a around 0 51.3%
associate-*r/51.3%
mul-1-neg51.3%
Simplified51.3%
if 5.00000000000000019e-26 < t < 9.20000000000000049e45Initial program 93.6%
associate-*l/100.0%
Simplified100.0%
Taylor expanded in x around 0 60.5%
Taylor expanded in a around inf 54.7%
associate-/l*54.7%
Simplified54.7%
if 1.5e195 < t Initial program 22.2%
associate-*l/67.8%
Simplified67.8%
Taylor expanded in t around inf 72.7%
Final simplification51.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* x (/ z t))) (t_2 (/ y (/ a z))))
(if (<= t -5.8e+279)
t_1
(if (<= t -8.8e-57)
(* y (+ (/ a t) 1.0))
(if (<= t -2.25e-237)
x
(if (<= t -1.8e-279)
t_2
(if (<= t 1.05e-91)
x
(if (<= t 7.5e-28)
t_1
(if (<= t 2.3e+134) t_2 (if (<= t 5.2e+192) t_1 y))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x * (z / t);
double t_2 = y / (a / z);
double tmp;
if (t <= -5.8e+279) {
tmp = t_1;
} else if (t <= -8.8e-57) {
tmp = y * ((a / t) + 1.0);
} else if (t <= -2.25e-237) {
tmp = x;
} else if (t <= -1.8e-279) {
tmp = t_2;
} else if (t <= 1.05e-91) {
tmp = x;
} else if (t <= 7.5e-28) {
tmp = t_1;
} else if (t <= 2.3e+134) {
tmp = t_2;
} else if (t <= 5.2e+192) {
tmp = t_1;
} else {
tmp = y;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x * (z / t)
t_2 = y / (a / z)
if (t <= (-5.8d+279)) then
tmp = t_1
else if (t <= (-8.8d-57)) then
tmp = y * ((a / t) + 1.0d0)
else if (t <= (-2.25d-237)) then
tmp = x
else if (t <= (-1.8d-279)) then
tmp = t_2
else if (t <= 1.05d-91) then
tmp = x
else if (t <= 7.5d-28) then
tmp = t_1
else if (t <= 2.3d+134) then
tmp = t_2
else if (t <= 5.2d+192) then
tmp = t_1
else
tmp = y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x * (z / t);
double t_2 = y / (a / z);
double tmp;
if (t <= -5.8e+279) {
tmp = t_1;
} else if (t <= -8.8e-57) {
tmp = y * ((a / t) + 1.0);
} else if (t <= -2.25e-237) {
tmp = x;
} else if (t <= -1.8e-279) {
tmp = t_2;
} else if (t <= 1.05e-91) {
tmp = x;
} else if (t <= 7.5e-28) {
tmp = t_1;
} else if (t <= 2.3e+134) {
tmp = t_2;
} else if (t <= 5.2e+192) {
tmp = t_1;
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x * (z / t) t_2 = y / (a / z) tmp = 0 if t <= -5.8e+279: tmp = t_1 elif t <= -8.8e-57: tmp = y * ((a / t) + 1.0) elif t <= -2.25e-237: tmp = x elif t <= -1.8e-279: tmp = t_2 elif t <= 1.05e-91: tmp = x elif t <= 7.5e-28: tmp = t_1 elif t <= 2.3e+134: tmp = t_2 elif t <= 5.2e+192: tmp = t_1 else: tmp = y return tmp
function code(x, y, z, t, a) t_1 = Float64(x * Float64(z / t)) t_2 = Float64(y / Float64(a / z)) tmp = 0.0 if (t <= -5.8e+279) tmp = t_1; elseif (t <= -8.8e-57) tmp = Float64(y * Float64(Float64(a / t) + 1.0)); elseif (t <= -2.25e-237) tmp = x; elseif (t <= -1.8e-279) tmp = t_2; elseif (t <= 1.05e-91) tmp = x; elseif (t <= 7.5e-28) tmp = t_1; elseif (t <= 2.3e+134) tmp = t_2; elseif (t <= 5.2e+192) tmp = t_1; else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x * (z / t); t_2 = y / (a / z); tmp = 0.0; if (t <= -5.8e+279) tmp = t_1; elseif (t <= -8.8e-57) tmp = y * ((a / t) + 1.0); elseif (t <= -2.25e-237) tmp = x; elseif (t <= -1.8e-279) tmp = t_2; elseif (t <= 1.05e-91) tmp = x; elseif (t <= 7.5e-28) tmp = t_1; elseif (t <= 2.3e+134) tmp = t_2; elseif (t <= 5.2e+192) tmp = t_1; else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x * N[(z / t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y / N[(a / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -5.8e+279], t$95$1, If[LessEqual[t, -8.8e-57], N[(y * N[(N[(a / t), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -2.25e-237], x, If[LessEqual[t, -1.8e-279], t$95$2, If[LessEqual[t, 1.05e-91], x, If[LessEqual[t, 7.5e-28], t$95$1, If[LessEqual[t, 2.3e+134], t$95$2, If[LessEqual[t, 5.2e+192], t$95$1, y]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{z}{t}\\
t_2 := \frac{y}{\frac{a}{z}}\\
\mathbf{if}\;t \leq -5.8 \cdot 10^{+279}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -8.8 \cdot 10^{-57}:\\
\;\;\;\;y \cdot \left(\frac{a}{t} + 1\right)\\
\mathbf{elif}\;t \leq -2.25 \cdot 10^{-237}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq -1.8 \cdot 10^{-279}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 1.05 \cdot 10^{-91}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 7.5 \cdot 10^{-28}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 2.3 \cdot 10^{+134}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 5.2 \cdot 10^{+192}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -5.7999999999999995e279 or 1.05e-91 < t < 7.5000000000000003e-28 or 2.2999999999999998e134 < t < 5.20000000000000006e192Initial program 52.7%
associate-*l/58.4%
Simplified58.4%
Taylor expanded in x around -inf 67.7%
mul-1-neg67.7%
*-commutative67.7%
distribute-rgt-neg-in67.7%
associate--r+38.8%
sub-neg38.8%
metadata-eval38.8%
Simplified38.8%
Taylor expanded in a around 0 58.1%
associate-*r/58.1%
mul-1-neg58.1%
Simplified58.1%
if -5.7999999999999995e279 < t < -8.79999999999999994e-57Initial program 59.6%
associate-*l/76.3%
Simplified76.3%
Taylor expanded in t around inf 69.2%
associate--l+69.2%
associate-*r/69.2%
associate-*r/69.2%
div-sub69.3%
distribute-lft-out--69.3%
associate-*r/69.3%
mul-1-neg69.3%
unsub-neg69.3%
distribute-rgt-out--69.4%
associate-/l*76.9%
Simplified76.9%
Taylor expanded in z around 0 45.5%
associate-*r/45.5%
neg-mul-145.5%
Simplified45.5%
Taylor expanded in y around inf 39.8%
sub-neg39.8%
mul-1-neg39.8%
remove-double-neg39.8%
Simplified39.8%
if -8.79999999999999994e-57 < t < -2.25000000000000005e-237 or -1.7999999999999998e-279 < t < 1.05e-91Initial program 90.8%
associate-*l/95.9%
Simplified95.9%
Taylor expanded in a around inf 47.4%
if -2.25000000000000005e-237 < t < -1.7999999999999998e-279 or 7.5000000000000003e-28 < t < 2.2999999999999998e134Initial program 78.4%
associate-*l/82.7%
Simplified82.7%
Taylor expanded in x around 0 49.5%
Taylor expanded in t around 0 29.4%
associate-/l*35.6%
Simplified35.6%
if 5.20000000000000006e192 < t Initial program 22.2%
associate-*l/67.8%
Simplified67.8%
Taylor expanded in t around inf 72.7%
Final simplification47.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* x (/ z t))))
(if (<= t -5.8e+279)
t_1
(if (<= t -9.5e-56)
(* y (+ (/ a t) 1.0))
(if (<= t -6.4e-240)
x
(if (<= t -3.1e-283)
(/ 1.0 (/ (/ a z) y))
(if (<= t 3.9e-92)
x
(if (<= t 3.2e-28)
t_1
(if (<= t 2.5e+134)
(/ y (/ a z))
(if (<= t 5.2e+192) t_1 y))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x * (z / t);
double tmp;
if (t <= -5.8e+279) {
tmp = t_1;
} else if (t <= -9.5e-56) {
tmp = y * ((a / t) + 1.0);
} else if (t <= -6.4e-240) {
tmp = x;
} else if (t <= -3.1e-283) {
tmp = 1.0 / ((a / z) / y);
} else if (t <= 3.9e-92) {
tmp = x;
} else if (t <= 3.2e-28) {
tmp = t_1;
} else if (t <= 2.5e+134) {
tmp = y / (a / z);
} else if (t <= 5.2e+192) {
tmp = t_1;
} else {
tmp = y;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x * (z / t)
if (t <= (-5.8d+279)) then
tmp = t_1
else if (t <= (-9.5d-56)) then
tmp = y * ((a / t) + 1.0d0)
else if (t <= (-6.4d-240)) then
tmp = x
else if (t <= (-3.1d-283)) then
tmp = 1.0d0 / ((a / z) / y)
else if (t <= 3.9d-92) then
tmp = x
else if (t <= 3.2d-28) then
tmp = t_1
else if (t <= 2.5d+134) then
tmp = y / (a / z)
else if (t <= 5.2d+192) then
tmp = t_1
else
tmp = y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x * (z / t);
double tmp;
if (t <= -5.8e+279) {
tmp = t_1;
} else if (t <= -9.5e-56) {
tmp = y * ((a / t) + 1.0);
} else if (t <= -6.4e-240) {
tmp = x;
} else if (t <= -3.1e-283) {
tmp = 1.0 / ((a / z) / y);
} else if (t <= 3.9e-92) {
tmp = x;
} else if (t <= 3.2e-28) {
tmp = t_1;
} else if (t <= 2.5e+134) {
tmp = y / (a / z);
} else if (t <= 5.2e+192) {
tmp = t_1;
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x * (z / t) tmp = 0 if t <= -5.8e+279: tmp = t_1 elif t <= -9.5e-56: tmp = y * ((a / t) + 1.0) elif t <= -6.4e-240: tmp = x elif t <= -3.1e-283: tmp = 1.0 / ((a / z) / y) elif t <= 3.9e-92: tmp = x elif t <= 3.2e-28: tmp = t_1 elif t <= 2.5e+134: tmp = y / (a / z) elif t <= 5.2e+192: tmp = t_1 else: tmp = y return tmp
function code(x, y, z, t, a) t_1 = Float64(x * Float64(z / t)) tmp = 0.0 if (t <= -5.8e+279) tmp = t_1; elseif (t <= -9.5e-56) tmp = Float64(y * Float64(Float64(a / t) + 1.0)); elseif (t <= -6.4e-240) tmp = x; elseif (t <= -3.1e-283) tmp = Float64(1.0 / Float64(Float64(a / z) / y)); elseif (t <= 3.9e-92) tmp = x; elseif (t <= 3.2e-28) tmp = t_1; elseif (t <= 2.5e+134) tmp = Float64(y / Float64(a / z)); elseif (t <= 5.2e+192) tmp = t_1; else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x * (z / t); tmp = 0.0; if (t <= -5.8e+279) tmp = t_1; elseif (t <= -9.5e-56) tmp = y * ((a / t) + 1.0); elseif (t <= -6.4e-240) tmp = x; elseif (t <= -3.1e-283) tmp = 1.0 / ((a / z) / y); elseif (t <= 3.9e-92) tmp = x; elseif (t <= 3.2e-28) tmp = t_1; elseif (t <= 2.5e+134) tmp = y / (a / z); elseif (t <= 5.2e+192) tmp = t_1; else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x * N[(z / t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -5.8e+279], t$95$1, If[LessEqual[t, -9.5e-56], N[(y * N[(N[(a / t), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -6.4e-240], x, If[LessEqual[t, -3.1e-283], N[(1.0 / N[(N[(a / z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.9e-92], x, If[LessEqual[t, 3.2e-28], t$95$1, If[LessEqual[t, 2.5e+134], N[(y / N[(a / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.2e+192], t$95$1, y]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{z}{t}\\
\mathbf{if}\;t \leq -5.8 \cdot 10^{+279}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -9.5 \cdot 10^{-56}:\\
\;\;\;\;y \cdot \left(\frac{a}{t} + 1\right)\\
\mathbf{elif}\;t \leq -6.4 \cdot 10^{-240}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq -3.1 \cdot 10^{-283}:\\
\;\;\;\;\frac{1}{\frac{\frac{a}{z}}{y}}\\
\mathbf{elif}\;t \leq 3.9 \cdot 10^{-92}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 3.2 \cdot 10^{-28}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 2.5 \cdot 10^{+134}:\\
\;\;\;\;\frac{y}{\frac{a}{z}}\\
\mathbf{elif}\;t \leq 5.2 \cdot 10^{+192}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -5.7999999999999995e279 or 3.8999999999999997e-92 < t < 3.19999999999999982e-28 or 2.4999999999999999e134 < t < 5.20000000000000006e192Initial program 52.7%
associate-*l/58.4%
Simplified58.4%
Taylor expanded in x around -inf 67.7%
mul-1-neg67.7%
*-commutative67.7%
distribute-rgt-neg-in67.7%
associate--r+38.8%
sub-neg38.8%
metadata-eval38.8%
Simplified38.8%
Taylor expanded in a around 0 58.1%
associate-*r/58.1%
mul-1-neg58.1%
Simplified58.1%
if -5.7999999999999995e279 < t < -9.4999999999999991e-56Initial program 59.6%
associate-*l/76.3%
Simplified76.3%
Taylor expanded in t around inf 69.2%
associate--l+69.2%
associate-*r/69.2%
associate-*r/69.2%
div-sub69.3%
distribute-lft-out--69.3%
associate-*r/69.3%
mul-1-neg69.3%
unsub-neg69.3%
distribute-rgt-out--69.4%
associate-/l*76.9%
Simplified76.9%
Taylor expanded in z around 0 45.5%
associate-*r/45.5%
neg-mul-145.5%
Simplified45.5%
Taylor expanded in y around inf 39.8%
sub-neg39.8%
mul-1-neg39.8%
remove-double-neg39.8%
Simplified39.8%
if -9.4999999999999991e-56 < t < -6.3999999999999998e-240 or -3.10000000000000004e-283 < t < 3.8999999999999997e-92Initial program 90.8%
associate-*l/95.9%
Simplified95.9%
Taylor expanded in a around inf 47.4%
if -6.3999999999999998e-240 < t < -3.10000000000000004e-283Initial program 91.2%
associate-*l/91.0%
Simplified91.0%
Taylor expanded in x around 0 48.1%
Taylor expanded in t around 0 48.1%
associate-/l*56.5%
Simplified56.5%
clear-num56.6%
inv-pow56.6%
Applied egg-rr56.6%
unpow-156.6%
Simplified56.6%
if 3.19999999999999982e-28 < t < 2.4999999999999999e134Initial program 74.3%
associate-*l/80.1%
Simplified80.1%
Taylor expanded in x around 0 49.9%
Taylor expanded in t around 0 23.4%
associate-/l*28.9%
Simplified28.9%
if 5.20000000000000006e192 < t Initial program 22.2%
associate-*l/67.8%
Simplified67.8%
Taylor expanded in t around inf 72.7%
Final simplification47.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ y (/ (- x y) (/ t z)))) (t_2 (- x (/ (- x y) (/ a (- z t))))))
(if (<= a -3.2e+56)
t_2
(if (<= a -3.8e+35)
t_1
(if (<= a -6.8e-13)
(* x (+ (/ (- t z) (- a t)) 1.0))
(if (<= a -1.7e-127)
(* y (/ (- z t) (- a t)))
(if (<= a -4.2e-231)
(/ z (/ (- a t) (- y x)))
(if (<= a 2.7e-39) t_1 t_2))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y + ((x - y) / (t / z));
double t_2 = x - ((x - y) / (a / (z - t)));
double tmp;
if (a <= -3.2e+56) {
tmp = t_2;
} else if (a <= -3.8e+35) {
tmp = t_1;
} else if (a <= -6.8e-13) {
tmp = x * (((t - z) / (a - t)) + 1.0);
} else if (a <= -1.7e-127) {
tmp = y * ((z - t) / (a - t));
} else if (a <= -4.2e-231) {
tmp = z / ((a - t) / (y - x));
} else if (a <= 2.7e-39) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = y + ((x - y) / (t / z))
t_2 = x - ((x - y) / (a / (z - t)))
if (a <= (-3.2d+56)) then
tmp = t_2
else if (a <= (-3.8d+35)) then
tmp = t_1
else if (a <= (-6.8d-13)) then
tmp = x * (((t - z) / (a - t)) + 1.0d0)
else if (a <= (-1.7d-127)) then
tmp = y * ((z - t) / (a - t))
else if (a <= (-4.2d-231)) then
tmp = z / ((a - t) / (y - x))
else if (a <= 2.7d-39) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y + ((x - y) / (t / z));
double t_2 = x - ((x - y) / (a / (z - t)));
double tmp;
if (a <= -3.2e+56) {
tmp = t_2;
} else if (a <= -3.8e+35) {
tmp = t_1;
} else if (a <= -6.8e-13) {
tmp = x * (((t - z) / (a - t)) + 1.0);
} else if (a <= -1.7e-127) {
tmp = y * ((z - t) / (a - t));
} else if (a <= -4.2e-231) {
tmp = z / ((a - t) / (y - x));
} else if (a <= 2.7e-39) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y + ((x - y) / (t / z)) t_2 = x - ((x - y) / (a / (z - t))) tmp = 0 if a <= -3.2e+56: tmp = t_2 elif a <= -3.8e+35: tmp = t_1 elif a <= -6.8e-13: tmp = x * (((t - z) / (a - t)) + 1.0) elif a <= -1.7e-127: tmp = y * ((z - t) / (a - t)) elif a <= -4.2e-231: tmp = z / ((a - t) / (y - x)) elif a <= 2.7e-39: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(y + Float64(Float64(x - y) / Float64(t / z))) t_2 = Float64(x - Float64(Float64(x - y) / Float64(a / Float64(z - t)))) tmp = 0.0 if (a <= -3.2e+56) tmp = t_2; elseif (a <= -3.8e+35) tmp = t_1; elseif (a <= -6.8e-13) tmp = Float64(x * Float64(Float64(Float64(t - z) / Float64(a - t)) + 1.0)); elseif (a <= -1.7e-127) tmp = Float64(y * Float64(Float64(z - t) / Float64(a - t))); elseif (a <= -4.2e-231) tmp = Float64(z / Float64(Float64(a - t) / Float64(y - x))); elseif (a <= 2.7e-39) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y + ((x - y) / (t / z)); t_2 = x - ((x - y) / (a / (z - t))); tmp = 0.0; if (a <= -3.2e+56) tmp = t_2; elseif (a <= -3.8e+35) tmp = t_1; elseif (a <= -6.8e-13) tmp = x * (((t - z) / (a - t)) + 1.0); elseif (a <= -1.7e-127) tmp = y * ((z - t) / (a - t)); elseif (a <= -4.2e-231) tmp = z / ((a - t) / (y - x)); elseif (a <= 2.7e-39) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y + N[(N[(x - y), $MachinePrecision] / N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(N[(x - y), $MachinePrecision] / N[(a / N[(z - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -3.2e+56], t$95$2, If[LessEqual[a, -3.8e+35], t$95$1, If[LessEqual[a, -6.8e-13], N[(x * N[(N[(N[(t - z), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -1.7e-127], N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -4.2e-231], N[(z / N[(N[(a - t), $MachinePrecision] / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.7e-39], t$95$1, t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + \frac{x - y}{\frac{t}{z}}\\
t_2 := x - \frac{x - y}{\frac{a}{z - t}}\\
\mathbf{if}\;a \leq -3.2 \cdot 10^{+56}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq -3.8 \cdot 10^{+35}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -6.8 \cdot 10^{-13}:\\
\;\;\;\;x \cdot \left(\frac{t - z}{a - t} + 1\right)\\
\mathbf{elif}\;a \leq -1.7 \cdot 10^{-127}:\\
\;\;\;\;y \cdot \frac{z - t}{a - t}\\
\mathbf{elif}\;a \leq -4.2 \cdot 10^{-231}:\\
\;\;\;\;\frac{z}{\frac{a - t}{y - x}}\\
\mathbf{elif}\;a \leq 2.7 \cdot 10^{-39}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if a < -3.20000000000000003e56 or 2.7000000000000001e-39 < a Initial program 71.6%
associate-*l/89.9%
Simplified89.9%
Taylor expanded in a around inf 67.6%
associate-/l*79.5%
Simplified79.5%
if -3.20000000000000003e56 < a < -3.8e35 or -4.19999999999999978e-231 < a < 2.7000000000000001e-39Initial program 65.1%
associate-*l/70.4%
Simplified70.4%
Taylor expanded in t around inf 80.7%
associate--l+80.7%
associate-*r/80.7%
associate-*r/80.7%
div-sub80.7%
distribute-lft-out--80.7%
associate-*r/80.7%
mul-1-neg80.7%
unsub-neg80.7%
distribute-rgt-out--80.7%
associate-/l*86.3%
Simplified86.3%
Taylor expanded in z around inf 83.4%
if -3.8e35 < a < -6.80000000000000031e-13Initial program 85.2%
associate-*l/92.5%
Simplified92.5%
Taylor expanded in x around inf 77.5%
mul-1-neg77.5%
unsub-neg77.5%
Simplified77.5%
if -6.80000000000000031e-13 < a < -1.6999999999999999e-127Initial program 73.6%
associate-*l/82.8%
Simplified82.8%
Taylor expanded in x around 0 68.9%
associate-/l*79.1%
div-inv79.2%
clear-num79.2%
Applied egg-rr79.2%
if -1.6999999999999999e-127 < a < -4.19999999999999978e-231Initial program 69.0%
+-commutative69.0%
associate-*l/69.2%
fma-def69.1%
Simplified69.1%
fma-udef69.2%
associate-/r/64.5%
div-inv64.4%
clear-num64.6%
Applied egg-rr64.6%
clear-num64.4%
un-div-inv64.5%
Applied egg-rr64.5%
Taylor expanded in z around -inf 74.8%
associate-/l*84.8%
Simplified84.8%
Final simplification81.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ y (* z (/ (- x y) t)))))
(if (<= t -4.2e+75)
t_1
(if (<= t -3.4e-31)
(* y (/ (- z t) (- a t)))
(if (or (<= t -2.5e-54)
(and (not (<= t 2.05e-91))
(or (<= t 1.48e-27) (not (<= t 370000000.0)))))
t_1
(+ x (/ z (/ a (- y x)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y + (z * ((x - y) / t));
double tmp;
if (t <= -4.2e+75) {
tmp = t_1;
} else if (t <= -3.4e-31) {
tmp = y * ((z - t) / (a - t));
} else if ((t <= -2.5e-54) || (!(t <= 2.05e-91) && ((t <= 1.48e-27) || !(t <= 370000000.0)))) {
tmp = t_1;
} else {
tmp = x + (z / (a / (y - x)));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = y + (z * ((x - y) / t))
if (t <= (-4.2d+75)) then
tmp = t_1
else if (t <= (-3.4d-31)) then
tmp = y * ((z - t) / (a - t))
else if ((t <= (-2.5d-54)) .or. (.not. (t <= 2.05d-91)) .and. (t <= 1.48d-27) .or. (.not. (t <= 370000000.0d0))) then
tmp = t_1
else
tmp = x + (z / (a / (y - x)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y + (z * ((x - y) / t));
double tmp;
if (t <= -4.2e+75) {
tmp = t_1;
} else if (t <= -3.4e-31) {
tmp = y * ((z - t) / (a - t));
} else if ((t <= -2.5e-54) || (!(t <= 2.05e-91) && ((t <= 1.48e-27) || !(t <= 370000000.0)))) {
tmp = t_1;
} else {
tmp = x + (z / (a / (y - x)));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y + (z * ((x - y) / t)) tmp = 0 if t <= -4.2e+75: tmp = t_1 elif t <= -3.4e-31: tmp = y * ((z - t) / (a - t)) elif (t <= -2.5e-54) or (not (t <= 2.05e-91) and ((t <= 1.48e-27) or not (t <= 370000000.0))): tmp = t_1 else: tmp = x + (z / (a / (y - x))) return tmp
function code(x, y, z, t, a) t_1 = Float64(y + Float64(z * Float64(Float64(x - y) / t))) tmp = 0.0 if (t <= -4.2e+75) tmp = t_1; elseif (t <= -3.4e-31) tmp = Float64(y * Float64(Float64(z - t) / Float64(a - t))); elseif ((t <= -2.5e-54) || (!(t <= 2.05e-91) && ((t <= 1.48e-27) || !(t <= 370000000.0)))) tmp = t_1; else tmp = Float64(x + Float64(z / Float64(a / Float64(y - x)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y + (z * ((x - y) / t)); tmp = 0.0; if (t <= -4.2e+75) tmp = t_1; elseif (t <= -3.4e-31) tmp = y * ((z - t) / (a - t)); elseif ((t <= -2.5e-54) || (~((t <= 2.05e-91)) && ((t <= 1.48e-27) || ~((t <= 370000000.0))))) tmp = t_1; else tmp = x + (z / (a / (y - x))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y + N[(z * N[(N[(x - y), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -4.2e+75], t$95$1, If[LessEqual[t, -3.4e-31], N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[t, -2.5e-54], And[N[Not[LessEqual[t, 2.05e-91]], $MachinePrecision], Or[LessEqual[t, 1.48e-27], N[Not[LessEqual[t, 370000000.0]], $MachinePrecision]]]], t$95$1, N[(x + N[(z / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + z \cdot \frac{x - y}{t}\\
\mathbf{if}\;t \leq -4.2 \cdot 10^{+75}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -3.4 \cdot 10^{-31}:\\
\;\;\;\;y \cdot \frac{z - t}{a - t}\\
\mathbf{elif}\;t \leq -2.5 \cdot 10^{-54} \lor \neg \left(t \leq 2.05 \cdot 10^{-91}\right) \land \left(t \leq 1.48 \cdot 10^{-27} \lor \neg \left(t \leq 370000000\right)\right):\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;x + \frac{z}{\frac{a}{y - x}}\\
\end{array}
\end{array}
if t < -4.19999999999999997e75 or -3.4000000000000001e-31 < t < -2.50000000000000008e-54 or 2.05000000000000012e-91 < t < 1.48000000000000008e-27 or 3.7e8 < t Initial program 49.8%
associate-*l/67.9%
Simplified67.9%
Taylor expanded in t around inf 70.5%
associate--l+70.5%
associate-*r/70.5%
associate-*r/70.5%
div-sub70.5%
distribute-lft-out--70.5%
associate-*r/70.5%
mul-1-neg70.5%
unsub-neg70.5%
distribute-rgt-out--71.4%
associate-/l*82.5%
Simplified82.5%
Taylor expanded in z around inf 66.8%
associate-*r/72.4%
Simplified72.4%
if -4.19999999999999997e75 < t < -3.4000000000000001e-31Initial program 70.2%
associate-*l/77.9%
Simplified77.9%
Taylor expanded in x around 0 63.2%
associate-/l*66.6%
div-inv66.6%
clear-num66.7%
Applied egg-rr66.7%
if -2.50000000000000008e-54 < t < 2.05000000000000012e-91 or 1.48000000000000008e-27 < t < 3.7e8Initial program 90.8%
associate-*l/95.8%
Simplified95.8%
Taylor expanded in t around 0 74.7%
associate-/l*80.1%
Simplified80.1%
Final simplification75.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* z (/ (- y x) (- a t)))) (t_2 (* y (/ (- z t) (- a t)))))
(if (<= y -6.6e-54)
t_2
(if (<= y -1.35e-251)
t_1
(if (<= y -1.8e-300)
x
(if (or (<= y 2.7e-106) (and (not (<= y 6.5e+52)) (<= y 6.6e+163)))
t_1
t_2))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = z * ((y - x) / (a - t));
double t_2 = y * ((z - t) / (a - t));
double tmp;
if (y <= -6.6e-54) {
tmp = t_2;
} else if (y <= -1.35e-251) {
tmp = t_1;
} else if (y <= -1.8e-300) {
tmp = x;
} else if ((y <= 2.7e-106) || (!(y <= 6.5e+52) && (y <= 6.6e+163))) {
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 = z * ((y - x) / (a - t))
t_2 = y * ((z - t) / (a - t))
if (y <= (-6.6d-54)) then
tmp = t_2
else if (y <= (-1.35d-251)) then
tmp = t_1
else if (y <= (-1.8d-300)) then
tmp = x
else if ((y <= 2.7d-106) .or. (.not. (y <= 6.5d+52)) .and. (y <= 6.6d+163)) 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 = z * ((y - x) / (a - t));
double t_2 = y * ((z - t) / (a - t));
double tmp;
if (y <= -6.6e-54) {
tmp = t_2;
} else if (y <= -1.35e-251) {
tmp = t_1;
} else if (y <= -1.8e-300) {
tmp = x;
} else if ((y <= 2.7e-106) || (!(y <= 6.5e+52) && (y <= 6.6e+163))) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = z * ((y - x) / (a - t)) t_2 = y * ((z - t) / (a - t)) tmp = 0 if y <= -6.6e-54: tmp = t_2 elif y <= -1.35e-251: tmp = t_1 elif y <= -1.8e-300: tmp = x elif (y <= 2.7e-106) or (not (y <= 6.5e+52) and (y <= 6.6e+163)): tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(z * Float64(Float64(y - x) / Float64(a - t))) t_2 = Float64(y * Float64(Float64(z - t) / Float64(a - t))) tmp = 0.0 if (y <= -6.6e-54) tmp = t_2; elseif (y <= -1.35e-251) tmp = t_1; elseif (y <= -1.8e-300) tmp = x; elseif ((y <= 2.7e-106) || (!(y <= 6.5e+52) && (y <= 6.6e+163))) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = z * ((y - x) / (a - t)); t_2 = y * ((z - t) / (a - t)); tmp = 0.0; if (y <= -6.6e-54) tmp = t_2; elseif (y <= -1.35e-251) tmp = t_1; elseif (y <= -1.8e-300) tmp = x; elseif ((y <= 2.7e-106) || (~((y <= 6.5e+52)) && (y <= 6.6e+163))) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(z * N[(N[(y - x), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -6.6e-54], t$95$2, If[LessEqual[y, -1.35e-251], t$95$1, If[LessEqual[y, -1.8e-300], x, If[Or[LessEqual[y, 2.7e-106], And[N[Not[LessEqual[y, 6.5e+52]], $MachinePrecision], LessEqual[y, 6.6e+163]]], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \frac{y - x}{a - t}\\
t_2 := y \cdot \frac{z - t}{a - t}\\
\mathbf{if}\;y \leq -6.6 \cdot 10^{-54}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -1.35 \cdot 10^{-251}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -1.8 \cdot 10^{-300}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 2.7 \cdot 10^{-106} \lor \neg \left(y \leq 6.5 \cdot 10^{+52}\right) \land y \leq 6.6 \cdot 10^{+163}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if y < -6.59999999999999986e-54 or 2.70000000000000022e-106 < y < 6.49999999999999996e52 or 6.5999999999999999e163 < y Initial program 65.8%
associate-*l/87.1%
Simplified87.1%
Taylor expanded in x around 0 53.9%
associate-/l*70.6%
div-inv70.6%
clear-num70.6%
Applied egg-rr70.6%
if -6.59999999999999986e-54 < y < -1.35000000000000005e-251 or -1.80000000000000008e-300 < y < 2.70000000000000022e-106 or 6.49999999999999996e52 < y < 6.5999999999999999e163Initial program 74.0%
associate-*l/75.7%
Simplified75.7%
Taylor expanded in z around inf 56.7%
div-sub56.7%
Simplified56.7%
if -1.35000000000000005e-251 < y < -1.80000000000000008e-300Initial program 82.2%
associate-*l/70.3%
Simplified70.3%
Taylor expanded in a around inf 58.7%
Final simplification64.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* z (/ (- y x) (- a t)))) (t_2 (* (- z t) (/ y (- a t)))))
(if (<= y -2.6e-52)
t_2
(if (<= y -6.2e-252)
t_1
(if (<= y -1.65e-300)
x
(if (<= y 1.95e-106)
t_1
(if (<= y 8.8e+51)
(* y (/ (- z t) (- a t)))
(if (<= y 4.1e+163) t_1 t_2))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = z * ((y - x) / (a - t));
double t_2 = (z - t) * (y / (a - t));
double tmp;
if (y <= -2.6e-52) {
tmp = t_2;
} else if (y <= -6.2e-252) {
tmp = t_1;
} else if (y <= -1.65e-300) {
tmp = x;
} else if (y <= 1.95e-106) {
tmp = t_1;
} else if (y <= 8.8e+51) {
tmp = y * ((z - t) / (a - t));
} else if (y <= 4.1e+163) {
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 = z * ((y - x) / (a - t))
t_2 = (z - t) * (y / (a - t))
if (y <= (-2.6d-52)) then
tmp = t_2
else if (y <= (-6.2d-252)) then
tmp = t_1
else if (y <= (-1.65d-300)) then
tmp = x
else if (y <= 1.95d-106) then
tmp = t_1
else if (y <= 8.8d+51) then
tmp = y * ((z - t) / (a - t))
else if (y <= 4.1d+163) 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 = z * ((y - x) / (a - t));
double t_2 = (z - t) * (y / (a - t));
double tmp;
if (y <= -2.6e-52) {
tmp = t_2;
} else if (y <= -6.2e-252) {
tmp = t_1;
} else if (y <= -1.65e-300) {
tmp = x;
} else if (y <= 1.95e-106) {
tmp = t_1;
} else if (y <= 8.8e+51) {
tmp = y * ((z - t) / (a - t));
} else if (y <= 4.1e+163) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = z * ((y - x) / (a - t)) t_2 = (z - t) * (y / (a - t)) tmp = 0 if y <= -2.6e-52: tmp = t_2 elif y <= -6.2e-252: tmp = t_1 elif y <= -1.65e-300: tmp = x elif y <= 1.95e-106: tmp = t_1 elif y <= 8.8e+51: tmp = y * ((z - t) / (a - t)) elif y <= 4.1e+163: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(z * Float64(Float64(y - x) / Float64(a - t))) t_2 = Float64(Float64(z - t) * Float64(y / Float64(a - t))) tmp = 0.0 if (y <= -2.6e-52) tmp = t_2; elseif (y <= -6.2e-252) tmp = t_1; elseif (y <= -1.65e-300) tmp = x; elseif (y <= 1.95e-106) tmp = t_1; elseif (y <= 8.8e+51) tmp = Float64(y * Float64(Float64(z - t) / Float64(a - t))); elseif (y <= 4.1e+163) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = z * ((y - x) / (a - t)); t_2 = (z - t) * (y / (a - t)); tmp = 0.0; if (y <= -2.6e-52) tmp = t_2; elseif (y <= -6.2e-252) tmp = t_1; elseif (y <= -1.65e-300) tmp = x; elseif (y <= 1.95e-106) tmp = t_1; elseif (y <= 8.8e+51) tmp = y * ((z - t) / (a - t)); elseif (y <= 4.1e+163) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(z * N[(N[(y - x), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(z - t), $MachinePrecision] * N[(y / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.6e-52], t$95$2, If[LessEqual[y, -6.2e-252], t$95$1, If[LessEqual[y, -1.65e-300], x, If[LessEqual[y, 1.95e-106], t$95$1, If[LessEqual[y, 8.8e+51], N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.1e+163], t$95$1, t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \frac{y - x}{a - t}\\
t_2 := \left(z - t\right) \cdot \frac{y}{a - t}\\
\mathbf{if}\;y \leq -2.6 \cdot 10^{-52}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -6.2 \cdot 10^{-252}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -1.65 \cdot 10^{-300}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 1.95 \cdot 10^{-106}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 8.8 \cdot 10^{+51}:\\
\;\;\;\;y \cdot \frac{z - t}{a - t}\\
\mathbf{elif}\;y \leq 4.1 \cdot 10^{+163}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if y < -2.5999999999999999e-52 or 4.0999999999999999e163 < y Initial program 64.3%
associate-*l/88.3%
Simplified88.3%
Taylor expanded in x around 0 52.3%
associate-/l*71.9%
associate-/r/73.2%
Simplified73.2%
if -2.5999999999999999e-52 < y < -6.1999999999999997e-252 or -1.6500000000000001e-300 < y < 1.95000000000000005e-106 or 8.79999999999999967e51 < y < 4.0999999999999999e163Initial program 74.0%
associate-*l/75.7%
Simplified75.7%
Taylor expanded in z around inf 56.7%
div-sub56.7%
Simplified56.7%
if -6.1999999999999997e-252 < y < -1.6500000000000001e-300Initial program 82.2%
associate-*l/70.3%
Simplified70.3%
Taylor expanded in a around inf 58.7%
if 1.95000000000000005e-106 < y < 8.79999999999999967e51Initial program 72.6%
associate-*l/82.1%
Simplified82.1%
Taylor expanded in x around 0 61.3%
associate-/l*65.2%
div-inv65.1%
clear-num65.1%
Applied egg-rr65.1%
Final simplification64.7%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ y (/ (- x y) (/ t z)))) (t_2 (+ x (/ z (/ a (- y x))))))
(if (<= t -8.2e+74)
t_1
(if (<= t -6.2e-31)
(* y (/ (- z t) (- a t)))
(if (<= t -9.2e-55)
t_1
(if (<= t 3.6e-92)
t_2
(if (<= t 1.1e-27)
t_1
(if (<= t 195000000.0) t_2 (+ y (* z (/ (- x y) t)))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y + ((x - y) / (t / z));
double t_2 = x + (z / (a / (y - x)));
double tmp;
if (t <= -8.2e+74) {
tmp = t_1;
} else if (t <= -6.2e-31) {
tmp = y * ((z - t) / (a - t));
} else if (t <= -9.2e-55) {
tmp = t_1;
} else if (t <= 3.6e-92) {
tmp = t_2;
} else if (t <= 1.1e-27) {
tmp = t_1;
} else if (t <= 195000000.0) {
tmp = t_2;
} else {
tmp = y + (z * ((x - y) / 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) :: t_2
real(8) :: tmp
t_1 = y + ((x - y) / (t / z))
t_2 = x + (z / (a / (y - x)))
if (t <= (-8.2d+74)) then
tmp = t_1
else if (t <= (-6.2d-31)) then
tmp = y * ((z - t) / (a - t))
else if (t <= (-9.2d-55)) then
tmp = t_1
else if (t <= 3.6d-92) then
tmp = t_2
else if (t <= 1.1d-27) then
tmp = t_1
else if (t <= 195000000.0d0) then
tmp = t_2
else
tmp = y + (z * ((x - y) / 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 + ((x - y) / (t / z));
double t_2 = x + (z / (a / (y - x)));
double tmp;
if (t <= -8.2e+74) {
tmp = t_1;
} else if (t <= -6.2e-31) {
tmp = y * ((z - t) / (a - t));
} else if (t <= -9.2e-55) {
tmp = t_1;
} else if (t <= 3.6e-92) {
tmp = t_2;
} else if (t <= 1.1e-27) {
tmp = t_1;
} else if (t <= 195000000.0) {
tmp = t_2;
} else {
tmp = y + (z * ((x - y) / t));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y + ((x - y) / (t / z)) t_2 = x + (z / (a / (y - x))) tmp = 0 if t <= -8.2e+74: tmp = t_1 elif t <= -6.2e-31: tmp = y * ((z - t) / (a - t)) elif t <= -9.2e-55: tmp = t_1 elif t <= 3.6e-92: tmp = t_2 elif t <= 1.1e-27: tmp = t_1 elif t <= 195000000.0: tmp = t_2 else: tmp = y + (z * ((x - y) / t)) return tmp
function code(x, y, z, t, a) t_1 = Float64(y + Float64(Float64(x - y) / Float64(t / z))) t_2 = Float64(x + Float64(z / Float64(a / Float64(y - x)))) tmp = 0.0 if (t <= -8.2e+74) tmp = t_1; elseif (t <= -6.2e-31) tmp = Float64(y * Float64(Float64(z - t) / Float64(a - t))); elseif (t <= -9.2e-55) tmp = t_1; elseif (t <= 3.6e-92) tmp = t_2; elseif (t <= 1.1e-27) tmp = t_1; elseif (t <= 195000000.0) tmp = t_2; else tmp = Float64(y + Float64(z * Float64(Float64(x - y) / t))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y + ((x - y) / (t / z)); t_2 = x + (z / (a / (y - x))); tmp = 0.0; if (t <= -8.2e+74) tmp = t_1; elseif (t <= -6.2e-31) tmp = y * ((z - t) / (a - t)); elseif (t <= -9.2e-55) tmp = t_1; elseif (t <= 3.6e-92) tmp = t_2; elseif (t <= 1.1e-27) tmp = t_1; elseif (t <= 195000000.0) tmp = t_2; else tmp = y + (z * ((x - y) / t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y + N[(N[(x - y), $MachinePrecision] / N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(z / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -8.2e+74], t$95$1, If[LessEqual[t, -6.2e-31], N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -9.2e-55], t$95$1, If[LessEqual[t, 3.6e-92], t$95$2, If[LessEqual[t, 1.1e-27], t$95$1, If[LessEqual[t, 195000000.0], t$95$2, N[(y + N[(z * N[(N[(x - y), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + \frac{x - y}{\frac{t}{z}}\\
t_2 := x + \frac{z}{\frac{a}{y - x}}\\
\mathbf{if}\;t \leq -8.2 \cdot 10^{+74}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -6.2 \cdot 10^{-31}:\\
\;\;\;\;y \cdot \frac{z - t}{a - t}\\
\mathbf{elif}\;t \leq -9.2 \cdot 10^{-55}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 3.6 \cdot 10^{-92}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 1.1 \cdot 10^{-27}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 195000000:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;y + z \cdot \frac{x - y}{t}\\
\end{array}
\end{array}
if t < -8.2000000000000001e74 or -6.19999999999999999e-31 < t < -9.20000000000000046e-55 or 3.60000000000000016e-92 < t < 1.09999999999999993e-27Initial program 54.9%
associate-*l/70.1%
Simplified70.1%
Taylor expanded in t around inf 73.5%
associate--l+73.5%
associate-*r/73.5%
associate-*r/73.5%
div-sub73.5%
distribute-lft-out--73.5%
associate-*r/73.5%
mul-1-neg73.5%
unsub-neg73.5%
distribute-rgt-out--73.5%
associate-/l*86.6%
Simplified86.6%
Taylor expanded in z around inf 81.3%
if -8.2000000000000001e74 < t < -6.19999999999999999e-31Initial program 70.2%
associate-*l/77.9%
Simplified77.9%
Taylor expanded in x around 0 63.2%
associate-/l*66.6%
div-inv66.6%
clear-num66.7%
Applied egg-rr66.7%
if -9.20000000000000046e-55 < t < 3.60000000000000016e-92 or 1.09999999999999993e-27 < t < 1.95e8Initial program 90.8%
associate-*l/95.8%
Simplified95.8%
Taylor expanded in t around 0 74.7%
associate-/l*80.1%
Simplified80.1%
if 1.95e8 < t Initial program 43.7%
associate-*l/65.3%
Simplified65.3%
Taylor expanded in t around inf 67.0%
associate--l+67.0%
associate-*r/67.0%
associate-*r/67.0%
div-sub67.0%
distribute-lft-out--67.0%
associate-*r/67.0%
mul-1-neg67.0%
unsub-neg67.0%
distribute-rgt-out--68.9%
associate-/l*77.7%
Simplified77.7%
Taylor expanded in z around inf 62.0%
associate-*r/69.1%
Simplified69.1%
Final simplification76.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ z (/ a (- y x))))) (t_2 (+ y (/ (- x y) (/ t z)))))
(if (<= t -5.4e+132)
(+ y (* (- z a) (/ x t)))
(if (<= t -3.8e-31)
(* y (/ (- z t) (- a t)))
(if (<= t -1.3e-57)
t_2
(if (<= t 1.15e-91)
t_1
(if (<= t 8e-28)
t_2
(if (<= t 120000000.0) t_1 (+ y (* z (/ (- x y) t)))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (z / (a / (y - x)));
double t_2 = y + ((x - y) / (t / z));
double tmp;
if (t <= -5.4e+132) {
tmp = y + ((z - a) * (x / t));
} else if (t <= -3.8e-31) {
tmp = y * ((z - t) / (a - t));
} else if (t <= -1.3e-57) {
tmp = t_2;
} else if (t <= 1.15e-91) {
tmp = t_1;
} else if (t <= 8e-28) {
tmp = t_2;
} else if (t <= 120000000.0) {
tmp = t_1;
} else {
tmp = y + (z * ((x - y) / 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) :: t_2
real(8) :: tmp
t_1 = x + (z / (a / (y - x)))
t_2 = y + ((x - y) / (t / z))
if (t <= (-5.4d+132)) then
tmp = y + ((z - a) * (x / t))
else if (t <= (-3.8d-31)) then
tmp = y * ((z - t) / (a - t))
else if (t <= (-1.3d-57)) then
tmp = t_2
else if (t <= 1.15d-91) then
tmp = t_1
else if (t <= 8d-28) then
tmp = t_2
else if (t <= 120000000.0d0) then
tmp = t_1
else
tmp = y + (z * ((x - y) / 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 + (z / (a / (y - x)));
double t_2 = y + ((x - y) / (t / z));
double tmp;
if (t <= -5.4e+132) {
tmp = y + ((z - a) * (x / t));
} else if (t <= -3.8e-31) {
tmp = y * ((z - t) / (a - t));
} else if (t <= -1.3e-57) {
tmp = t_2;
} else if (t <= 1.15e-91) {
tmp = t_1;
} else if (t <= 8e-28) {
tmp = t_2;
} else if (t <= 120000000.0) {
tmp = t_1;
} else {
tmp = y + (z * ((x - y) / t));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (z / (a / (y - x))) t_2 = y + ((x - y) / (t / z)) tmp = 0 if t <= -5.4e+132: tmp = y + ((z - a) * (x / t)) elif t <= -3.8e-31: tmp = y * ((z - t) / (a - t)) elif t <= -1.3e-57: tmp = t_2 elif t <= 1.15e-91: tmp = t_1 elif t <= 8e-28: tmp = t_2 elif t <= 120000000.0: tmp = t_1 else: tmp = y + (z * ((x - y) / t)) return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(z / Float64(a / Float64(y - x)))) t_2 = Float64(y + Float64(Float64(x - y) / Float64(t / z))) tmp = 0.0 if (t <= -5.4e+132) tmp = Float64(y + Float64(Float64(z - a) * Float64(x / t))); elseif (t <= -3.8e-31) tmp = Float64(y * Float64(Float64(z - t) / Float64(a - t))); elseif (t <= -1.3e-57) tmp = t_2; elseif (t <= 1.15e-91) tmp = t_1; elseif (t <= 8e-28) tmp = t_2; elseif (t <= 120000000.0) tmp = t_1; else tmp = Float64(y + Float64(z * Float64(Float64(x - y) / t))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (z / (a / (y - x))); t_2 = y + ((x - y) / (t / z)); tmp = 0.0; if (t <= -5.4e+132) tmp = y + ((z - a) * (x / t)); elseif (t <= -3.8e-31) tmp = y * ((z - t) / (a - t)); elseif (t <= -1.3e-57) tmp = t_2; elseif (t <= 1.15e-91) tmp = t_1; elseif (t <= 8e-28) tmp = t_2; elseif (t <= 120000000.0) tmp = t_1; else tmp = y + (z * ((x - y) / t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(z / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y + N[(N[(x - y), $MachinePrecision] / N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -5.4e+132], N[(y + N[(N[(z - a), $MachinePrecision] * N[(x / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -3.8e-31], N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.3e-57], t$95$2, If[LessEqual[t, 1.15e-91], t$95$1, If[LessEqual[t, 8e-28], t$95$2, If[LessEqual[t, 120000000.0], t$95$1, N[(y + N[(z * N[(N[(x - y), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{z}{\frac{a}{y - x}}\\
t_2 := y + \frac{x - y}{\frac{t}{z}}\\
\mathbf{if}\;t \leq -5.4 \cdot 10^{+132}:\\
\;\;\;\;y + \left(z - a\right) \cdot \frac{x}{t}\\
\mathbf{elif}\;t \leq -3.8 \cdot 10^{-31}:\\
\;\;\;\;y \cdot \frac{z - t}{a - t}\\
\mathbf{elif}\;t \leq -1.3 \cdot 10^{-57}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 1.15 \cdot 10^{-91}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 8 \cdot 10^{-28}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 120000000:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y + z \cdot \frac{x - y}{t}\\
\end{array}
\end{array}
if t < -5.3999999999999999e132Initial program 34.5%
associate-*l/63.0%
Simplified63.0%
Taylor expanded in t around inf 59.2%
associate--l+59.2%
associate-*r/59.2%
associate-*r/59.2%
div-sub59.2%
distribute-lft-out--59.2%
associate-*r/59.2%
mul-1-neg59.2%
unsub-neg59.2%
distribute-rgt-out--59.2%
associate-/l*89.7%
Simplified89.7%
Taylor expanded in y around 0 63.9%
mul-1-neg63.9%
associate-*l/80.3%
distribute-rgt-neg-in80.3%
Simplified80.3%
if -5.3999999999999999e132 < t < -3.8e-31Initial program 60.8%
associate-*l/71.4%
Simplified71.4%
Taylor expanded in x around 0 63.8%
associate-/l*71.4%
div-inv71.4%
clear-num71.5%
Applied egg-rr71.5%
if -3.8e-31 < t < -1.29999999999999993e-57 or 1.14999999999999998e-91 < t < 7.99999999999999977e-28Initial program 83.7%
associate-*l/83.7%
Simplified83.7%
Taylor expanded in t around inf 85.0%
associate--l+85.0%
associate-*r/85.0%
associate-*r/85.0%
div-sub85.0%
distribute-lft-out--85.0%
associate-*r/85.0%
mul-1-neg85.0%
unsub-neg85.0%
distribute-rgt-out--85.0%
associate-/l*85.1%
Simplified85.1%
Taylor expanded in z around inf 84.1%
if -1.29999999999999993e-57 < t < 1.14999999999999998e-91 or 7.99999999999999977e-28 < t < 1.2e8Initial program 90.8%
associate-*l/95.8%
Simplified95.8%
Taylor expanded in t around 0 74.7%
associate-/l*80.1%
Simplified80.1%
if 1.2e8 < t Initial program 43.7%
associate-*l/65.3%
Simplified65.3%
Taylor expanded in t around inf 67.0%
associate--l+67.0%
associate-*r/67.0%
associate-*r/67.0%
div-sub67.0%
distribute-lft-out--67.0%
associate-*r/67.0%
mul-1-neg67.0%
unsub-neg67.0%
distribute-rgt-out--68.9%
associate-/l*77.7%
Simplified77.7%
Taylor expanded in z around inf 62.0%
associate-*r/69.1%
Simplified69.1%
Final simplification77.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ x (/ t (- z a)))))
(if (<= t -5.8e+279)
t_1
(if (<= t -7.5e-54)
(* y (+ (/ a t) 1.0))
(if (<= t -8.2e-237)
x
(if (<= t -9.5e-280)
(/ 1.0 (/ (/ a z) y))
(if (<= t 9.5e-93) x (if (<= t 3e+193) t_1 y))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x / (t / (z - a));
double tmp;
if (t <= -5.8e+279) {
tmp = t_1;
} else if (t <= -7.5e-54) {
tmp = y * ((a / t) + 1.0);
} else if (t <= -8.2e-237) {
tmp = x;
} else if (t <= -9.5e-280) {
tmp = 1.0 / ((a / z) / y);
} else if (t <= 9.5e-93) {
tmp = x;
} else if (t <= 3e+193) {
tmp = t_1;
} else {
tmp = y;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x / (t / (z - a))
if (t <= (-5.8d+279)) then
tmp = t_1
else if (t <= (-7.5d-54)) then
tmp = y * ((a / t) + 1.0d0)
else if (t <= (-8.2d-237)) then
tmp = x
else if (t <= (-9.5d-280)) then
tmp = 1.0d0 / ((a / z) / y)
else if (t <= 9.5d-93) then
tmp = x
else if (t <= 3d+193) then
tmp = t_1
else
tmp = y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x / (t / (z - a));
double tmp;
if (t <= -5.8e+279) {
tmp = t_1;
} else if (t <= -7.5e-54) {
tmp = y * ((a / t) + 1.0);
} else if (t <= -8.2e-237) {
tmp = x;
} else if (t <= -9.5e-280) {
tmp = 1.0 / ((a / z) / y);
} else if (t <= 9.5e-93) {
tmp = x;
} else if (t <= 3e+193) {
tmp = t_1;
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x / (t / (z - a)) tmp = 0 if t <= -5.8e+279: tmp = t_1 elif t <= -7.5e-54: tmp = y * ((a / t) + 1.0) elif t <= -8.2e-237: tmp = x elif t <= -9.5e-280: tmp = 1.0 / ((a / z) / y) elif t <= 9.5e-93: tmp = x elif t <= 3e+193: tmp = t_1 else: tmp = y return tmp
function code(x, y, z, t, a) t_1 = Float64(x / Float64(t / Float64(z - a))) tmp = 0.0 if (t <= -5.8e+279) tmp = t_1; elseif (t <= -7.5e-54) tmp = Float64(y * Float64(Float64(a / t) + 1.0)); elseif (t <= -8.2e-237) tmp = x; elseif (t <= -9.5e-280) tmp = Float64(1.0 / Float64(Float64(a / z) / y)); elseif (t <= 9.5e-93) tmp = x; elseif (t <= 3e+193) tmp = t_1; else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x / (t / (z - a)); tmp = 0.0; if (t <= -5.8e+279) tmp = t_1; elseif (t <= -7.5e-54) tmp = y * ((a / t) + 1.0); elseif (t <= -8.2e-237) tmp = x; elseif (t <= -9.5e-280) tmp = 1.0 / ((a / z) / y); elseif (t <= 9.5e-93) tmp = x; elseif (t <= 3e+193) tmp = t_1; else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x / N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -5.8e+279], t$95$1, If[LessEqual[t, -7.5e-54], N[(y * N[(N[(a / t), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -8.2e-237], x, If[LessEqual[t, -9.5e-280], N[(1.0 / N[(N[(a / z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 9.5e-93], x, If[LessEqual[t, 3e+193], t$95$1, y]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{\frac{t}{z - a}}\\
\mathbf{if}\;t \leq -5.8 \cdot 10^{+279}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -7.5 \cdot 10^{-54}:\\
\;\;\;\;y \cdot \left(\frac{a}{t} + 1\right)\\
\mathbf{elif}\;t \leq -8.2 \cdot 10^{-237}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq -9.5 \cdot 10^{-280}:\\
\;\;\;\;\frac{1}{\frac{\frac{a}{z}}{y}}\\
\mathbf{elif}\;t \leq 9.5 \cdot 10^{-93}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 3 \cdot 10^{+193}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -5.7999999999999995e279 or 9.5000000000000001e-93 < t < 3e193Initial program 63.3%
associate-*l/69.1%
Simplified69.1%
Taylor expanded in x around -inf 53.0%
mul-1-neg53.0%
*-commutative53.0%
distribute-rgt-neg-in53.0%
associate--r+36.9%
sub-neg36.9%
metadata-eval36.9%
Simplified36.9%
Taylor expanded in t around -inf 34.4%
associate-/l*43.5%
Simplified43.5%
if -5.7999999999999995e279 < t < -7.5000000000000005e-54Initial program 59.6%
associate-*l/76.3%
Simplified76.3%
Taylor expanded in t around inf 69.2%
associate--l+69.2%
associate-*r/69.2%
associate-*r/69.2%
div-sub69.3%
distribute-lft-out--69.3%
associate-*r/69.3%
mul-1-neg69.3%
unsub-neg69.3%
distribute-rgt-out--69.4%
associate-/l*76.9%
Simplified76.9%
Taylor expanded in z around 0 45.5%
associate-*r/45.5%
neg-mul-145.5%
Simplified45.5%
Taylor expanded in y around inf 39.8%
sub-neg39.8%
mul-1-neg39.8%
remove-double-neg39.8%
Simplified39.8%
if -7.5000000000000005e-54 < t < -8.2000000000000002e-237 or -9.50000000000000082e-280 < t < 9.5000000000000001e-93Initial program 90.8%
associate-*l/95.9%
Simplified95.9%
Taylor expanded in a around inf 47.4%
if -8.2000000000000002e-237 < t < -9.50000000000000082e-280Initial program 91.2%
associate-*l/91.0%
Simplified91.0%
Taylor expanded in x around 0 48.1%
Taylor expanded in t around 0 48.1%
associate-/l*56.5%
Simplified56.5%
clear-num56.6%
inv-pow56.6%
Applied egg-rr56.6%
unpow-156.6%
Simplified56.6%
if 3e193 < t Initial program 22.2%
associate-*l/67.8%
Simplified67.8%
Taylor expanded in t around inf 72.7%
Final simplification47.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ x (/ t (- z a)))))
(if (<= t -5.8e+279)
t_1
(if (<= t -1.15e-53)
(* y (+ (/ a t) 1.0))
(if (<= t 4.5e-92)
x
(if (<= t 2e-26)
(* x (/ z t))
(if (<= t 3e+46) (/ y (/ a (- z t))) (if (<= t 6e+192) t_1 y))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x / (t / (z - a));
double tmp;
if (t <= -5.8e+279) {
tmp = t_1;
} else if (t <= -1.15e-53) {
tmp = y * ((a / t) + 1.0);
} else if (t <= 4.5e-92) {
tmp = x;
} else if (t <= 2e-26) {
tmp = x * (z / t);
} else if (t <= 3e+46) {
tmp = y / (a / (z - t));
} else if (t <= 6e+192) {
tmp = t_1;
} else {
tmp = y;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x / (t / (z - a))
if (t <= (-5.8d+279)) then
tmp = t_1
else if (t <= (-1.15d-53)) then
tmp = y * ((a / t) + 1.0d0)
else if (t <= 4.5d-92) then
tmp = x
else if (t <= 2d-26) then
tmp = x * (z / t)
else if (t <= 3d+46) then
tmp = y / (a / (z - t))
else if (t <= 6d+192) then
tmp = t_1
else
tmp = y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x / (t / (z - a));
double tmp;
if (t <= -5.8e+279) {
tmp = t_1;
} else if (t <= -1.15e-53) {
tmp = y * ((a / t) + 1.0);
} else if (t <= 4.5e-92) {
tmp = x;
} else if (t <= 2e-26) {
tmp = x * (z / t);
} else if (t <= 3e+46) {
tmp = y / (a / (z - t));
} else if (t <= 6e+192) {
tmp = t_1;
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x / (t / (z - a)) tmp = 0 if t <= -5.8e+279: tmp = t_1 elif t <= -1.15e-53: tmp = y * ((a / t) + 1.0) elif t <= 4.5e-92: tmp = x elif t <= 2e-26: tmp = x * (z / t) elif t <= 3e+46: tmp = y / (a / (z - t)) elif t <= 6e+192: tmp = t_1 else: tmp = y return tmp
function code(x, y, z, t, a) t_1 = Float64(x / Float64(t / Float64(z - a))) tmp = 0.0 if (t <= -5.8e+279) tmp = t_1; elseif (t <= -1.15e-53) tmp = Float64(y * Float64(Float64(a / t) + 1.0)); elseif (t <= 4.5e-92) tmp = x; elseif (t <= 2e-26) tmp = Float64(x * Float64(z / t)); elseif (t <= 3e+46) tmp = Float64(y / Float64(a / Float64(z - t))); elseif (t <= 6e+192) tmp = t_1; else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x / (t / (z - a)); tmp = 0.0; if (t <= -5.8e+279) tmp = t_1; elseif (t <= -1.15e-53) tmp = y * ((a / t) + 1.0); elseif (t <= 4.5e-92) tmp = x; elseif (t <= 2e-26) tmp = x * (z / t); elseif (t <= 3e+46) tmp = y / (a / (z - t)); elseif (t <= 6e+192) tmp = t_1; else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x / N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -5.8e+279], t$95$1, If[LessEqual[t, -1.15e-53], N[(y * N[(N[(a / t), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 4.5e-92], x, If[LessEqual[t, 2e-26], N[(x * N[(z / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3e+46], N[(y / N[(a / N[(z - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 6e+192], t$95$1, y]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{\frac{t}{z - a}}\\
\mathbf{if}\;t \leq -5.8 \cdot 10^{+279}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -1.15 \cdot 10^{-53}:\\
\;\;\;\;y \cdot \left(\frac{a}{t} + 1\right)\\
\mathbf{elif}\;t \leq 4.5 \cdot 10^{-92}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 2 \cdot 10^{-26}:\\
\;\;\;\;x \cdot \frac{z}{t}\\
\mathbf{elif}\;t \leq 3 \cdot 10^{+46}:\\
\;\;\;\;\frac{y}{\frac{a}{z - t}}\\
\mathbf{elif}\;t \leq 6 \cdot 10^{+192}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -5.7999999999999995e279 or 3.00000000000000023e46 < t < 6e192Initial program 38.2%
associate-*l/47.2%
Simplified47.2%
Taylor expanded in x around -inf 48.6%
mul-1-neg48.6%
*-commutative48.6%
distribute-rgt-neg-in48.6%
associate--r+21.0%
sub-neg21.0%
metadata-eval21.0%
Simplified21.0%
Taylor expanded in t around -inf 33.5%
associate-/l*52.5%
Simplified52.5%
if -5.7999999999999995e279 < t < -1.1500000000000001e-53Initial program 59.6%
associate-*l/76.3%
Simplified76.3%
Taylor expanded in t around inf 69.2%
associate--l+69.2%
associate-*r/69.2%
associate-*r/69.2%
div-sub69.3%
distribute-lft-out--69.3%
associate-*r/69.3%
mul-1-neg69.3%
unsub-neg69.3%
distribute-rgt-out--69.4%
associate-/l*76.9%
Simplified76.9%
Taylor expanded in z around 0 45.5%
associate-*r/45.5%
neg-mul-145.5%
Simplified45.5%
Taylor expanded in y around inf 39.8%
sub-neg39.8%
mul-1-neg39.8%
remove-double-neg39.8%
Simplified39.8%
if -1.1500000000000001e-53 < t < 4.5e-92Initial program 90.8%
associate-*l/95.4%
Simplified95.4%
Taylor expanded in a around inf 43.6%
if 4.5e-92 < t < 2.0000000000000001e-26Initial program 80.5%
associate-*l/80.5%
Simplified80.5%
Taylor expanded in x around -inf 70.7%
mul-1-neg70.7%
*-commutative70.7%
distribute-rgt-neg-in70.7%
associate--r+60.8%
sub-neg60.8%
metadata-eval60.8%
Simplified60.8%
Taylor expanded in a around 0 51.3%
associate-*r/51.3%
mul-1-neg51.3%
Simplified51.3%
if 2.0000000000000001e-26 < t < 3.00000000000000023e46Initial program 93.6%
associate-*l/100.0%
Simplified100.0%
Taylor expanded in x around 0 60.5%
Taylor expanded in a around inf 54.7%
associate-/l*54.7%
Simplified54.7%
if 6e192 < t Initial program 22.2%
associate-*l/67.8%
Simplified67.8%
Taylor expanded in t around inf 72.7%
Final simplification47.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (/ (- z t) (- a t)))) (t_2 (+ x (/ z (/ a (- y x))))))
(if (<= t -5.8e+279)
(/ x (/ t (- z a)))
(if (<= t -4.2e-54)
t_1
(if (<= t 1.25e-92)
t_2
(if (<= t 1.75e-31)
(* z (/ (- y x) (- a t)))
(if (<= t 130000000.0) t_2 t_1)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((z - t) / (a - t));
double t_2 = x + (z / (a / (y - x)));
double tmp;
if (t <= -5.8e+279) {
tmp = x / (t / (z - a));
} else if (t <= -4.2e-54) {
tmp = t_1;
} else if (t <= 1.25e-92) {
tmp = t_2;
} else if (t <= 1.75e-31) {
tmp = z * ((y - x) / (a - t));
} else if (t <= 130000000.0) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = y * ((z - t) / (a - t))
t_2 = x + (z / (a / (y - x)))
if (t <= (-5.8d+279)) then
tmp = x / (t / (z - a))
else if (t <= (-4.2d-54)) then
tmp = t_1
else if (t <= 1.25d-92) then
tmp = t_2
else if (t <= 1.75d-31) then
tmp = z * ((y - x) / (a - t))
else if (t <= 130000000.0d0) then
tmp = t_2
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((z - t) / (a - t));
double t_2 = x + (z / (a / (y - x)));
double tmp;
if (t <= -5.8e+279) {
tmp = x / (t / (z - a));
} else if (t <= -4.2e-54) {
tmp = t_1;
} else if (t <= 1.25e-92) {
tmp = t_2;
} else if (t <= 1.75e-31) {
tmp = z * ((y - x) / (a - t));
} else if (t <= 130000000.0) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * ((z - t) / (a - t)) t_2 = x + (z / (a / (y - x))) tmp = 0 if t <= -5.8e+279: tmp = x / (t / (z - a)) elif t <= -4.2e-54: tmp = t_1 elif t <= 1.25e-92: tmp = t_2 elif t <= 1.75e-31: tmp = z * ((y - x) / (a - t)) elif t <= 130000000.0: tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(Float64(z - t) / Float64(a - t))) t_2 = Float64(x + Float64(z / Float64(a / Float64(y - x)))) tmp = 0.0 if (t <= -5.8e+279) tmp = Float64(x / Float64(t / Float64(z - a))); elseif (t <= -4.2e-54) tmp = t_1; elseif (t <= 1.25e-92) tmp = t_2; elseif (t <= 1.75e-31) tmp = Float64(z * Float64(Float64(y - x) / Float64(a - t))); elseif (t <= 130000000.0) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * ((z - t) / (a - t)); t_2 = x + (z / (a / (y - x))); tmp = 0.0; if (t <= -5.8e+279) tmp = x / (t / (z - a)); elseif (t <= -4.2e-54) tmp = t_1; elseif (t <= 1.25e-92) tmp = t_2; elseif (t <= 1.75e-31) tmp = z * ((y - x) / (a - t)); elseif (t <= 130000000.0) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(z / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -5.8e+279], N[(x / N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -4.2e-54], t$95$1, If[LessEqual[t, 1.25e-92], t$95$2, If[LessEqual[t, 1.75e-31], N[(z * N[(N[(y - x), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 130000000.0], t$95$2, t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \frac{z - t}{a - t}\\
t_2 := x + \frac{z}{\frac{a}{y - x}}\\
\mathbf{if}\;t \leq -5.8 \cdot 10^{+279}:\\
\;\;\;\;\frac{x}{\frac{t}{z - a}}\\
\mathbf{elif}\;t \leq -4.2 \cdot 10^{-54}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 1.25 \cdot 10^{-92}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 1.75 \cdot 10^{-31}:\\
\;\;\;\;z \cdot \frac{y - x}{a - t}\\
\mathbf{elif}\;t \leq 130000000:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -5.7999999999999995e279Initial program 1.3%
associate-*l/17.5%
Simplified17.5%
Taylor expanded in x around -inf 77.5%
mul-1-neg77.5%
*-commutative77.5%
distribute-rgt-neg-in77.5%
associate--r+17.3%
sub-neg17.3%
metadata-eval17.3%
Simplified17.3%
Taylor expanded in t around -inf 45.6%
associate-/l*96.0%
Simplified96.0%
if -5.7999999999999995e279 < t < -4.2e-54 or 1.3e8 < t Initial program 52.3%
associate-*l/71.2%
Simplified71.2%
Taylor expanded in x around 0 45.0%
associate-/l*64.8%
div-inv64.8%
clear-num64.8%
Applied egg-rr64.8%
if -4.2e-54 < t < 1.25000000000000003e-92 or 1.74999999999999993e-31 < t < 1.3e8Initial program 90.9%
associate-*l/95.9%
Simplified95.9%
Taylor expanded in t around 0 74.1%
associate-/l*79.4%
Simplified79.4%
if 1.25000000000000003e-92 < t < 1.74999999999999993e-31Initial program 78.3%
associate-*l/78.3%
Simplified78.3%
Taylor expanded in z around inf 62.1%
div-sub62.1%
Simplified62.1%
Final simplification72.1%
(FPCore (x y z t a)
:precision binary64
(if (<= t -5e+136)
(+ y (* (- z a) (/ x t)))
(if (<= t -1.2e-31)
(* y (/ (- z t) (- a t)))
(if (<= t -1.15e-53)
(+ y (/ (- x y) (/ t z)))
(if (<= t 3.3e+74)
(+ x (* (- y x) (/ z (- a t))))
(+ y (* z (/ (- x y) t))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -5e+136) {
tmp = y + ((z - a) * (x / t));
} else if (t <= -1.2e-31) {
tmp = y * ((z - t) / (a - t));
} else if (t <= -1.15e-53) {
tmp = y + ((x - y) / (t / z));
} else if (t <= 3.3e+74) {
tmp = x + ((y - x) * (z / (a - t)));
} else {
tmp = y + (z * ((x - y) / t));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (t <= (-5d+136)) then
tmp = y + ((z - a) * (x / t))
else if (t <= (-1.2d-31)) then
tmp = y * ((z - t) / (a - t))
else if (t <= (-1.15d-53)) then
tmp = y + ((x - y) / (t / z))
else if (t <= 3.3d+74) then
tmp = x + ((y - x) * (z / (a - t)))
else
tmp = y + (z * ((x - y) / t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -5e+136) {
tmp = y + ((z - a) * (x / t));
} else if (t <= -1.2e-31) {
tmp = y * ((z - t) / (a - t));
} else if (t <= -1.15e-53) {
tmp = y + ((x - y) / (t / z));
} else if (t <= 3.3e+74) {
tmp = x + ((y - x) * (z / (a - t)));
} else {
tmp = y + (z * ((x - y) / t));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -5e+136: tmp = y + ((z - a) * (x / t)) elif t <= -1.2e-31: tmp = y * ((z - t) / (a - t)) elif t <= -1.15e-53: tmp = y + ((x - y) / (t / z)) elif t <= 3.3e+74: tmp = x + ((y - x) * (z / (a - t))) else: tmp = y + (z * ((x - y) / t)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -5e+136) tmp = Float64(y + Float64(Float64(z - a) * Float64(x / t))); elseif (t <= -1.2e-31) tmp = Float64(y * Float64(Float64(z - t) / Float64(a - t))); elseif (t <= -1.15e-53) tmp = Float64(y + Float64(Float64(x - y) / Float64(t / z))); elseif (t <= 3.3e+74) tmp = Float64(x + Float64(Float64(y - x) * Float64(z / Float64(a - t)))); else tmp = Float64(y + Float64(z * Float64(Float64(x - y) / t))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -5e+136) tmp = y + ((z - a) * (x / t)); elseif (t <= -1.2e-31) tmp = y * ((z - t) / (a - t)); elseif (t <= -1.15e-53) tmp = y + ((x - y) / (t / z)); elseif (t <= 3.3e+74) tmp = x + ((y - x) * (z / (a - t))); else tmp = y + (z * ((x - y) / t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -5e+136], N[(y + N[(N[(z - a), $MachinePrecision] * N[(x / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.2e-31], N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.15e-53], N[(y + N[(N[(x - y), $MachinePrecision] / N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.3e+74], N[(x + N[(N[(y - x), $MachinePrecision] * N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y + N[(z * N[(N[(x - y), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -5 \cdot 10^{+136}:\\
\;\;\;\;y + \left(z - a\right) \cdot \frac{x}{t}\\
\mathbf{elif}\;t \leq -1.2 \cdot 10^{-31}:\\
\;\;\;\;y \cdot \frac{z - t}{a - t}\\
\mathbf{elif}\;t \leq -1.15 \cdot 10^{-53}:\\
\;\;\;\;y + \frac{x - y}{\frac{t}{z}}\\
\mathbf{elif}\;t \leq 3.3 \cdot 10^{+74}:\\
\;\;\;\;x + \left(y - x\right) \cdot \frac{z}{a - t}\\
\mathbf{else}:\\
\;\;\;\;y + z \cdot \frac{x - y}{t}\\
\end{array}
\end{array}
if t < -5.0000000000000002e136Initial program 34.5%
associate-*l/63.0%
Simplified63.0%
Taylor expanded in t around inf 59.2%
associate--l+59.2%
associate-*r/59.2%
associate-*r/59.2%
div-sub59.2%
distribute-lft-out--59.2%
associate-*r/59.2%
mul-1-neg59.2%
unsub-neg59.2%
distribute-rgt-out--59.2%
associate-/l*89.7%
Simplified89.7%
Taylor expanded in y around 0 63.9%
mul-1-neg63.9%
associate-*l/80.3%
distribute-rgt-neg-in80.3%
Simplified80.3%
if -5.0000000000000002e136 < t < -1.2e-31Initial program 60.8%
associate-*l/71.4%
Simplified71.4%
Taylor expanded in x around 0 63.8%
associate-/l*71.4%
div-inv71.4%
clear-num71.5%
Applied egg-rr71.5%
if -1.2e-31 < t < -1.1500000000000001e-53Initial program 97.2%
associate-*l/97.2%
Simplified97.2%
Taylor expanded in t around inf 92.0%
associate--l+92.0%
associate-*r/92.0%
associate-*r/92.0%
div-sub92.0%
distribute-lft-out--92.0%
associate-*r/92.0%
mul-1-neg92.0%
unsub-neg92.0%
distribute-rgt-out--92.0%
associate-/l*92.0%
Simplified92.0%
Taylor expanded in z around inf 88.7%
if -1.1500000000000001e-53 < t < 3.3000000000000002e74Initial program 88.3%
+-commutative88.3%
associate-*l/92.8%
fma-def92.8%
Simplified92.8%
fma-udef92.8%
associate-/r/92.6%
div-inv92.6%
clear-num92.7%
Applied egg-rr92.7%
Taylor expanded in z around inf 84.3%
if 3.3000000000000002e74 < t Initial program 31.0%
associate-*l/57.8%
Simplified57.8%
Taylor expanded in t around inf 72.7%
associate--l+72.7%
associate-*r/72.7%
associate-*r/72.7%
div-sub72.7%
distribute-lft-out--72.7%
associate-*r/72.7%
mul-1-neg72.7%
unsub-neg72.7%
distribute-rgt-out--75.2%
associate-/l*87.2%
Simplified87.2%
Taylor expanded in z around inf 68.1%
associate-*r/77.7%
Simplified77.7%
Final simplification81.2%
(FPCore (x y z t a)
:precision binary64
(if (<= t -1.15e-53)
y
(if (<= t -8.8e-238)
x
(if (<= t -2.1e-279)
(/ y (/ a z))
(if (<= t 5.8e-94) x (if (<= t 5e+67) (/ (* x z) t) y))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -1.15e-53) {
tmp = y;
} else if (t <= -8.8e-238) {
tmp = x;
} else if (t <= -2.1e-279) {
tmp = y / (a / z);
} else if (t <= 5.8e-94) {
tmp = x;
} else if (t <= 5e+67) {
tmp = (x * z) / t;
} else {
tmp = y;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (t <= (-1.15d-53)) then
tmp = y
else if (t <= (-8.8d-238)) then
tmp = x
else if (t <= (-2.1d-279)) then
tmp = y / (a / z)
else if (t <= 5.8d-94) then
tmp = x
else if (t <= 5d+67) then
tmp = (x * z) / t
else
tmp = y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -1.15e-53) {
tmp = y;
} else if (t <= -8.8e-238) {
tmp = x;
} else if (t <= -2.1e-279) {
tmp = y / (a / z);
} else if (t <= 5.8e-94) {
tmp = x;
} else if (t <= 5e+67) {
tmp = (x * z) / t;
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -1.15e-53: tmp = y elif t <= -8.8e-238: tmp = x elif t <= -2.1e-279: tmp = y / (a / z) elif t <= 5.8e-94: tmp = x elif t <= 5e+67: tmp = (x * z) / t else: tmp = y return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -1.15e-53) tmp = y; elseif (t <= -8.8e-238) tmp = x; elseif (t <= -2.1e-279) tmp = Float64(y / Float64(a / z)); elseif (t <= 5.8e-94) tmp = x; elseif (t <= 5e+67) tmp = Float64(Float64(x * z) / t); else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -1.15e-53) tmp = y; elseif (t <= -8.8e-238) tmp = x; elseif (t <= -2.1e-279) tmp = y / (a / z); elseif (t <= 5.8e-94) tmp = x; elseif (t <= 5e+67) tmp = (x * z) / t; else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -1.15e-53], y, If[LessEqual[t, -8.8e-238], x, If[LessEqual[t, -2.1e-279], N[(y / N[(a / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.8e-94], x, If[LessEqual[t, 5e+67], N[(N[(x * z), $MachinePrecision] / t), $MachinePrecision], y]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.15 \cdot 10^{-53}:\\
\;\;\;\;y\\
\mathbf{elif}\;t \leq -8.8 \cdot 10^{-238}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq -2.1 \cdot 10^{-279}:\\
\;\;\;\;\frac{y}{\frac{a}{z}}\\
\mathbf{elif}\;t \leq 5.8 \cdot 10^{-94}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 5 \cdot 10^{+67}:\\
\;\;\;\;\frac{x \cdot z}{t}\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -1.1500000000000001e-53 or 4.99999999999999976e67 < t Initial program 45.1%
associate-*l/66.1%
Simplified66.1%
Taylor expanded in t around inf 40.6%
if -1.1500000000000001e-53 < t < -8.79999999999999965e-238 or -2.10000000000000006e-279 < t < 5.79999999999999991e-94Initial program 90.8%
associate-*l/95.9%
Simplified95.9%
Taylor expanded in a around inf 47.4%
if -8.79999999999999965e-238 < t < -2.10000000000000006e-279Initial program 91.2%
associate-*l/91.0%
Simplified91.0%
Taylor expanded in x around 0 48.1%
Taylor expanded in t around 0 48.1%
associate-/l*56.5%
Simplified56.5%
if 5.79999999999999991e-94 < t < 4.99999999999999976e67Initial program 84.0%
associate-*l/86.4%
Simplified86.4%
Taylor expanded in x around -inf 57.4%
mul-1-neg57.4%
*-commutative57.4%
distribute-rgt-neg-in57.4%
associate--r+50.5%
sub-neg50.5%
metadata-eval50.5%
Simplified50.5%
Taylor expanded in a around 0 35.1%
Final simplification42.8%
(FPCore (x y z t a)
:precision binary64
(if (<= t -1.15e-53)
(* y (+ (/ a t) 1.0))
(if (<= t -7.2e-240)
x
(if (<= t -1.45e-282)
(/ y (/ a z))
(if (<= t 2.95e-92) x (if (<= t 1.45e+66) (/ (* x z) t) y))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -1.15e-53) {
tmp = y * ((a / t) + 1.0);
} else if (t <= -7.2e-240) {
tmp = x;
} else if (t <= -1.45e-282) {
tmp = y / (a / z);
} else if (t <= 2.95e-92) {
tmp = x;
} else if (t <= 1.45e+66) {
tmp = (x * z) / t;
} else {
tmp = y;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (t <= (-1.15d-53)) then
tmp = y * ((a / t) + 1.0d0)
else if (t <= (-7.2d-240)) then
tmp = x
else if (t <= (-1.45d-282)) then
tmp = y / (a / z)
else if (t <= 2.95d-92) then
tmp = x
else if (t <= 1.45d+66) then
tmp = (x * z) / t
else
tmp = y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -1.15e-53) {
tmp = y * ((a / t) + 1.0);
} else if (t <= -7.2e-240) {
tmp = x;
} else if (t <= -1.45e-282) {
tmp = y / (a / z);
} else if (t <= 2.95e-92) {
tmp = x;
} else if (t <= 1.45e+66) {
tmp = (x * z) / t;
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -1.15e-53: tmp = y * ((a / t) + 1.0) elif t <= -7.2e-240: tmp = x elif t <= -1.45e-282: tmp = y / (a / z) elif t <= 2.95e-92: tmp = x elif t <= 1.45e+66: tmp = (x * z) / t else: tmp = y return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -1.15e-53) tmp = Float64(y * Float64(Float64(a / t) + 1.0)); elseif (t <= -7.2e-240) tmp = x; elseif (t <= -1.45e-282) tmp = Float64(y / Float64(a / z)); elseif (t <= 2.95e-92) tmp = x; elseif (t <= 1.45e+66) tmp = Float64(Float64(x * z) / t); else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -1.15e-53) tmp = y * ((a / t) + 1.0); elseif (t <= -7.2e-240) tmp = x; elseif (t <= -1.45e-282) tmp = y / (a / z); elseif (t <= 2.95e-92) tmp = x; elseif (t <= 1.45e+66) tmp = (x * z) / t; else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -1.15e-53], N[(y * N[(N[(a / t), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -7.2e-240], x, If[LessEqual[t, -1.45e-282], N[(y / N[(a / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.95e-92], x, If[LessEqual[t, 1.45e+66], N[(N[(x * z), $MachinePrecision] / t), $MachinePrecision], y]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.15 \cdot 10^{-53}:\\
\;\;\;\;y \cdot \left(\frac{a}{t} + 1\right)\\
\mathbf{elif}\;t \leq -7.2 \cdot 10^{-240}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq -1.45 \cdot 10^{-282}:\\
\;\;\;\;\frac{y}{\frac{a}{z}}\\
\mathbf{elif}\;t \leq 2.95 \cdot 10^{-92}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 1.45 \cdot 10^{+66}:\\
\;\;\;\;\frac{x \cdot z}{t}\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -1.1500000000000001e-53Initial program 53.7%
associate-*l/70.4%
Simplified70.4%
Taylor expanded in t around inf 66.8%
associate--l+66.8%
associate-*r/66.8%
associate-*r/66.8%
div-sub66.8%
distribute-lft-out--66.8%
associate-*r/66.8%
mul-1-neg66.8%
unsub-neg66.8%
distribute-rgt-out--67.0%
associate-/l*78.9%
Simplified78.9%
Taylor expanded in z around 0 43.7%
associate-*r/43.7%
neg-mul-143.7%
Simplified43.7%
Taylor expanded in y around inf 36.1%
sub-neg36.1%
mul-1-neg36.1%
remove-double-neg36.1%
Simplified36.1%
if -1.1500000000000001e-53 < t < -7.1999999999999998e-240 or -1.44999999999999999e-282 < t < 2.95e-92Initial program 90.8%
associate-*l/95.9%
Simplified95.9%
Taylor expanded in a around inf 47.4%
if -7.1999999999999998e-240 < t < -1.44999999999999999e-282Initial program 91.2%
associate-*l/91.0%
Simplified91.0%
Taylor expanded in x around 0 48.1%
Taylor expanded in t around 0 48.1%
associate-/l*56.5%
Simplified56.5%
if 2.95e-92 < t < 1.44999999999999993e66Initial program 84.0%
associate-*l/86.4%
Simplified86.4%
Taylor expanded in x around -inf 57.4%
mul-1-neg57.4%
*-commutative57.4%
distribute-rgt-neg-in57.4%
associate--r+50.5%
sub-neg50.5%
metadata-eval50.5%
Simplified50.5%
Taylor expanded in a around 0 35.1%
if 1.44999999999999993e66 < t Initial program 30.3%
associate-*l/58.8%
Simplified58.8%
Taylor expanded in t around inf 49.8%
Final simplification43.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (/ (- z t) (- a t)))))
(if (<= y -3.55e-50)
t_1
(if (<= y -6e-211)
(/ x (/ t (- z a)))
(if (<= y 8.2e-145) (/ (* x (- z)) (- a t)) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((z - t) / (a - t));
double tmp;
if (y <= -3.55e-50) {
tmp = t_1;
} else if (y <= -6e-211) {
tmp = x / (t / (z - a));
} else if (y <= 8.2e-145) {
tmp = (x * -z) / (a - t);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = y * ((z - t) / (a - t))
if (y <= (-3.55d-50)) then
tmp = t_1
else if (y <= (-6d-211)) then
tmp = x / (t / (z - a))
else if (y <= 8.2d-145) then
tmp = (x * -z) / (a - t)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((z - t) / (a - t));
double tmp;
if (y <= -3.55e-50) {
tmp = t_1;
} else if (y <= -6e-211) {
tmp = x / (t / (z - a));
} else if (y <= 8.2e-145) {
tmp = (x * -z) / (a - t);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * ((z - t) / (a - t)) tmp = 0 if y <= -3.55e-50: tmp = t_1 elif y <= -6e-211: tmp = x / (t / (z - a)) elif y <= 8.2e-145: tmp = (x * -z) / (a - t) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(Float64(z - t) / Float64(a - t))) tmp = 0.0 if (y <= -3.55e-50) tmp = t_1; elseif (y <= -6e-211) tmp = Float64(x / Float64(t / Float64(z - a))); elseif (y <= 8.2e-145) tmp = Float64(Float64(x * Float64(-z)) / Float64(a - t)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * ((z - t) / (a - t)); tmp = 0.0; if (y <= -3.55e-50) tmp = t_1; elseif (y <= -6e-211) tmp = x / (t / (z - a)); elseif (y <= 8.2e-145) tmp = (x * -z) / (a - t); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -3.55e-50], t$95$1, If[LessEqual[y, -6e-211], N[(x / N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 8.2e-145], N[(N[(x * (-z)), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \frac{z - t}{a - t}\\
\mathbf{if}\;y \leq -3.55 \cdot 10^{-50}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -6 \cdot 10^{-211}:\\
\;\;\;\;\frac{x}{\frac{t}{z - a}}\\
\mathbf{elif}\;y \leq 8.2 \cdot 10^{-145}:\\
\;\;\;\;\frac{x \cdot \left(-z\right)}{a - t}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if y < -3.5499999999999999e-50 or 8.1999999999999995e-145 < y Initial program 67.1%
associate-*l/86.4%
Simplified86.4%
Taylor expanded in x around 0 51.3%
associate-/l*66.3%
div-inv66.3%
clear-num66.4%
Applied egg-rr66.4%
if -3.5499999999999999e-50 < y < -6.00000000000000009e-211Initial program 63.7%
associate-*l/64.6%
Simplified64.6%
Taylor expanded in x around -inf 61.2%
mul-1-neg61.2%
*-commutative61.2%
distribute-rgt-neg-in61.2%
associate--r+47.5%
sub-neg47.5%
metadata-eval47.5%
Simplified47.5%
Taylor expanded in t around -inf 43.7%
associate-/l*47.1%
Simplified47.1%
if -6.00000000000000009e-211 < y < 8.1999999999999995e-145Initial program 80.9%
+-commutative80.9%
associate-*l/76.3%
fma-def76.3%
Simplified76.3%
fma-udef76.3%
associate-/r/79.7%
div-inv79.6%
clear-num79.7%
Applied egg-rr79.7%
clear-num79.6%
un-div-inv79.7%
Applied egg-rr79.7%
Taylor expanded in z around -inf 50.3%
associate-/l*45.9%
Simplified45.9%
Taylor expanded in y around 0 48.9%
associate-*r/48.9%
mul-1-neg48.9%
Simplified48.9%
Final simplification59.8%
(FPCore (x y z t a) :precision binary64 (if (or (<= t -1.55e+71) (not (<= t 8.5e+91))) (+ y (/ (- x y) (/ t (- z a)))) (+ x (* (- z t) (/ (- y x) (- a t))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((t <= -1.55e+71) || !(t <= 8.5e+91)) {
tmp = y + ((x - y) / (t / (z - a)));
} else {
tmp = x + ((z - t) * ((y - x) / (a - t)));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((t <= (-1.55d+71)) .or. (.not. (t <= 8.5d+91))) then
tmp = y + ((x - y) / (t / (z - a)))
else
tmp = x + ((z - t) * ((y - x) / (a - t)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((t <= -1.55e+71) || !(t <= 8.5e+91)) {
tmp = y + ((x - y) / (t / (z - a)));
} else {
tmp = x + ((z - t) * ((y - x) / (a - t)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (t <= -1.55e+71) or not (t <= 8.5e+91): tmp = y + ((x - y) / (t / (z - a))) else: tmp = x + ((z - t) * ((y - x) / (a - t))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((t <= -1.55e+71) || !(t <= 8.5e+91)) tmp = Float64(y + Float64(Float64(x - y) / Float64(t / Float64(z - a)))); else tmp = Float64(x + Float64(Float64(z - t) * Float64(Float64(y - x) / Float64(a - t)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((t <= -1.55e+71) || ~((t <= 8.5e+91))) tmp = y + ((x - y) / (t / (z - a))); else tmp = x + ((z - t) * ((y - x) / (a - t))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[t, -1.55e+71], N[Not[LessEqual[t, 8.5e+91]], $MachinePrecision]], N[(y + N[(N[(x - y), $MachinePrecision] / N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(z - t), $MachinePrecision] * N[(N[(y - x), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.55 \cdot 10^{+71} \lor \neg \left(t \leq 8.5 \cdot 10^{+91}\right):\\
\;\;\;\;y + \frac{x - y}{\frac{t}{z - a}}\\
\mathbf{else}:\\
\;\;\;\;x + \left(z - t\right) \cdot \frac{y - x}{a - t}\\
\end{array}
\end{array}
if t < -1.55000000000000009e71 or 8.4999999999999995e91 < t Initial program 33.5%
associate-*l/58.8%
Simplified58.8%
Taylor expanded in t around inf 69.7%
associate--l+69.7%
associate-*r/69.7%
associate-*r/69.7%
div-sub69.7%
distribute-lft-out--69.7%
associate-*r/69.7%
mul-1-neg69.7%
unsub-neg69.7%
distribute-rgt-out--71.0%
associate-/l*87.6%
Simplified87.6%
if -1.55000000000000009e71 < t < 8.4999999999999995e91Initial program 86.3%
associate-*l/91.3%
Simplified91.3%
Final simplification90.2%
(FPCore (x y z t a) :precision binary64 (if (or (<= t -2.1e+71) (not (<= t 1.75e+86))) (+ y (/ (- x y) (/ t (- z a)))) (+ x (/ (- y x) (/ (- a t) (- z t))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((t <= -2.1e+71) || !(t <= 1.75e+86)) {
tmp = y + ((x - y) / (t / (z - a)));
} else {
tmp = x + ((y - x) / ((a - t) / (z - t)));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((t <= (-2.1d+71)) .or. (.not. (t <= 1.75d+86))) then
tmp = y + ((x - y) / (t / (z - a)))
else
tmp = x + ((y - x) / ((a - t) / (z - t)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((t <= -2.1e+71) || !(t <= 1.75e+86)) {
tmp = y + ((x - y) / (t / (z - a)));
} else {
tmp = x + ((y - x) / ((a - t) / (z - t)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (t <= -2.1e+71) or not (t <= 1.75e+86): tmp = y + ((x - y) / (t / (z - a))) else: tmp = x + ((y - x) / ((a - t) / (z - t))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((t <= -2.1e+71) || !(t <= 1.75e+86)) tmp = Float64(y + Float64(Float64(x - y) / Float64(t / Float64(z - a)))); else tmp = Float64(x + Float64(Float64(y - x) / Float64(Float64(a - t) / Float64(z - t)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((t <= -2.1e+71) || ~((t <= 1.75e+86))) tmp = y + ((x - y) / (t / (z - a))); else tmp = x + ((y - x) / ((a - t) / (z - t))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[t, -2.1e+71], N[Not[LessEqual[t, 1.75e+86]], $MachinePrecision]], N[(y + N[(N[(x - y), $MachinePrecision] / N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(y - x), $MachinePrecision] / N[(N[(a - t), $MachinePrecision] / N[(z - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -2.1 \cdot 10^{+71} \lor \neg \left(t \leq 1.75 \cdot 10^{+86}\right):\\
\;\;\;\;y + \frac{x - y}{\frac{t}{z - a}}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{y - x}{\frac{a - t}{z - t}}\\
\end{array}
\end{array}
if t < -2.09999999999999989e71 or 1.75000000000000009e86 < t Initial program 33.5%
associate-*l/58.8%
Simplified58.8%
Taylor expanded in t around inf 69.7%
associate--l+69.7%
associate-*r/69.7%
associate-*r/69.7%
div-sub69.7%
distribute-lft-out--69.7%
associate-*r/69.7%
mul-1-neg69.7%
unsub-neg69.7%
distribute-rgt-out--71.0%
associate-/l*87.6%
Simplified87.6%
if -2.09999999999999989e71 < t < 1.75000000000000009e86Initial program 86.3%
associate-*l/91.3%
Simplified91.3%
associate-/r/91.4%
Applied egg-rr91.4%
Final simplification90.2%
(FPCore (x y z t a) :precision binary64 (if (or (<= t -8.6e+73) (not (<= t 6.5e+93))) (+ y (/ (- x y) (/ t (- z a)))) (+ x (* (- y x) (/ (- z t) (- a t))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((t <= -8.6e+73) || !(t <= 6.5e+93)) {
tmp = y + ((x - y) / (t / (z - a)));
} else {
tmp = x + ((y - x) * ((z - t) / (a - t)));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((t <= (-8.6d+73)) .or. (.not. (t <= 6.5d+93))) then
tmp = y + ((x - y) / (t / (z - a)))
else
tmp = x + ((y - x) * ((z - t) / (a - t)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((t <= -8.6e+73) || !(t <= 6.5e+93)) {
tmp = y + ((x - y) / (t / (z - a)));
} else {
tmp = x + ((y - x) * ((z - t) / (a - t)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (t <= -8.6e+73) or not (t <= 6.5e+93): tmp = y + ((x - y) / (t / (z - a))) else: tmp = x + ((y - x) * ((z - t) / (a - t))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((t <= -8.6e+73) || !(t <= 6.5e+93)) tmp = Float64(y + Float64(Float64(x - y) / Float64(t / Float64(z - a)))); else tmp = Float64(x + Float64(Float64(y - x) * Float64(Float64(z - t) / Float64(a - t)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((t <= -8.6e+73) || ~((t <= 6.5e+93))) tmp = y + ((x - y) / (t / (z - a))); else tmp = x + ((y - x) * ((z - t) / (a - t))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[t, -8.6e+73], N[Not[LessEqual[t, 6.5e+93]], $MachinePrecision]], N[(y + N[(N[(x - y), $MachinePrecision] / N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(y - x), $MachinePrecision] * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -8.6 \cdot 10^{+73} \lor \neg \left(t \leq 6.5 \cdot 10^{+93}\right):\\
\;\;\;\;y + \frac{x - y}{\frac{t}{z - a}}\\
\mathbf{else}:\\
\;\;\;\;x + \left(y - x\right) \cdot \frac{z - t}{a - t}\\
\end{array}
\end{array}
if t < -8.60000000000000026e73 or 6.4999999999999998e93 < t Initial program 33.5%
associate-*l/58.8%
Simplified58.8%
Taylor expanded in t around inf 69.7%
associate--l+69.7%
associate-*r/69.7%
associate-*r/69.7%
div-sub69.7%
distribute-lft-out--69.7%
associate-*r/69.7%
mul-1-neg69.7%
unsub-neg69.7%
distribute-rgt-out--71.0%
associate-/l*87.6%
Simplified87.6%
if -8.60000000000000026e73 < t < 6.4999999999999998e93Initial program 86.3%
+-commutative86.3%
associate-*l/91.3%
fma-def91.3%
Simplified91.3%
fma-udef91.3%
associate-/r/91.4%
div-inv91.4%
clear-num91.4%
Applied egg-rr91.4%
Final simplification90.2%
(FPCore (x y z t a)
:precision binary64
(if (<= t -9.5e-56)
y
(if (<= t -4.8e-239)
x
(if (<= t -2.2e-277) (* z (/ y a)) (if (<= t 5.4e+45) x y)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -9.5e-56) {
tmp = y;
} else if (t <= -4.8e-239) {
tmp = x;
} else if (t <= -2.2e-277) {
tmp = z * (y / a);
} else if (t <= 5.4e+45) {
tmp = x;
} else {
tmp = y;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (t <= (-9.5d-56)) then
tmp = y
else if (t <= (-4.8d-239)) then
tmp = x
else if (t <= (-2.2d-277)) then
tmp = z * (y / a)
else if (t <= 5.4d+45) then
tmp = x
else
tmp = y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -9.5e-56) {
tmp = y;
} else if (t <= -4.8e-239) {
tmp = x;
} else if (t <= -2.2e-277) {
tmp = z * (y / a);
} else if (t <= 5.4e+45) {
tmp = x;
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -9.5e-56: tmp = y elif t <= -4.8e-239: tmp = x elif t <= -2.2e-277: tmp = z * (y / a) elif t <= 5.4e+45: tmp = x else: tmp = y return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -9.5e-56) tmp = y; elseif (t <= -4.8e-239) tmp = x; elseif (t <= -2.2e-277) tmp = Float64(z * Float64(y / a)); elseif (t <= 5.4e+45) tmp = x; else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -9.5e-56) tmp = y; elseif (t <= -4.8e-239) tmp = x; elseif (t <= -2.2e-277) tmp = z * (y / a); elseif (t <= 5.4e+45) tmp = x; else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -9.5e-56], y, If[LessEqual[t, -4.8e-239], x, If[LessEqual[t, -2.2e-277], N[(z * N[(y / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.4e+45], x, y]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -9.5 \cdot 10^{-56}:\\
\;\;\;\;y\\
\mathbf{elif}\;t \leq -4.8 \cdot 10^{-239}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq -2.2 \cdot 10^{-277}:\\
\;\;\;\;z \cdot \frac{y}{a}\\
\mathbf{elif}\;t \leq 5.4 \cdot 10^{+45}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -9.4999999999999991e-56 or 5.39999999999999968e45 < t Initial program 46.7%
associate-*l/66.5%
Simplified66.5%
Taylor expanded in t around inf 39.2%
if -9.4999999999999991e-56 < t < -4.79999999999999985e-239 or -2.19999999999999996e-277 < t < 5.39999999999999968e45Initial program 89.5%
associate-*l/94.0%
Simplified94.0%
Taylor expanded in a around inf 40.3%
if -4.79999999999999985e-239 < t < -2.19999999999999996e-277Initial program 91.2%
associate-*l/91.0%
Simplified91.0%
Taylor expanded in x around 0 48.1%
Taylor expanded in t around 0 48.1%
associate-/l*56.5%
Simplified56.5%
associate-/r/55.9%
Applied egg-rr55.9%
Final simplification40.5%
(FPCore (x y z t a)
:precision binary64
(if (<= t -9e-54)
y
(if (<= t -1.7e-237)
x
(if (<= t -4.5e-278) (/ y (/ a z)) (if (<= t 5.5e+45) x y)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -9e-54) {
tmp = y;
} else if (t <= -1.7e-237) {
tmp = x;
} else if (t <= -4.5e-278) {
tmp = y / (a / z);
} else if (t <= 5.5e+45) {
tmp = x;
} else {
tmp = y;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (t <= (-9d-54)) then
tmp = y
else if (t <= (-1.7d-237)) then
tmp = x
else if (t <= (-4.5d-278)) then
tmp = y / (a / z)
else if (t <= 5.5d+45) then
tmp = x
else
tmp = y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -9e-54) {
tmp = y;
} else if (t <= -1.7e-237) {
tmp = x;
} else if (t <= -4.5e-278) {
tmp = y / (a / z);
} else if (t <= 5.5e+45) {
tmp = x;
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -9e-54: tmp = y elif t <= -1.7e-237: tmp = x elif t <= -4.5e-278: tmp = y / (a / z) elif t <= 5.5e+45: tmp = x else: tmp = y return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -9e-54) tmp = y; elseif (t <= -1.7e-237) tmp = x; elseif (t <= -4.5e-278) tmp = Float64(y / Float64(a / z)); elseif (t <= 5.5e+45) tmp = x; else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -9e-54) tmp = y; elseif (t <= -1.7e-237) tmp = x; elseif (t <= -4.5e-278) tmp = y / (a / z); elseif (t <= 5.5e+45) tmp = x; else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -9e-54], y, If[LessEqual[t, -1.7e-237], x, If[LessEqual[t, -4.5e-278], N[(y / N[(a / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.5e+45], x, y]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -9 \cdot 10^{-54}:\\
\;\;\;\;y\\
\mathbf{elif}\;t \leq -1.7 \cdot 10^{-237}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq -4.5 \cdot 10^{-278}:\\
\;\;\;\;\frac{y}{\frac{a}{z}}\\
\mathbf{elif}\;t \leq 5.5 \cdot 10^{+45}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -8.9999999999999997e-54 or 5.5000000000000001e45 < t Initial program 46.7%
associate-*l/66.5%
Simplified66.5%
Taylor expanded in t around inf 39.2%
if -8.9999999999999997e-54 < t < -1.7000000000000001e-237 or -4.4999999999999998e-278 < t < 5.5000000000000001e45Initial program 89.5%
associate-*l/94.0%
Simplified94.0%
Taylor expanded in a around inf 40.3%
if -1.7000000000000001e-237 < t < -4.4999999999999998e-278Initial program 91.2%
associate-*l/91.0%
Simplified91.0%
Taylor expanded in x around 0 48.1%
Taylor expanded in t around 0 48.1%
associate-/l*56.5%
Simplified56.5%
Final simplification40.5%
(FPCore (x y z t a) :precision binary64 (if (or (<= t -1.15e-53) (not (<= t 9.2e+45))) (+ y (* (- y x) (/ (- a z) t))) (+ x (* (- y x) (/ z (- a t))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((t <= -1.15e-53) || !(t <= 9.2e+45)) {
tmp = y + ((y - x) * ((a - z) / t));
} else {
tmp = x + ((y - x) * (z / (a - t)));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((t <= (-1.15d-53)) .or. (.not. (t <= 9.2d+45))) then
tmp = y + ((y - x) * ((a - z) / t))
else
tmp = x + ((y - x) * (z / (a - t)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((t <= -1.15e-53) || !(t <= 9.2e+45)) {
tmp = y + ((y - x) * ((a - z) / t));
} else {
tmp = x + ((y - x) * (z / (a - t)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (t <= -1.15e-53) or not (t <= 9.2e+45): tmp = y + ((y - x) * ((a - z) / t)) else: tmp = x + ((y - x) * (z / (a - t))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((t <= -1.15e-53) || !(t <= 9.2e+45)) tmp = Float64(y + Float64(Float64(y - x) * Float64(Float64(a - z) / t))); else tmp = Float64(x + Float64(Float64(y - x) * Float64(z / Float64(a - t)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((t <= -1.15e-53) || ~((t <= 9.2e+45))) tmp = y + ((y - x) * ((a - z) / t)); else tmp = x + ((y - x) * (z / (a - t))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[t, -1.15e-53], N[Not[LessEqual[t, 9.2e+45]], $MachinePrecision]], N[(y + N[(N[(y - x), $MachinePrecision] * N[(N[(a - z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(y - x), $MachinePrecision] * N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.15 \cdot 10^{-53} \lor \neg \left(t \leq 9.2 \cdot 10^{+45}\right):\\
\;\;\;\;y + \left(y - x\right) \cdot \frac{a - z}{t}\\
\mathbf{else}:\\
\;\;\;\;x + \left(y - x\right) \cdot \frac{z}{a - t}\\
\end{array}
\end{array}
if t < -1.1500000000000001e-53 or 9.20000000000000049e45 < t Initial program 46.7%
associate-*l/66.5%
Simplified66.5%
Taylor expanded in t around inf 68.6%
associate--l+68.6%
associate-*r/68.6%
associate-*r/68.6%
div-sub68.6%
distribute-lft-out--68.6%
associate-*r/68.6%
mul-1-neg68.6%
unsub-neg68.6%
distribute-rgt-out--69.6%
associate-/l*80.7%
Simplified80.7%
clear-num80.6%
associate-/r/80.6%
clear-num80.6%
Applied egg-rr80.6%
if -1.1500000000000001e-53 < t < 9.20000000000000049e45Initial program 89.7%
+-commutative89.7%
associate-*l/93.8%
fma-def93.8%
Simplified93.8%
fma-udef93.8%
associate-/r/93.6%
div-inv93.6%
clear-num93.7%
Applied egg-rr93.7%
Taylor expanded in z around inf 85.5%
Final simplification83.3%
(FPCore (x y z t a)
:precision binary64
(if (<= t -1.15e-53)
(+ y (* (- y x) (/ (- a z) t)))
(if (<= t 5.6e+45)
(+ x (* (- y x) (/ z (- a t))))
(+ y (/ (- x y) (/ t (- z a)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -1.15e-53) {
tmp = y + ((y - x) * ((a - z) / t));
} else if (t <= 5.6e+45) {
tmp = x + ((y - x) * (z / (a - t)));
} else {
tmp = y + ((x - y) / (t / (z - 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 (t <= (-1.15d-53)) then
tmp = y + ((y - x) * ((a - z) / t))
else if (t <= 5.6d+45) then
tmp = x + ((y - x) * (z / (a - t)))
else
tmp = y + ((x - y) / (t / (z - a)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -1.15e-53) {
tmp = y + ((y - x) * ((a - z) / t));
} else if (t <= 5.6e+45) {
tmp = x + ((y - x) * (z / (a - t)));
} else {
tmp = y + ((x - y) / (t / (z - a)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -1.15e-53: tmp = y + ((y - x) * ((a - z) / t)) elif t <= 5.6e+45: tmp = x + ((y - x) * (z / (a - t))) else: tmp = y + ((x - y) / (t / (z - a))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -1.15e-53) tmp = Float64(y + Float64(Float64(y - x) * Float64(Float64(a - z) / t))); elseif (t <= 5.6e+45) tmp = Float64(x + Float64(Float64(y - x) * Float64(z / Float64(a - t)))); else tmp = Float64(y + Float64(Float64(x - y) / Float64(t / Float64(z - a)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -1.15e-53) tmp = y + ((y - x) * ((a - z) / t)); elseif (t <= 5.6e+45) tmp = x + ((y - x) * (z / (a - t))); else tmp = y + ((x - y) / (t / (z - a))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -1.15e-53], N[(y + N[(N[(y - x), $MachinePrecision] * N[(N[(a - z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.6e+45], N[(x + N[(N[(y - x), $MachinePrecision] * N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y + N[(N[(x - y), $MachinePrecision] / N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.15 \cdot 10^{-53}:\\
\;\;\;\;y + \left(y - x\right) \cdot \frac{a - z}{t}\\
\mathbf{elif}\;t \leq 5.6 \cdot 10^{+45}:\\
\;\;\;\;x + \left(y - x\right) \cdot \frac{z}{a - t}\\
\mathbf{else}:\\
\;\;\;\;y + \frac{x - y}{\frac{t}{z - a}}\\
\end{array}
\end{array}
if t < -1.1500000000000001e-53Initial program 53.7%
associate-*l/70.4%
Simplified70.4%
Taylor expanded in t around inf 66.8%
associate--l+66.8%
associate-*r/66.8%
associate-*r/66.8%
div-sub66.8%
distribute-lft-out--66.8%
associate-*r/66.8%
mul-1-neg66.8%
unsub-neg66.8%
distribute-rgt-out--67.0%
associate-/l*78.9%
Simplified78.9%
clear-num78.8%
associate-/r/78.7%
clear-num78.9%
Applied egg-rr78.9%
if -1.1500000000000001e-53 < t < 5.5999999999999999e45Initial program 89.7%
+-commutative89.7%
associate-*l/93.8%
fma-def93.8%
Simplified93.8%
fma-udef93.8%
associate-/r/93.6%
div-inv93.6%
clear-num93.7%
Applied egg-rr93.7%
Taylor expanded in z around inf 85.5%
if 5.5999999999999999e45 < t Initial program 36.6%
associate-*l/60.8%
Simplified60.8%
Taylor expanded in t around inf 71.2%
associate--l+71.2%
associate-*r/71.2%
associate-*r/71.2%
div-sub71.2%
distribute-lft-out--71.2%
associate-*r/71.2%
mul-1-neg71.2%
unsub-neg71.2%
distribute-rgt-out--73.4%
associate-/l*83.3%
Simplified83.3%
Final simplification83.3%
(FPCore (x y z t a) :precision binary64 (if (<= t -1.15e-53) y (if (<= t 1.5e+46) x y)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -1.15e-53) {
tmp = y;
} else if (t <= 1.5e+46) {
tmp = x;
} else {
tmp = y;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (t <= (-1.15d-53)) then
tmp = y
else if (t <= 1.5d+46) then
tmp = x
else
tmp = y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -1.15e-53) {
tmp = y;
} else if (t <= 1.5e+46) {
tmp = x;
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -1.15e-53: tmp = y elif t <= 1.5e+46: tmp = x else: tmp = y return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -1.15e-53) tmp = y; elseif (t <= 1.5e+46) tmp = x; else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -1.15e-53) tmp = y; elseif (t <= 1.5e+46) tmp = x; else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -1.15e-53], y, If[LessEqual[t, 1.5e+46], x, y]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.15 \cdot 10^{-53}:\\
\;\;\;\;y\\
\mathbf{elif}\;t \leq 1.5 \cdot 10^{+46}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -1.1500000000000001e-53 or 1.50000000000000012e46 < t Initial program 46.7%
associate-*l/66.5%
Simplified66.5%
Taylor expanded in t around inf 39.2%
if -1.1500000000000001e-53 < t < 1.50000000000000012e46Initial program 89.7%
associate-*l/93.8%
Simplified93.8%
Taylor expanded in a around inf 38.0%
Final simplification38.5%
(FPCore (x y z t a) :precision binary64 x)
double code(double x, double y, double z, double t, double a) {
return x;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = x
end function
public static double code(double x, double y, double z, double t, double a) {
return x;
}
def code(x, y, z, t, a): return x
function code(x, y, z, t, a) return x end
function tmp = code(x, y, z, t, a) tmp = x; end
code[x_, y_, z_, t_, a_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 70.2%
associate-*l/81.4%
Simplified81.4%
Taylor expanded in a around inf 24.9%
Final simplification24.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* (/ (- y x) 1.0) (/ (- z t) (- a t))))))
(if (< a -1.6153062845442575e-142)
t_1
(if (< a 3.774403170083174e-182) (- y (* (/ z t) (- y x))) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (((y - x) / 1.0) * ((z - t) / (a - t)));
double tmp;
if (a < -1.6153062845442575e-142) {
tmp = t_1;
} else if (a < 3.774403170083174e-182) {
tmp = y - ((z / t) * (y - x));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x + (((y - x) / 1.0d0) * ((z - t) / (a - t)))
if (a < (-1.6153062845442575d-142)) then
tmp = t_1
else if (a < 3.774403170083174d-182) then
tmp = y - ((z / t) * (y - x))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + (((y - x) / 1.0) * ((z - t) / (a - t)));
double tmp;
if (a < -1.6153062845442575e-142) {
tmp = t_1;
} else if (a < 3.774403170083174e-182) {
tmp = y - ((z / t) * (y - x));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (((y - x) / 1.0) * ((z - t) / (a - t))) tmp = 0 if a < -1.6153062845442575e-142: tmp = t_1 elif a < 3.774403170083174e-182: tmp = y - ((z / t) * (y - x)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(Float64(y - x) / 1.0) * Float64(Float64(z - t) / Float64(a - t)))) tmp = 0.0 if (a < -1.6153062845442575e-142) tmp = t_1; elseif (a < 3.774403170083174e-182) tmp = Float64(y - Float64(Float64(z / t) * Float64(y - x))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (((y - x) / 1.0) * ((z - t) / (a - t))); tmp = 0.0; if (a < -1.6153062845442575e-142) tmp = t_1; elseif (a < 3.774403170083174e-182) tmp = y - ((z / t) * (y - x)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(N[(y - x), $MachinePrecision] / 1.0), $MachinePrecision] * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[a, -1.6153062845442575e-142], t$95$1, If[Less[a, 3.774403170083174e-182], N[(y - N[(N[(z / t), $MachinePrecision] * N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{y - x}{1} \cdot \frac{z - t}{a - t}\\
\mathbf{if}\;a < -1.6153062845442575 \cdot 10^{-142}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a < 3.774403170083174 \cdot 10^{-182}:\\
\;\;\;\;y - \frac{z}{t} \cdot \left(y - x\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
herbie shell --seed 2024018
(FPCore (x y z t a)
:name "Graphics.Rendering.Chart.Axis.Types:linMap from Chart-1.5.3"
:precision binary64
:herbie-target
(if (< a -1.6153062845442575e-142) (+ x (* (/ (- y x) 1.0) (/ (- z t) (- a t)))) (if (< a 3.774403170083174e-182) (- y (* (/ z t) (- y x))) (+ x (* (/ (- y x) 1.0) (/ (- z t) (- a t))))))
(+ x (/ (* (- y x) (- z t)) (- a t))))