
(FPCore (x y z t a) :precision binary64 (+ (/ (* 60.0 (- x y)) (- z t)) (* a 120.0)))
double code(double x, double y, double z, double t, double a) {
return ((60.0 * (x - y)) / (z - t)) + (a * 120.0);
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = ((60.0d0 * (x - y)) / (z - t)) + (a * 120.0d0)
end function
public static double code(double x, double y, double z, double t, double a) {
return ((60.0 * (x - y)) / (z - t)) + (a * 120.0);
}
def code(x, y, z, t, a): return ((60.0 * (x - y)) / (z - t)) + (a * 120.0)
function code(x, y, z, t, a) return Float64(Float64(Float64(60.0 * Float64(x - y)) / Float64(z - t)) + Float64(a * 120.0)) end
function tmp = code(x, y, z, t, a) tmp = ((60.0 * (x - y)) / (z - t)) + (a * 120.0); end
code[x_, y_, z_, t_, a_] := N[(N[(N[(60.0 * N[(x - y), $MachinePrecision]), $MachinePrecision] / N[(z - t), $MachinePrecision]), $MachinePrecision] + N[(a * 120.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{60 \cdot \left(x - y\right)}{z - t} + a \cdot 120
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 16 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (+ (/ (* 60.0 (- x y)) (- z t)) (* a 120.0)))
double code(double x, double y, double z, double t, double a) {
return ((60.0 * (x - y)) / (z - t)) + (a * 120.0);
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = ((60.0d0 * (x - y)) / (z - t)) + (a * 120.0d0)
end function
public static double code(double x, double y, double z, double t, double a) {
return ((60.0 * (x - y)) / (z - t)) + (a * 120.0);
}
def code(x, y, z, t, a): return ((60.0 * (x - y)) / (z - t)) + (a * 120.0)
function code(x, y, z, t, a) return Float64(Float64(Float64(60.0 * Float64(x - y)) / Float64(z - t)) + Float64(a * 120.0)) end
function tmp = code(x, y, z, t, a) tmp = ((60.0 * (x - y)) / (z - t)) + (a * 120.0); end
code[x_, y_, z_, t_, a_] := N[(N[(N[(60.0 * N[(x - y), $MachinePrecision]), $MachinePrecision] / N[(z - t), $MachinePrecision]), $MachinePrecision] + N[(a * 120.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{60 \cdot \left(x - y\right)}{z - t} + a \cdot 120
\end{array}
(FPCore (x y z t a) :precision binary64 (fma a 120.0 (/ (* 60.0 (- y x)) (- t z))))
double code(double x, double y, double z, double t, double a) {
return fma(a, 120.0, ((60.0 * (y - x)) / (t - z)));
}
function code(x, y, z, t, a) return fma(a, 120.0, Float64(Float64(60.0 * Float64(y - x)) / Float64(t - z))) end
code[x_, y_, z_, t_, a_] := N[(a * 120.0 + N[(N[(60.0 * N[(y - x), $MachinePrecision]), $MachinePrecision] / N[(t - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(a, 120, \frac{60 \cdot \left(y - x\right)}{t - z}\right)
\end{array}
Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
+-commutativeN/A
fma-defineN/A
fma-lowering-fma.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6499.9%
Applied egg-rr99.9%
(FPCore (x y z t a)
:precision binary64
(if (<= a -2.3e-51)
(* a 120.0)
(if (<= a -1.5e-223)
(* -60.0 (/ x (- t z)))
(if (<= a 1.46e-297)
(* -60.0 (/ (- y x) z))
(if (<= a 3.9e-148) (* 60.0 (/ (- y x) t)) (* a 120.0))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -2.3e-51) {
tmp = a * 120.0;
} else if (a <= -1.5e-223) {
tmp = -60.0 * (x / (t - z));
} else if (a <= 1.46e-297) {
tmp = -60.0 * ((y - x) / z);
} else if (a <= 3.9e-148) {
tmp = 60.0 * ((y - x) / t);
} else {
tmp = a * 120.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) :: tmp
if (a <= (-2.3d-51)) then
tmp = a * 120.0d0
else if (a <= (-1.5d-223)) then
tmp = (-60.0d0) * (x / (t - z))
else if (a <= 1.46d-297) then
tmp = (-60.0d0) * ((y - x) / z)
else if (a <= 3.9d-148) then
tmp = 60.0d0 * ((y - x) / t)
else
tmp = a * 120.0d0
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -2.3e-51) {
tmp = a * 120.0;
} else if (a <= -1.5e-223) {
tmp = -60.0 * (x / (t - z));
} else if (a <= 1.46e-297) {
tmp = -60.0 * ((y - x) / z);
} else if (a <= 3.9e-148) {
tmp = 60.0 * ((y - x) / t);
} else {
tmp = a * 120.0;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -2.3e-51: tmp = a * 120.0 elif a <= -1.5e-223: tmp = -60.0 * (x / (t - z)) elif a <= 1.46e-297: tmp = -60.0 * ((y - x) / z) elif a <= 3.9e-148: tmp = 60.0 * ((y - x) / t) else: tmp = a * 120.0 return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -2.3e-51) tmp = Float64(a * 120.0); elseif (a <= -1.5e-223) tmp = Float64(-60.0 * Float64(x / Float64(t - z))); elseif (a <= 1.46e-297) tmp = Float64(-60.0 * Float64(Float64(y - x) / z)); elseif (a <= 3.9e-148) tmp = Float64(60.0 * Float64(Float64(y - x) / t)); else tmp = Float64(a * 120.0); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -2.3e-51) tmp = a * 120.0; elseif (a <= -1.5e-223) tmp = -60.0 * (x / (t - z)); elseif (a <= 1.46e-297) tmp = -60.0 * ((y - x) / z); elseif (a <= 3.9e-148) tmp = 60.0 * ((y - x) / t); else tmp = a * 120.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -2.3e-51], N[(a * 120.0), $MachinePrecision], If[LessEqual[a, -1.5e-223], N[(-60.0 * N[(x / N[(t - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.46e-297], N[(-60.0 * N[(N[(y - x), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.9e-148], N[(60.0 * N[(N[(y - x), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], N[(a * 120.0), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -2.3 \cdot 10^{-51}:\\
\;\;\;\;a \cdot 120\\
\mathbf{elif}\;a \leq -1.5 \cdot 10^{-223}:\\
\;\;\;\;-60 \cdot \frac{x}{t - z}\\
\mathbf{elif}\;a \leq 1.46 \cdot 10^{-297}:\\
\;\;\;\;-60 \cdot \frac{y - x}{z}\\
\mathbf{elif}\;a \leq 3.9 \cdot 10^{-148}:\\
\;\;\;\;60 \cdot \frac{y - x}{t}\\
\mathbf{else}:\\
\;\;\;\;a \cdot 120\\
\end{array}
\end{array}
if a < -2.30000000000000002e-51 or 3.89999999999999994e-148 < a Initial program 99.9%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.9%
Simplified99.9%
Taylor expanded in t around inf
*-lowering-*.f6472.5%
Simplified72.5%
if -2.30000000000000002e-51 < a < -1.49999999999999996e-223Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
+-commutativeN/A
fma-defineN/A
fma-lowering-fma.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6499.8%
Applied egg-rr99.8%
Taylor expanded in x around inf
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6451.5%
Simplified51.5%
if -1.49999999999999996e-223 < a < 1.4600000000000001e-297Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in a around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6494.7%
Simplified94.7%
Taylor expanded in t around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6478.2%
Simplified78.2%
if 1.4600000000000001e-297 < a < 3.89999999999999994e-148Initial program 99.6%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.6%
Simplified99.6%
Taylor expanded in t around inf
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6468.5%
Simplified68.5%
Taylor expanded in a around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6456.8%
Simplified56.8%
Final simplification67.3%
(FPCore (x y z t a)
:precision binary64
(if (<= y -3.2e+180)
(* 60.0 (/ y (- t z)))
(if (<= y -8e-217)
(* a 120.0)
(if (<= y 2.1e+151)
(+ (* a 120.0) (* -60.0 (/ x t)))
(* y (/ 60.0 (- t z)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -3.2e+180) {
tmp = 60.0 * (y / (t - z));
} else if (y <= -8e-217) {
tmp = a * 120.0;
} else if (y <= 2.1e+151) {
tmp = (a * 120.0) + (-60.0 * (x / t));
} else {
tmp = y * (60.0 / (t - z));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (y <= (-3.2d+180)) then
tmp = 60.0d0 * (y / (t - z))
else if (y <= (-8d-217)) then
tmp = a * 120.0d0
else if (y <= 2.1d+151) then
tmp = (a * 120.0d0) + ((-60.0d0) * (x / t))
else
tmp = y * (60.0d0 / (t - z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -3.2e+180) {
tmp = 60.0 * (y / (t - z));
} else if (y <= -8e-217) {
tmp = a * 120.0;
} else if (y <= 2.1e+151) {
tmp = (a * 120.0) + (-60.0 * (x / t));
} else {
tmp = y * (60.0 / (t - z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if y <= -3.2e+180: tmp = 60.0 * (y / (t - z)) elif y <= -8e-217: tmp = a * 120.0 elif y <= 2.1e+151: tmp = (a * 120.0) + (-60.0 * (x / t)) else: tmp = y * (60.0 / (t - z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (y <= -3.2e+180) tmp = Float64(60.0 * Float64(y / Float64(t - z))); elseif (y <= -8e-217) tmp = Float64(a * 120.0); elseif (y <= 2.1e+151) tmp = Float64(Float64(a * 120.0) + Float64(-60.0 * Float64(x / t))); else tmp = Float64(y * Float64(60.0 / Float64(t - z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (y <= -3.2e+180) tmp = 60.0 * (y / (t - z)); elseif (y <= -8e-217) tmp = a * 120.0; elseif (y <= 2.1e+151) tmp = (a * 120.0) + (-60.0 * (x / t)); else tmp = y * (60.0 / (t - z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[y, -3.2e+180], N[(60.0 * N[(y / N[(t - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -8e-217], N[(a * 120.0), $MachinePrecision], If[LessEqual[y, 2.1e+151], N[(N[(a * 120.0), $MachinePrecision] + N[(-60.0 * N[(x / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * N[(60.0 / N[(t - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3.2 \cdot 10^{+180}:\\
\;\;\;\;60 \cdot \frac{y}{t - z}\\
\mathbf{elif}\;y \leq -8 \cdot 10^{-217}:\\
\;\;\;\;a \cdot 120\\
\mathbf{elif}\;y \leq 2.1 \cdot 10^{+151}:\\
\;\;\;\;a \cdot 120 + -60 \cdot \frac{x}{t}\\
\mathbf{else}:\\
\;\;\;\;y \cdot \frac{60}{t - z}\\
\end{array}
\end{array}
if y < -3.19999999999999994e180Initial program 99.9%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.9%
Simplified99.9%
Taylor expanded in y around inf
*-lft-identityN/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f64N/A
--lowering--.f6481.8%
Simplified81.8%
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
metadata-evalN/A
metadata-evalN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6481.9%
Applied egg-rr81.9%
if -3.19999999999999994e180 < y < -8.00000000000000066e-217Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in t around inf
*-lowering-*.f6468.1%
Simplified68.1%
if -8.00000000000000066e-217 < y < 2.1000000000000001e151Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in t around inf
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6468.4%
Simplified68.4%
Taylor expanded in y around 0
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6468.8%
Simplified68.8%
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6468.8%
Applied egg-rr68.8%
if 2.1000000000000001e151 < y Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in y around inf
*-lft-identityN/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f64N/A
--lowering--.f6468.8%
Simplified68.8%
Final simplification70.0%
(FPCore (x y z t a)
:precision binary64
(if (<= y -3.2e+180)
(* 60.0 (/ y (- t z)))
(if (<= y -2.6e-218)
(* a 120.0)
(if (<= y 6.8e+152)
(+ (* a 120.0) (/ (* x -60.0) t))
(* y (/ 60.0 (- t z)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -3.2e+180) {
tmp = 60.0 * (y / (t - z));
} else if (y <= -2.6e-218) {
tmp = a * 120.0;
} else if (y <= 6.8e+152) {
tmp = (a * 120.0) + ((x * -60.0) / t);
} else {
tmp = y * (60.0 / (t - z));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (y <= (-3.2d+180)) then
tmp = 60.0d0 * (y / (t - z))
else if (y <= (-2.6d-218)) then
tmp = a * 120.0d0
else if (y <= 6.8d+152) then
tmp = (a * 120.0d0) + ((x * (-60.0d0)) / t)
else
tmp = y * (60.0d0 / (t - z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -3.2e+180) {
tmp = 60.0 * (y / (t - z));
} else if (y <= -2.6e-218) {
tmp = a * 120.0;
} else if (y <= 6.8e+152) {
tmp = (a * 120.0) + ((x * -60.0) / t);
} else {
tmp = y * (60.0 / (t - z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if y <= -3.2e+180: tmp = 60.0 * (y / (t - z)) elif y <= -2.6e-218: tmp = a * 120.0 elif y <= 6.8e+152: tmp = (a * 120.0) + ((x * -60.0) / t) else: tmp = y * (60.0 / (t - z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (y <= -3.2e+180) tmp = Float64(60.0 * Float64(y / Float64(t - z))); elseif (y <= -2.6e-218) tmp = Float64(a * 120.0); elseif (y <= 6.8e+152) tmp = Float64(Float64(a * 120.0) + Float64(Float64(x * -60.0) / t)); else tmp = Float64(y * Float64(60.0 / Float64(t - z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (y <= -3.2e+180) tmp = 60.0 * (y / (t - z)); elseif (y <= -2.6e-218) tmp = a * 120.0; elseif (y <= 6.8e+152) tmp = (a * 120.0) + ((x * -60.0) / t); else tmp = y * (60.0 / (t - z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[y, -3.2e+180], N[(60.0 * N[(y / N[(t - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -2.6e-218], N[(a * 120.0), $MachinePrecision], If[LessEqual[y, 6.8e+152], N[(N[(a * 120.0), $MachinePrecision] + N[(N[(x * -60.0), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], N[(y * N[(60.0 / N[(t - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3.2 \cdot 10^{+180}:\\
\;\;\;\;60 \cdot \frac{y}{t - z}\\
\mathbf{elif}\;y \leq -2.6 \cdot 10^{-218}:\\
\;\;\;\;a \cdot 120\\
\mathbf{elif}\;y \leq 6.8 \cdot 10^{+152}:\\
\;\;\;\;a \cdot 120 + \frac{x \cdot -60}{t}\\
\mathbf{else}:\\
\;\;\;\;y \cdot \frac{60}{t - z}\\
\end{array}
\end{array}
if y < -3.19999999999999994e180Initial program 99.9%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.9%
Simplified99.9%
Taylor expanded in y around inf
*-lft-identityN/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f64N/A
--lowering--.f6481.8%
Simplified81.8%
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
metadata-evalN/A
metadata-evalN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6481.9%
Applied egg-rr81.9%
if -3.19999999999999994e180 < y < -2.59999999999999983e-218Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in t around inf
*-lowering-*.f6468.1%
Simplified68.1%
if -2.59999999999999983e-218 < y < 6.80000000000000041e152Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in t around inf
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6468.4%
Simplified68.4%
Taylor expanded in y around 0
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6468.8%
Simplified68.8%
if 6.80000000000000041e152 < y Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in y around inf
*-lft-identityN/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f64N/A
--lowering--.f6468.8%
Simplified68.8%
Final simplification70.0%
(FPCore (x y z t a) :precision binary64 (if (<= (* a 120.0) -1e+53) (* a 120.0) (if (<= (* a 120.0) 100000.0) (/ (* 60.0 (- y x)) (- t z)) (* a 120.0))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a * 120.0) <= -1e+53) {
tmp = a * 120.0;
} else if ((a * 120.0) <= 100000.0) {
tmp = (60.0 * (y - x)) / (t - z);
} else {
tmp = a * 120.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) :: tmp
if ((a * 120.0d0) <= (-1d+53)) then
tmp = a * 120.0d0
else if ((a * 120.0d0) <= 100000.0d0) then
tmp = (60.0d0 * (y - x)) / (t - z)
else
tmp = a * 120.0d0
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a * 120.0) <= -1e+53) {
tmp = a * 120.0;
} else if ((a * 120.0) <= 100000.0) {
tmp = (60.0 * (y - x)) / (t - z);
} else {
tmp = a * 120.0;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (a * 120.0) <= -1e+53: tmp = a * 120.0 elif (a * 120.0) <= 100000.0: tmp = (60.0 * (y - x)) / (t - z) else: tmp = a * 120.0 return tmp
function code(x, y, z, t, a) tmp = 0.0 if (Float64(a * 120.0) <= -1e+53) tmp = Float64(a * 120.0); elseif (Float64(a * 120.0) <= 100000.0) tmp = Float64(Float64(60.0 * Float64(y - x)) / Float64(t - z)); else tmp = Float64(a * 120.0); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((a * 120.0) <= -1e+53) tmp = a * 120.0; elseif ((a * 120.0) <= 100000.0) tmp = (60.0 * (y - x)) / (t - z); else tmp = a * 120.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[N[(a * 120.0), $MachinePrecision], -1e+53], N[(a * 120.0), $MachinePrecision], If[LessEqual[N[(a * 120.0), $MachinePrecision], 100000.0], N[(N[(60.0 * N[(y - x), $MachinePrecision]), $MachinePrecision] / N[(t - z), $MachinePrecision]), $MachinePrecision], N[(a * 120.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \cdot 120 \leq -1 \cdot 10^{+53}:\\
\;\;\;\;a \cdot 120\\
\mathbf{elif}\;a \cdot 120 \leq 100000:\\
\;\;\;\;\frac{60 \cdot \left(y - x\right)}{t - z}\\
\mathbf{else}:\\
\;\;\;\;a \cdot 120\\
\end{array}
\end{array}
if (*.f64 a #s(literal 120 binary64)) < -9.9999999999999999e52 or 1e5 < (*.f64 a #s(literal 120 binary64)) Initial program 99.9%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.9%
Simplified99.9%
Taylor expanded in t around inf
*-lowering-*.f6483.5%
Simplified83.5%
if -9.9999999999999999e52 < (*.f64 a #s(literal 120 binary64)) < 1e5Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in a around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6474.7%
Simplified74.7%
Final simplification78.6%
(FPCore (x y z t a)
:precision binary64
(if (<= a -1.22e-62)
(* a 120.0)
(if (<= a -3.7e-227)
(* -60.0 (/ x (- t z)))
(if (<= a 1.1e-147) (* y (/ 60.0 (- t z))) (* a 120.0)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -1.22e-62) {
tmp = a * 120.0;
} else if (a <= -3.7e-227) {
tmp = -60.0 * (x / (t - z));
} else if (a <= 1.1e-147) {
tmp = y * (60.0 / (t - z));
} else {
tmp = a * 120.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) :: tmp
if (a <= (-1.22d-62)) then
tmp = a * 120.0d0
else if (a <= (-3.7d-227)) then
tmp = (-60.0d0) * (x / (t - z))
else if (a <= 1.1d-147) then
tmp = y * (60.0d0 / (t - z))
else
tmp = a * 120.0d0
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -1.22e-62) {
tmp = a * 120.0;
} else if (a <= -3.7e-227) {
tmp = -60.0 * (x / (t - z));
} else if (a <= 1.1e-147) {
tmp = y * (60.0 / (t - z));
} else {
tmp = a * 120.0;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -1.22e-62: tmp = a * 120.0 elif a <= -3.7e-227: tmp = -60.0 * (x / (t - z)) elif a <= 1.1e-147: tmp = y * (60.0 / (t - z)) else: tmp = a * 120.0 return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -1.22e-62) tmp = Float64(a * 120.0); elseif (a <= -3.7e-227) tmp = Float64(-60.0 * Float64(x / Float64(t - z))); elseif (a <= 1.1e-147) tmp = Float64(y * Float64(60.0 / Float64(t - z))); else tmp = Float64(a * 120.0); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -1.22e-62) tmp = a * 120.0; elseif (a <= -3.7e-227) tmp = -60.0 * (x / (t - z)); elseif (a <= 1.1e-147) tmp = y * (60.0 / (t - z)); else tmp = a * 120.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -1.22e-62], N[(a * 120.0), $MachinePrecision], If[LessEqual[a, -3.7e-227], N[(-60.0 * N[(x / N[(t - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.1e-147], N[(y * N[(60.0 / N[(t - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(a * 120.0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.22 \cdot 10^{-62}:\\
\;\;\;\;a \cdot 120\\
\mathbf{elif}\;a \leq -3.7 \cdot 10^{-227}:\\
\;\;\;\;-60 \cdot \frac{x}{t - z}\\
\mathbf{elif}\;a \leq 1.1 \cdot 10^{-147}:\\
\;\;\;\;y \cdot \frac{60}{t - z}\\
\mathbf{else}:\\
\;\;\;\;a \cdot 120\\
\end{array}
\end{array}
if a < -1.2199999999999999e-62 or 1.1000000000000001e-147 < a Initial program 99.9%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.9%
Simplified99.9%
Taylor expanded in t around inf
*-lowering-*.f6472.5%
Simplified72.5%
if -1.2199999999999999e-62 < a < -3.69999999999999978e-227Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
+-commutativeN/A
fma-defineN/A
fma-lowering-fma.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6499.8%
Applied egg-rr99.8%
Taylor expanded in x around inf
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6451.5%
Simplified51.5%
if -3.69999999999999978e-227 < a < 1.1000000000000001e-147Initial program 99.7%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.7%
Simplified99.7%
Taylor expanded in y around inf
*-lft-identityN/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f64N/A
--lowering--.f6462.8%
Simplified62.8%
Final simplification66.8%
(FPCore (x y z t a)
:precision binary64
(if (<= a -3e-58)
(* a 120.0)
(if (<= a -1.25e-220)
(* -60.0 (/ x (- t z)))
(if (<= a 2.2e-175) (* -60.0 (/ (- y x) z)) (* a 120.0)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -3e-58) {
tmp = a * 120.0;
} else if (a <= -1.25e-220) {
tmp = -60.0 * (x / (t - z));
} else if (a <= 2.2e-175) {
tmp = -60.0 * ((y - x) / z);
} else {
tmp = a * 120.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) :: tmp
if (a <= (-3d-58)) then
tmp = a * 120.0d0
else if (a <= (-1.25d-220)) then
tmp = (-60.0d0) * (x / (t - z))
else if (a <= 2.2d-175) then
tmp = (-60.0d0) * ((y - x) / z)
else
tmp = a * 120.0d0
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -3e-58) {
tmp = a * 120.0;
} else if (a <= -1.25e-220) {
tmp = -60.0 * (x / (t - z));
} else if (a <= 2.2e-175) {
tmp = -60.0 * ((y - x) / z);
} else {
tmp = a * 120.0;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -3e-58: tmp = a * 120.0 elif a <= -1.25e-220: tmp = -60.0 * (x / (t - z)) elif a <= 2.2e-175: tmp = -60.0 * ((y - x) / z) else: tmp = a * 120.0 return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -3e-58) tmp = Float64(a * 120.0); elseif (a <= -1.25e-220) tmp = Float64(-60.0 * Float64(x / Float64(t - z))); elseif (a <= 2.2e-175) tmp = Float64(-60.0 * Float64(Float64(y - x) / z)); else tmp = Float64(a * 120.0); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -3e-58) tmp = a * 120.0; elseif (a <= -1.25e-220) tmp = -60.0 * (x / (t - z)); elseif (a <= 2.2e-175) tmp = -60.0 * ((y - x) / z); else tmp = a * 120.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -3e-58], N[(a * 120.0), $MachinePrecision], If[LessEqual[a, -1.25e-220], N[(-60.0 * N[(x / N[(t - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.2e-175], N[(-60.0 * N[(N[(y - x), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], N[(a * 120.0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -3 \cdot 10^{-58}:\\
\;\;\;\;a \cdot 120\\
\mathbf{elif}\;a \leq -1.25 \cdot 10^{-220}:\\
\;\;\;\;-60 \cdot \frac{x}{t - z}\\
\mathbf{elif}\;a \leq 2.2 \cdot 10^{-175}:\\
\;\;\;\;-60 \cdot \frac{y - x}{z}\\
\mathbf{else}:\\
\;\;\;\;a \cdot 120\\
\end{array}
\end{array}
if a < -3.00000000000000008e-58 or 2.2e-175 < a Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in t around inf
*-lowering-*.f6470.0%
Simplified70.0%
if -3.00000000000000008e-58 < a < -1.25e-220Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
+-commutativeN/A
fma-defineN/A
fma-lowering-fma.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6499.8%
Applied egg-rr99.8%
Taylor expanded in x around inf
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6451.5%
Simplified51.5%
if -1.25e-220 < a < 2.2e-175Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in a around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6493.4%
Simplified93.4%
Taylor expanded in t around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6460.2%
Simplified60.2%
Final simplification65.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ (/ (* (- y x) -60.0) z) (* a 120.0))))
(if (<= z -205000000.0)
t_1
(if (<= z 2.1e-20) (+ (* a 120.0) (* 60.0 (/ (- y x) t))) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (((y - x) * -60.0) / z) + (a * 120.0);
double tmp;
if (z <= -205000000.0) {
tmp = t_1;
} else if (z <= 2.1e-20) {
tmp = (a * 120.0) + (60.0 * ((y - x) / 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 - x) * (-60.0d0)) / z) + (a * 120.0d0)
if (z <= (-205000000.0d0)) then
tmp = t_1
else if (z <= 2.1d-20) then
tmp = (a * 120.0d0) + (60.0d0 * ((y - x) / 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 - x) * -60.0) / z) + (a * 120.0);
double tmp;
if (z <= -205000000.0) {
tmp = t_1;
} else if (z <= 2.1e-20) {
tmp = (a * 120.0) + (60.0 * ((y - x) / t));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (((y - x) * -60.0) / z) + (a * 120.0) tmp = 0 if z <= -205000000.0: tmp = t_1 elif z <= 2.1e-20: tmp = (a * 120.0) + (60.0 * ((y - x) / t)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(Float64(Float64(y - x) * -60.0) / z) + Float64(a * 120.0)) tmp = 0.0 if (z <= -205000000.0) tmp = t_1; elseif (z <= 2.1e-20) tmp = Float64(Float64(a * 120.0) + Float64(60.0 * Float64(Float64(y - x) / t))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (((y - x) * -60.0) / z) + (a * 120.0); tmp = 0.0; if (z <= -205000000.0) tmp = t_1; elseif (z <= 2.1e-20) tmp = (a * 120.0) + (60.0 * ((y - x) / t)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(N[(N[(y - x), $MachinePrecision] * -60.0), $MachinePrecision] / z), $MachinePrecision] + N[(a * 120.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -205000000.0], t$95$1, If[LessEqual[z, 2.1e-20], N[(N[(a * 120.0), $MachinePrecision] + N[(60.0 * N[(N[(y - x), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\left(y - x\right) \cdot -60}{z} + a \cdot 120\\
\mathbf{if}\;z \leq -205000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 2.1 \cdot 10^{-20}:\\
\;\;\;\;a \cdot 120 + 60 \cdot \frac{y - x}{t}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -2.05e8 or 2.0999999999999999e-20 < z Initial program 99.9%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.9%
Simplified99.9%
Taylor expanded in t around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f6488.6%
Simplified88.6%
if -2.05e8 < z < 2.0999999999999999e-20Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in t around inf
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6483.5%
Simplified83.5%
Final simplification86.1%
(FPCore (x y z t a)
:precision binary64
(if (<= a -5e-65)
(* a 120.0)
(if (<= a 1.35e-300)
(* -60.0 (/ x (- t z)))
(if (<= a 2.9e-148) (* y (/ 60.0 t)) (* a 120.0)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -5e-65) {
tmp = a * 120.0;
} else if (a <= 1.35e-300) {
tmp = -60.0 * (x / (t - z));
} else if (a <= 2.9e-148) {
tmp = y * (60.0 / t);
} else {
tmp = a * 120.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) :: tmp
if (a <= (-5d-65)) then
tmp = a * 120.0d0
else if (a <= 1.35d-300) then
tmp = (-60.0d0) * (x / (t - z))
else if (a <= 2.9d-148) then
tmp = y * (60.0d0 / t)
else
tmp = a * 120.0d0
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -5e-65) {
tmp = a * 120.0;
} else if (a <= 1.35e-300) {
tmp = -60.0 * (x / (t - z));
} else if (a <= 2.9e-148) {
tmp = y * (60.0 / t);
} else {
tmp = a * 120.0;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -5e-65: tmp = a * 120.0 elif a <= 1.35e-300: tmp = -60.0 * (x / (t - z)) elif a <= 2.9e-148: tmp = y * (60.0 / t) else: tmp = a * 120.0 return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -5e-65) tmp = Float64(a * 120.0); elseif (a <= 1.35e-300) tmp = Float64(-60.0 * Float64(x / Float64(t - z))); elseif (a <= 2.9e-148) tmp = Float64(y * Float64(60.0 / t)); else tmp = Float64(a * 120.0); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -5e-65) tmp = a * 120.0; elseif (a <= 1.35e-300) tmp = -60.0 * (x / (t - z)); elseif (a <= 2.9e-148) tmp = y * (60.0 / t); else tmp = a * 120.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -5e-65], N[(a * 120.0), $MachinePrecision], If[LessEqual[a, 1.35e-300], N[(-60.0 * N[(x / N[(t - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.9e-148], N[(y * N[(60.0 / t), $MachinePrecision]), $MachinePrecision], N[(a * 120.0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -5 \cdot 10^{-65}:\\
\;\;\;\;a \cdot 120\\
\mathbf{elif}\;a \leq 1.35 \cdot 10^{-300}:\\
\;\;\;\;-60 \cdot \frac{x}{t - z}\\
\mathbf{elif}\;a \leq 2.9 \cdot 10^{-148}:\\
\;\;\;\;y \cdot \frac{60}{t}\\
\mathbf{else}:\\
\;\;\;\;a \cdot 120\\
\end{array}
\end{array}
if a < -4.99999999999999983e-65 or 2.8999999999999998e-148 < a Initial program 99.9%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.9%
Simplified99.9%
Taylor expanded in t around inf
*-lowering-*.f6472.5%
Simplified72.5%
if -4.99999999999999983e-65 < a < 1.34999999999999998e-300Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
+-commutativeN/A
fma-defineN/A
fma-lowering-fma.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6499.8%
Applied egg-rr99.8%
Taylor expanded in x around inf
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6447.7%
Simplified47.7%
if 1.34999999999999998e-300 < a < 2.8999999999999998e-148Initial program 99.6%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.6%
Simplified99.6%
Taylor expanded in y around inf
*-lft-identityN/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f64N/A
--lowering--.f6464.1%
Simplified64.1%
Taylor expanded in t around inf
/-lowering-/.f6441.5%
Simplified41.5%
Final simplification62.2%
(FPCore (x y z t a)
:precision binary64
(if (<= y -1.6e+243)
(* -60.0 (/ y z))
(if (<= y -4.8e+180)
(* 60.0 (/ y t))
(if (<= y 1.95e+158) (* a 120.0) (/ y (/ z -60.0))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -1.6e+243) {
tmp = -60.0 * (y / z);
} else if (y <= -4.8e+180) {
tmp = 60.0 * (y / t);
} else if (y <= 1.95e+158) {
tmp = a * 120.0;
} else {
tmp = y / (z / -60.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) :: tmp
if (y <= (-1.6d+243)) then
tmp = (-60.0d0) * (y / z)
else if (y <= (-4.8d+180)) then
tmp = 60.0d0 * (y / t)
else if (y <= 1.95d+158) then
tmp = a * 120.0d0
else
tmp = y / (z / (-60.0d0))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -1.6e+243) {
tmp = -60.0 * (y / z);
} else if (y <= -4.8e+180) {
tmp = 60.0 * (y / t);
} else if (y <= 1.95e+158) {
tmp = a * 120.0;
} else {
tmp = y / (z / -60.0);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if y <= -1.6e+243: tmp = -60.0 * (y / z) elif y <= -4.8e+180: tmp = 60.0 * (y / t) elif y <= 1.95e+158: tmp = a * 120.0 else: tmp = y / (z / -60.0) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (y <= -1.6e+243) tmp = Float64(-60.0 * Float64(y / z)); elseif (y <= -4.8e+180) tmp = Float64(60.0 * Float64(y / t)); elseif (y <= 1.95e+158) tmp = Float64(a * 120.0); else tmp = Float64(y / Float64(z / -60.0)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (y <= -1.6e+243) tmp = -60.0 * (y / z); elseif (y <= -4.8e+180) tmp = 60.0 * (y / t); elseif (y <= 1.95e+158) tmp = a * 120.0; else tmp = y / (z / -60.0); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[y, -1.6e+243], N[(-60.0 * N[(y / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -4.8e+180], N[(60.0 * N[(y / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.95e+158], N[(a * 120.0), $MachinePrecision], N[(y / N[(z / -60.0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.6 \cdot 10^{+243}:\\
\;\;\;\;-60 \cdot \frac{y}{z}\\
\mathbf{elif}\;y \leq -4.8 \cdot 10^{+180}:\\
\;\;\;\;60 \cdot \frac{y}{t}\\
\mathbf{elif}\;y \leq 1.95 \cdot 10^{+158}:\\
\;\;\;\;a \cdot 120\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{\frac{z}{-60}}\\
\end{array}
\end{array}
if y < -1.60000000000000008e243Initial program 100.0%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in y around inf
*-lft-identityN/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f64N/A
--lowering--.f6475.1%
Simplified75.1%
Taylor expanded in t around 0
/-lowering-/.f6460.2%
Simplified60.2%
associate-*r/N/A
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6460.2%
Applied egg-rr60.2%
if -1.60000000000000008e243 < y < -4.7999999999999997e180Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in y around inf
*-lft-identityN/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f64N/A
--lowering--.f6487.1%
Simplified87.1%
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
metadata-evalN/A
metadata-evalN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6487.3%
Applied egg-rr87.3%
Taylor expanded in t around inf
/-lowering-/.f6475.1%
Simplified75.1%
if -4.7999999999999997e180 < y < 1.95e158Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in t around inf
*-lowering-*.f6460.6%
Simplified60.6%
if 1.95e158 < y Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in y around inf
*-lft-identityN/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f64N/A
--lowering--.f6468.8%
Simplified68.8%
Taylor expanded in t around 0
/-lowering-/.f6446.8%
Simplified46.8%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6446.9%
Applied egg-rr46.9%
Final simplification59.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* -60.0 (/ y z))))
(if (<= y -1.7e+245)
t_1
(if (<= y -5.8e+180)
(* 60.0 (/ y t))
(if (<= y 1.1e+154) (* a 120.0) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = -60.0 * (y / z);
double tmp;
if (y <= -1.7e+245) {
tmp = t_1;
} else if (y <= -5.8e+180) {
tmp = 60.0 * (y / t);
} else if (y <= 1.1e+154) {
tmp = a * 120.0;
} 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 = (-60.0d0) * (y / z)
if (y <= (-1.7d+245)) then
tmp = t_1
else if (y <= (-5.8d+180)) then
tmp = 60.0d0 * (y / t)
else if (y <= 1.1d+154) then
tmp = a * 120.0d0
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 = -60.0 * (y / z);
double tmp;
if (y <= -1.7e+245) {
tmp = t_1;
} else if (y <= -5.8e+180) {
tmp = 60.0 * (y / t);
} else if (y <= 1.1e+154) {
tmp = a * 120.0;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = -60.0 * (y / z) tmp = 0 if y <= -1.7e+245: tmp = t_1 elif y <= -5.8e+180: tmp = 60.0 * (y / t) elif y <= 1.1e+154: tmp = a * 120.0 else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(-60.0 * Float64(y / z)) tmp = 0.0 if (y <= -1.7e+245) tmp = t_1; elseif (y <= -5.8e+180) tmp = Float64(60.0 * Float64(y / t)); elseif (y <= 1.1e+154) tmp = Float64(a * 120.0); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = -60.0 * (y / z); tmp = 0.0; if (y <= -1.7e+245) tmp = t_1; elseif (y <= -5.8e+180) tmp = 60.0 * (y / t); elseif (y <= 1.1e+154) tmp = a * 120.0; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(-60.0 * N[(y / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.7e+245], t$95$1, If[LessEqual[y, -5.8e+180], N[(60.0 * N[(y / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.1e+154], N[(a * 120.0), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := -60 \cdot \frac{y}{z}\\
\mathbf{if}\;y \leq -1.7 \cdot 10^{+245}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -5.8 \cdot 10^{+180}:\\
\;\;\;\;60 \cdot \frac{y}{t}\\
\mathbf{elif}\;y \leq 1.1 \cdot 10^{+154}:\\
\;\;\;\;a \cdot 120\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -1.69999999999999999e245 or 1.1000000000000001e154 < y Initial program 99.9%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.9%
Simplified99.9%
Taylor expanded in y around inf
*-lft-identityN/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f64N/A
--lowering--.f6470.6%
Simplified70.6%
Taylor expanded in t around 0
/-lowering-/.f6450.6%
Simplified50.6%
associate-*r/N/A
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6450.6%
Applied egg-rr50.6%
if -1.69999999999999999e245 < y < -5.80000000000000015e180Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in y around inf
*-lft-identityN/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f64N/A
--lowering--.f6487.1%
Simplified87.1%
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
metadata-evalN/A
metadata-evalN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6487.3%
Applied egg-rr87.3%
Taylor expanded in t around inf
/-lowering-/.f6475.1%
Simplified75.1%
if -5.80000000000000015e180 < y < 1.1000000000000001e154Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in t around inf
*-lowering-*.f6460.6%
Simplified60.6%
Final simplification59.7%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* -60.0 (/ y z))))
(if (<= y -1.35e+244)
t_1
(if (<= y -6.8e+180)
(* y (/ 60.0 t))
(if (<= y 8.2e+156) (* a 120.0) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = -60.0 * (y / z);
double tmp;
if (y <= -1.35e+244) {
tmp = t_1;
} else if (y <= -6.8e+180) {
tmp = y * (60.0 / t);
} else if (y <= 8.2e+156) {
tmp = a * 120.0;
} 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 = (-60.0d0) * (y / z)
if (y <= (-1.35d+244)) then
tmp = t_1
else if (y <= (-6.8d+180)) then
tmp = y * (60.0d0 / t)
else if (y <= 8.2d+156) then
tmp = a * 120.0d0
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 = -60.0 * (y / z);
double tmp;
if (y <= -1.35e+244) {
tmp = t_1;
} else if (y <= -6.8e+180) {
tmp = y * (60.0 / t);
} else if (y <= 8.2e+156) {
tmp = a * 120.0;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = -60.0 * (y / z) tmp = 0 if y <= -1.35e+244: tmp = t_1 elif y <= -6.8e+180: tmp = y * (60.0 / t) elif y <= 8.2e+156: tmp = a * 120.0 else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(-60.0 * Float64(y / z)) tmp = 0.0 if (y <= -1.35e+244) tmp = t_1; elseif (y <= -6.8e+180) tmp = Float64(y * Float64(60.0 / t)); elseif (y <= 8.2e+156) tmp = Float64(a * 120.0); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = -60.0 * (y / z); tmp = 0.0; if (y <= -1.35e+244) tmp = t_1; elseif (y <= -6.8e+180) tmp = y * (60.0 / t); elseif (y <= 8.2e+156) tmp = a * 120.0; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(-60.0 * N[(y / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.35e+244], t$95$1, If[LessEqual[y, -6.8e+180], N[(y * N[(60.0 / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 8.2e+156], N[(a * 120.0), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := -60 \cdot \frac{y}{z}\\
\mathbf{if}\;y \leq -1.35 \cdot 10^{+244}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -6.8 \cdot 10^{+180}:\\
\;\;\;\;y \cdot \frac{60}{t}\\
\mathbf{elif}\;y \leq 8.2 \cdot 10^{+156}:\\
\;\;\;\;a \cdot 120\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -1.34999999999999999e244 or 8.2000000000000003e156 < y Initial program 99.9%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.9%
Simplified99.9%
Taylor expanded in y around inf
*-lft-identityN/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f64N/A
--lowering--.f6470.6%
Simplified70.6%
Taylor expanded in t around 0
/-lowering-/.f6450.6%
Simplified50.6%
associate-*r/N/A
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6450.6%
Applied egg-rr50.6%
if -1.34999999999999999e244 < y < -6.79999999999999969e180Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in y around inf
*-lft-identityN/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f64N/A
--lowering--.f6487.1%
Simplified87.1%
Taylor expanded in t around inf
/-lowering-/.f6475.0%
Simplified75.0%
if -6.79999999999999969e180 < y < 8.2000000000000003e156Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in t around inf
*-lowering-*.f6460.6%
Simplified60.6%
Final simplification59.7%
(FPCore (x y z t a) :precision binary64 (if (<= a -2.3e-110) (* a 120.0) (if (<= a 9.5e-176) (* -60.0 (/ y z)) (* a 120.0))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -2.3e-110) {
tmp = a * 120.0;
} else if (a <= 9.5e-176) {
tmp = -60.0 * (y / z);
} else {
tmp = a * 120.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) :: tmp
if (a <= (-2.3d-110)) then
tmp = a * 120.0d0
else if (a <= 9.5d-176) then
tmp = (-60.0d0) * (y / z)
else
tmp = a * 120.0d0
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -2.3e-110) {
tmp = a * 120.0;
} else if (a <= 9.5e-176) {
tmp = -60.0 * (y / z);
} else {
tmp = a * 120.0;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -2.3e-110: tmp = a * 120.0 elif a <= 9.5e-176: tmp = -60.0 * (y / z) else: tmp = a * 120.0 return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -2.3e-110) tmp = Float64(a * 120.0); elseif (a <= 9.5e-176) tmp = Float64(-60.0 * Float64(y / z)); else tmp = Float64(a * 120.0); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -2.3e-110) tmp = a * 120.0; elseif (a <= 9.5e-176) tmp = -60.0 * (y / z); else tmp = a * 120.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -2.3e-110], N[(a * 120.0), $MachinePrecision], If[LessEqual[a, 9.5e-176], N[(-60.0 * N[(y / z), $MachinePrecision]), $MachinePrecision], N[(a * 120.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -2.3 \cdot 10^{-110}:\\
\;\;\;\;a \cdot 120\\
\mathbf{elif}\;a \leq 9.5 \cdot 10^{-176}:\\
\;\;\;\;-60 \cdot \frac{y}{z}\\
\mathbf{else}:\\
\;\;\;\;a \cdot 120\\
\end{array}
\end{array}
if a < -2.3000000000000001e-110 or 9.5e-176 < a Initial program 99.9%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.9%
Simplified99.9%
Taylor expanded in t around inf
*-lowering-*.f6465.9%
Simplified65.9%
if -2.3000000000000001e-110 < a < 9.5e-176Initial program 99.7%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.7%
Simplified99.7%
Taylor expanded in y around inf
*-lft-identityN/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f64N/A
--lowering--.f6453.8%
Simplified53.8%
Taylor expanded in t around 0
/-lowering-/.f6435.2%
Simplified35.2%
associate-*r/N/A
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6435.2%
Applied egg-rr35.2%
Final simplification57.7%
(FPCore (x y z t a) :precision binary64 (if (<= a -2.1e-112) (* a 120.0) (if (<= a 2.8e-169) (* -60.0 (/ x t)) (* a 120.0))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -2.1e-112) {
tmp = a * 120.0;
} else if (a <= 2.8e-169) {
tmp = -60.0 * (x / t);
} else {
tmp = a * 120.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) :: tmp
if (a <= (-2.1d-112)) then
tmp = a * 120.0d0
else if (a <= 2.8d-169) then
tmp = (-60.0d0) * (x / t)
else
tmp = a * 120.0d0
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -2.1e-112) {
tmp = a * 120.0;
} else if (a <= 2.8e-169) {
tmp = -60.0 * (x / t);
} else {
tmp = a * 120.0;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -2.1e-112: tmp = a * 120.0 elif a <= 2.8e-169: tmp = -60.0 * (x / t) else: tmp = a * 120.0 return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -2.1e-112) tmp = Float64(a * 120.0); elseif (a <= 2.8e-169) tmp = Float64(-60.0 * Float64(x / t)); else tmp = Float64(a * 120.0); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -2.1e-112) tmp = a * 120.0; elseif (a <= 2.8e-169) tmp = -60.0 * (x / t); else tmp = a * 120.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -2.1e-112], N[(a * 120.0), $MachinePrecision], If[LessEqual[a, 2.8e-169], N[(-60.0 * N[(x / t), $MachinePrecision]), $MachinePrecision], N[(a * 120.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -2.1 \cdot 10^{-112}:\\
\;\;\;\;a \cdot 120\\
\mathbf{elif}\;a \leq 2.8 \cdot 10^{-169}:\\
\;\;\;\;-60 \cdot \frac{x}{t}\\
\mathbf{else}:\\
\;\;\;\;a \cdot 120\\
\end{array}
\end{array}
if a < -2.1000000000000001e-112 or 2.79999999999999988e-169 < a Initial program 99.9%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.9%
Simplified99.9%
Taylor expanded in t around inf
*-lowering-*.f6466.6%
Simplified66.6%
if -2.1000000000000001e-112 < a < 2.79999999999999988e-169Initial program 99.7%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.7%
Simplified99.7%
Taylor expanded in t around inf
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6455.7%
Simplified55.7%
Taylor expanded in x around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6424.7%
Simplified24.7%
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6424.8%
Applied egg-rr24.8%
Final simplification55.0%
(FPCore (x y z t a) :precision binary64 (+ (* 60.0 (/ (- y x) (- t z))) (* a 120.0)))
double code(double x, double y, double z, double t, double a) {
return (60.0 * ((y - x) / (t - z))) + (a * 120.0);
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = (60.0d0 * ((y - x) / (t - z))) + (a * 120.0d0)
end function
public static double code(double x, double y, double z, double t, double a) {
return (60.0 * ((y - x) / (t - z))) + (a * 120.0);
}
def code(x, y, z, t, a): return (60.0 * ((y - x) / (t - z))) + (a * 120.0)
function code(x, y, z, t, a) return Float64(Float64(60.0 * Float64(Float64(y - x) / Float64(t - z))) + Float64(a * 120.0)) end
function tmp = code(x, y, z, t, a) tmp = (60.0 * ((y - x) / (t - z))) + (a * 120.0); end
code[x_, y_, z_, t_, a_] := N[(N[(60.0 * N[(N[(y - x), $MachinePrecision] / N[(t - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(a * 120.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
60 \cdot \frac{y - x}{t - z} + a \cdot 120
\end{array}
Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f6499.8%
Applied egg-rr99.8%
Final simplification99.8%
(FPCore (x y z t a) :precision binary64 (* a 120.0))
double code(double x, double y, double z, double t, double a) {
return a * 120.0;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = a * 120.0d0
end function
public static double code(double x, double y, double z, double t, double a) {
return a * 120.0;
}
def code(x, y, z, t, a): return a * 120.0
function code(x, y, z, t, a) return Float64(a * 120.0) end
function tmp = code(x, y, z, t, a) tmp = a * 120.0; end
code[x_, y_, z_, t_, a_] := N[(a * 120.0), $MachinePrecision]
\begin{array}{l}
\\
a \cdot 120
\end{array}
Initial program 99.8%
+-lowering-+.f64N/A
sub-negN/A
+-commutativeN/A
neg-sub0N/A
associate-+l-N/A
sub0-negN/A
distribute-rgt-neg-outN/A
distribute-frac-negN/A
distribute-frac-neg2N/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in t around inf
*-lowering-*.f6451.2%
Simplified51.2%
Final simplification51.2%
(FPCore (x y z t a) :precision binary64 (+ (/ 60.0 (/ (- z t) (- x y))) (* a 120.0)))
double code(double x, double y, double z, double t, double a) {
return (60.0 / ((z - t) / (x - y))) + (a * 120.0);
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = (60.0d0 / ((z - t) / (x - y))) + (a * 120.0d0)
end function
public static double code(double x, double y, double z, double t, double a) {
return (60.0 / ((z - t) / (x - y))) + (a * 120.0);
}
def code(x, y, z, t, a): return (60.0 / ((z - t) / (x - y))) + (a * 120.0)
function code(x, y, z, t, a) return Float64(Float64(60.0 / Float64(Float64(z - t) / Float64(x - y))) + Float64(a * 120.0)) end
function tmp = code(x, y, z, t, a) tmp = (60.0 / ((z - t) / (x - y))) + (a * 120.0); end
code[x_, y_, z_, t_, a_] := N[(N[(60.0 / N[(N[(z - t), $MachinePrecision] / N[(x - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(a * 120.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{60}{\frac{z - t}{x - y}} + a \cdot 120
\end{array}
herbie shell --seed 2024145
(FPCore (x y z t a)
:name "Data.Colour.RGB:hslsv from colour-2.3.3, B"
:precision binary64
:alt
(! :herbie-platform default (+ (/ 60 (/ (- z t) (- x y))) (* a 120)))
(+ (/ (* 60.0 (- x y)) (- z t)) (* a 120.0)))