
(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 19 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 (+ (/ 60.0 (/ (- t z) (- y x))) (* a 120.0)))
double code(double x, double y, double z, double t, double a) {
return (60.0 / ((t - z) / (y - x))) + (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 / ((t - z) / (y - x))) + (a * 120.0d0)
end function
public static double code(double x, double y, double z, double t, double a) {
return (60.0 / ((t - z) / (y - x))) + (a * 120.0);
}
def code(x, y, z, t, a): return (60.0 / ((t - z) / (y - x))) + (a * 120.0)
function code(x, y, z, t, a) return Float64(Float64(60.0 / Float64(Float64(t - z) / Float64(y - x))) + Float64(a * 120.0)) end
function tmp = code(x, y, z, t, a) tmp = (60.0 / ((t - z) / (y - x))) + (a * 120.0); end
code[x_, y_, z_, t_, a_] := N[(N[(60.0 / N[(N[(t - z), $MachinePrecision] / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(a * 120.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{60}{\frac{t - z}{y - x}} + a \cdot 120
\end{array}
Initial program 99.4%
+-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.4%
Simplified99.4%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f6499.8%
Applied egg-rr99.8%
(FPCore (x y z t a)
:precision binary64
(if (<= a -4.7e+174)
(* a 120.0)
(if (<= a -6.5e-257)
(+ (* a 120.0) (/ (* 60.0 y) t))
(if (<= a 7.5e-199)
(* x (/ -60.0 (- t z)))
(if (<= a 5.8e-78) (* y (/ 60.0 (- t z))) (* a 120.0))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -4.7e+174) {
tmp = a * 120.0;
} else if (a <= -6.5e-257) {
tmp = (a * 120.0) + ((60.0 * y) / t);
} else if (a <= 7.5e-199) {
tmp = x * (-60.0 / (t - z));
} else if (a <= 5.8e-78) {
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 <= (-4.7d+174)) then
tmp = a * 120.0d0
else if (a <= (-6.5d-257)) then
tmp = (a * 120.0d0) + ((60.0d0 * y) / t)
else if (a <= 7.5d-199) then
tmp = x * ((-60.0d0) / (t - z))
else if (a <= 5.8d-78) 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 <= -4.7e+174) {
tmp = a * 120.0;
} else if (a <= -6.5e-257) {
tmp = (a * 120.0) + ((60.0 * y) / t);
} else if (a <= 7.5e-199) {
tmp = x * (-60.0 / (t - z));
} else if (a <= 5.8e-78) {
tmp = y * (60.0 / (t - z));
} else {
tmp = a * 120.0;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -4.7e+174: tmp = a * 120.0 elif a <= -6.5e-257: tmp = (a * 120.0) + ((60.0 * y) / t) elif a <= 7.5e-199: tmp = x * (-60.0 / (t - z)) elif a <= 5.8e-78: 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 <= -4.7e+174) tmp = Float64(a * 120.0); elseif (a <= -6.5e-257) tmp = Float64(Float64(a * 120.0) + Float64(Float64(60.0 * y) / t)); elseif (a <= 7.5e-199) tmp = Float64(x * Float64(-60.0 / Float64(t - z))); elseif (a <= 5.8e-78) 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 <= -4.7e+174) tmp = a * 120.0; elseif (a <= -6.5e-257) tmp = (a * 120.0) + ((60.0 * y) / t); elseif (a <= 7.5e-199) tmp = x * (-60.0 / (t - z)); elseif (a <= 5.8e-78) 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, -4.7e+174], N[(a * 120.0), $MachinePrecision], If[LessEqual[a, -6.5e-257], N[(N[(a * 120.0), $MachinePrecision] + N[(N[(60.0 * y), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 7.5e-199], N[(x * N[(-60.0 / N[(t - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 5.8e-78], 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 -4.7 \cdot 10^{+174}:\\
\;\;\;\;a \cdot 120\\
\mathbf{elif}\;a \leq -6.5 \cdot 10^{-257}:\\
\;\;\;\;a \cdot 120 + \frac{60 \cdot y}{t}\\
\mathbf{elif}\;a \leq 7.5 \cdot 10^{-199}:\\
\;\;\;\;x \cdot \frac{-60}{t - z}\\
\mathbf{elif}\;a \leq 5.8 \cdot 10^{-78}:\\
\;\;\;\;y \cdot \frac{60}{t - z}\\
\mathbf{else}:\\
\;\;\;\;a \cdot 120\\
\end{array}
\end{array}
if a < -4.6999999999999996e174 or 5.8000000000000001e-78 < 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-*.f6478.8%
Simplified78.8%
if -4.6999999999999996e174 < a < -6.5000000000000002e-257Initial 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--.f6469.5%
Simplified69.5%
Taylor expanded in x around 0
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6464.4%
Simplified64.4%
if -6.5000000000000002e-257 < a < 7.5000000000000003e-199Initial program 96.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-*.f6496.9%
Simplified96.9%
Taylor expanded in x around inf
associate-*r/N/A
*-commutativeN/A
associate-/l*N/A
metadata-evalN/A
distribute-neg-fracN/A
metadata-evalN/A
associate-*r/N/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
metadata-evalN/A
/-lowering-/.f64N/A
--lowering--.f6468.3%
Simplified68.3%
if 7.5000000000000003e-199 < a < 5.8000000000000001e-78Initial 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--.f6462.5%
Simplified62.5%
Final simplification70.5%
(FPCore (x y z t a)
:precision binary64
(if (<= a -8500.0)
(* a 120.0)
(if (<= a -2.1e-258)
(* 60.0 (/ (- y x) t))
(if (<= a 2.8e-201)
(* x (/ -60.0 (- t z)))
(if (<= a 1.2e-78) (* y (/ 60.0 (- t z))) (* a 120.0))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -8500.0) {
tmp = a * 120.0;
} else if (a <= -2.1e-258) {
tmp = 60.0 * ((y - x) / t);
} else if (a <= 2.8e-201) {
tmp = x * (-60.0 / (t - z));
} else if (a <= 1.2e-78) {
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 <= (-8500.0d0)) then
tmp = a * 120.0d0
else if (a <= (-2.1d-258)) then
tmp = 60.0d0 * ((y - x) / t)
else if (a <= 2.8d-201) then
tmp = x * ((-60.0d0) / (t - z))
else if (a <= 1.2d-78) 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 <= -8500.0) {
tmp = a * 120.0;
} else if (a <= -2.1e-258) {
tmp = 60.0 * ((y - x) / t);
} else if (a <= 2.8e-201) {
tmp = x * (-60.0 / (t - z));
} else if (a <= 1.2e-78) {
tmp = y * (60.0 / (t - z));
} else {
tmp = a * 120.0;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -8500.0: tmp = a * 120.0 elif a <= -2.1e-258: tmp = 60.0 * ((y - x) / t) elif a <= 2.8e-201: tmp = x * (-60.0 / (t - z)) elif a <= 1.2e-78: 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 <= -8500.0) tmp = Float64(a * 120.0); elseif (a <= -2.1e-258) tmp = Float64(60.0 * Float64(Float64(y - x) / t)); elseif (a <= 2.8e-201) tmp = Float64(x * Float64(-60.0 / Float64(t - z))); elseif (a <= 1.2e-78) 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 <= -8500.0) tmp = a * 120.0; elseif (a <= -2.1e-258) tmp = 60.0 * ((y - x) / t); elseif (a <= 2.8e-201) tmp = x * (-60.0 / (t - z)); elseif (a <= 1.2e-78) 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, -8500.0], N[(a * 120.0), $MachinePrecision], If[LessEqual[a, -2.1e-258], N[(60.0 * N[(N[(y - x), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.8e-201], N[(x * N[(-60.0 / N[(t - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.2e-78], 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 -8500:\\
\;\;\;\;a \cdot 120\\
\mathbf{elif}\;a \leq -2.1 \cdot 10^{-258}:\\
\;\;\;\;60 \cdot \frac{y - x}{t}\\
\mathbf{elif}\;a \leq 2.8 \cdot 10^{-201}:\\
\;\;\;\;x \cdot \frac{-60}{t - z}\\
\mathbf{elif}\;a \leq 1.2 \cdot 10^{-78}:\\
\;\;\;\;y \cdot \frac{60}{t - z}\\
\mathbf{else}:\\
\;\;\;\;a \cdot 120\\
\end{array}
\end{array}
if a < -8500 or 1.2e-78 < 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-*.f6476.8%
Simplified76.8%
if -8500 < a < -2.0999999999999999e-258Initial 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--.f6469.6%
Simplified69.6%
Taylor expanded in a around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6455.2%
Simplified55.2%
if -2.0999999999999999e-258 < a < 2.7999999999999999e-201Initial program 96.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-*.f6496.9%
Simplified96.9%
Taylor expanded in x around inf
associate-*r/N/A
*-commutativeN/A
associate-/l*N/A
metadata-evalN/A
distribute-neg-fracN/A
metadata-evalN/A
associate-*r/N/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
metadata-evalN/A
/-lowering-/.f64N/A
--lowering--.f6468.3%
Simplified68.3%
if 2.7999999999999999e-201 < a < 1.2e-78Initial 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--.f6462.5%
Simplified62.5%
Final simplification69.8%
(FPCore (x y z t a)
:precision binary64
(if (<= (* a 120.0) -20000000.0)
(* a 120.0)
(if (<= (* a 120.0) 1e-76)
(/ (* 60.0 (- y x)) (- t z))
(+ (* a 120.0) (/ (* 60.0 x) z)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a * 120.0) <= -20000000.0) {
tmp = a * 120.0;
} else if ((a * 120.0) <= 1e-76) {
tmp = (60.0 * (y - x)) / (t - z);
} else {
tmp = (a * 120.0) + ((60.0 * x) / z);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((a * 120.0d0) <= (-20000000.0d0)) then
tmp = a * 120.0d0
else if ((a * 120.0d0) <= 1d-76) then
tmp = (60.0d0 * (y - x)) / (t - z)
else
tmp = (a * 120.0d0) + ((60.0d0 * x) / z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a * 120.0) <= -20000000.0) {
tmp = a * 120.0;
} else if ((a * 120.0) <= 1e-76) {
tmp = (60.0 * (y - x)) / (t - z);
} else {
tmp = (a * 120.0) + ((60.0 * x) / z);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (a * 120.0) <= -20000000.0: tmp = a * 120.0 elif (a * 120.0) <= 1e-76: tmp = (60.0 * (y - x)) / (t - z) else: tmp = (a * 120.0) + ((60.0 * x) / z) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (Float64(a * 120.0) <= -20000000.0) tmp = Float64(a * 120.0); elseif (Float64(a * 120.0) <= 1e-76) tmp = Float64(Float64(60.0 * Float64(y - x)) / Float64(t - z)); else tmp = Float64(Float64(a * 120.0) + Float64(Float64(60.0 * x) / z)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((a * 120.0) <= -20000000.0) tmp = a * 120.0; elseif ((a * 120.0) <= 1e-76) tmp = (60.0 * (y - x)) / (t - z); else tmp = (a * 120.0) + ((60.0 * x) / z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[N[(a * 120.0), $MachinePrecision], -20000000.0], N[(a * 120.0), $MachinePrecision], If[LessEqual[N[(a * 120.0), $MachinePrecision], 1e-76], N[(N[(60.0 * N[(y - x), $MachinePrecision]), $MachinePrecision] / N[(t - z), $MachinePrecision]), $MachinePrecision], N[(N[(a * 120.0), $MachinePrecision] + N[(N[(60.0 * x), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \cdot 120 \leq -20000000:\\
\;\;\;\;a \cdot 120\\
\mathbf{elif}\;a \cdot 120 \leq 10^{-76}:\\
\;\;\;\;\frac{60 \cdot \left(y - x\right)}{t - z}\\
\mathbf{else}:\\
\;\;\;\;a \cdot 120 + \frac{60 \cdot x}{z}\\
\end{array}
\end{array}
if (*.f64 a #s(literal 120 binary64)) < -2e7Initial 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-*.f6478.3%
Simplified78.3%
if -2e7 < (*.f64 a #s(literal 120 binary64)) < 9.99999999999999927e-77Initial program 98.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-*.f6498.8%
Simplified98.8%
Taylor expanded in a around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6483.2%
Simplified83.2%
if 9.99999999999999927e-77 < (*.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%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f6499.8%
Applied egg-rr99.8%
Taylor expanded in t around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6480.6%
Simplified80.6%
Taylor expanded in y around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f6482.7%
Simplified82.7%
Final simplification81.7%
(FPCore (x y z t a)
:precision binary64
(if (<= a -390.0)
(* a 120.0)
(if (<= a -3.1e-277)
(* 60.0 (/ (- y x) t))
(if (<= a 5.5e-78) (* -60.0 (/ (- y x) z)) (* a 120.0)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -390.0) {
tmp = a * 120.0;
} else if (a <= -3.1e-277) {
tmp = 60.0 * ((y - x) / t);
} else if (a <= 5.5e-78) {
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 <= (-390.0d0)) then
tmp = a * 120.0d0
else if (a <= (-3.1d-277)) then
tmp = 60.0d0 * ((y - x) / t)
else if (a <= 5.5d-78) 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 <= -390.0) {
tmp = a * 120.0;
} else if (a <= -3.1e-277) {
tmp = 60.0 * ((y - x) / t);
} else if (a <= 5.5e-78) {
tmp = -60.0 * ((y - x) / z);
} else {
tmp = a * 120.0;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -390.0: tmp = a * 120.0 elif a <= -3.1e-277: tmp = 60.0 * ((y - x) / t) elif a <= 5.5e-78: 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 <= -390.0) tmp = Float64(a * 120.0); elseif (a <= -3.1e-277) tmp = Float64(60.0 * Float64(Float64(y - x) / t)); elseif (a <= 5.5e-78) 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 <= -390.0) tmp = a * 120.0; elseif (a <= -3.1e-277) tmp = 60.0 * ((y - x) / t); elseif (a <= 5.5e-78) 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, -390.0], N[(a * 120.0), $MachinePrecision], If[LessEqual[a, -3.1e-277], N[(60.0 * N[(N[(y - x), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 5.5e-78], 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 -390:\\
\;\;\;\;a \cdot 120\\
\mathbf{elif}\;a \leq -3.1 \cdot 10^{-277}:\\
\;\;\;\;60 \cdot \frac{y - x}{t}\\
\mathbf{elif}\;a \leq 5.5 \cdot 10^{-78}:\\
\;\;\;\;-60 \cdot \frac{y - x}{z}\\
\mathbf{else}:\\
\;\;\;\;a \cdot 120\\
\end{array}
\end{array}
if a < -390 or 5.50000000000000017e-78 < 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-*.f6476.8%
Simplified76.8%
if -390 < a < -3.09999999999999979e-277Initial 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--.f6468.9%
Simplified68.9%
Taylor expanded in a around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6455.6%
Simplified55.6%
if -3.09999999999999979e-277 < a < 5.50000000000000017e-78Initial program 97.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-*.f6497.6%
Simplified97.6%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f6499.8%
Applied egg-rr99.8%
Taylor expanded in t around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6458.8%
Simplified58.8%
Taylor expanded in z around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6456.8%
Simplified56.8%
Final simplification67.9%
(FPCore (x y z t a)
:precision binary64
(if (<= a -1.9e-50)
(* a 120.0)
(if (<= a -8.5e-255)
(/ (* 60.0 y) t)
(if (<= a 6.5e-78) (* -60.0 (/ (- y x) z)) (* a 120.0)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -1.9e-50) {
tmp = a * 120.0;
} else if (a <= -8.5e-255) {
tmp = (60.0 * y) / t;
} else if (a <= 6.5e-78) {
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 <= (-1.9d-50)) then
tmp = a * 120.0d0
else if (a <= (-8.5d-255)) then
tmp = (60.0d0 * y) / t
else if (a <= 6.5d-78) 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 <= -1.9e-50) {
tmp = a * 120.0;
} else if (a <= -8.5e-255) {
tmp = (60.0 * y) / t;
} else if (a <= 6.5e-78) {
tmp = -60.0 * ((y - x) / z);
} else {
tmp = a * 120.0;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -1.9e-50: tmp = a * 120.0 elif a <= -8.5e-255: tmp = (60.0 * y) / t elif a <= 6.5e-78: 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 <= -1.9e-50) tmp = Float64(a * 120.0); elseif (a <= -8.5e-255) tmp = Float64(Float64(60.0 * y) / t); elseif (a <= 6.5e-78) 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 <= -1.9e-50) tmp = a * 120.0; elseif (a <= -8.5e-255) tmp = (60.0 * y) / t; elseif (a <= 6.5e-78) 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, -1.9e-50], N[(a * 120.0), $MachinePrecision], If[LessEqual[a, -8.5e-255], N[(N[(60.0 * y), $MachinePrecision] / t), $MachinePrecision], If[LessEqual[a, 6.5e-78], 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 -1.9 \cdot 10^{-50}:\\
\;\;\;\;a \cdot 120\\
\mathbf{elif}\;a \leq -8.5 \cdot 10^{-255}:\\
\;\;\;\;\frac{60 \cdot y}{t}\\
\mathbf{elif}\;a \leq 6.5 \cdot 10^{-78}:\\
\;\;\;\;-60 \cdot \frac{y - x}{z}\\
\mathbf{else}:\\
\;\;\;\;a \cdot 120\\
\end{array}
\end{array}
if a < -1.9e-50 or 6.5000000000000003e-78 < 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-*.f6474.1%
Simplified74.1%
if -1.9e-50 < a < -8.49999999999999982e-255Initial 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--.f6470.1%
Simplified70.1%
Taylor expanded in y around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6441.7%
Simplified41.7%
if -8.49999999999999982e-255 < a < 6.5000000000000003e-78Initial program 97.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-*.f6497.9%
Simplified97.9%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f6499.8%
Applied egg-rr99.8%
Taylor expanded in t around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6459.7%
Simplified59.7%
Taylor expanded in z around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6456.2%
Simplified56.2%
Final simplification64.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ (* a 120.0) (* 60.0 (/ (- y x) t)))))
(if (<= t -7.2e-31)
t_1
(if (<= t 6.1e-33) (+ (* a 120.0) (/ (* (- y x) -60.0) z)) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (a * 120.0) + (60.0 * ((y - x) / t));
double tmp;
if (t <= -7.2e-31) {
tmp = t_1;
} else if (t <= 6.1e-33) {
tmp = (a * 120.0) + (((y - x) * -60.0) / z);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = (a * 120.0d0) + (60.0d0 * ((y - x) / t))
if (t <= (-7.2d-31)) then
tmp = t_1
else if (t <= 6.1d-33) then
tmp = (a * 120.0d0) + (((y - x) * (-60.0d0)) / z)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (a * 120.0) + (60.0 * ((y - x) / t));
double tmp;
if (t <= -7.2e-31) {
tmp = t_1;
} else if (t <= 6.1e-33) {
tmp = (a * 120.0) + (((y - x) * -60.0) / z);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (a * 120.0) + (60.0 * ((y - x) / t)) tmp = 0 if t <= -7.2e-31: tmp = t_1 elif t <= 6.1e-33: tmp = (a * 120.0) + (((y - x) * -60.0) / z) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(a * 120.0) + Float64(60.0 * Float64(Float64(y - x) / t))) tmp = 0.0 if (t <= -7.2e-31) tmp = t_1; elseif (t <= 6.1e-33) tmp = Float64(Float64(a * 120.0) + Float64(Float64(Float64(y - x) * -60.0) / z)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (a * 120.0) + (60.0 * ((y - x) / t)); tmp = 0.0; if (t <= -7.2e-31) tmp = t_1; elseif (t <= 6.1e-33) tmp = (a * 120.0) + (((y - x) * -60.0) / z); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(a * 120.0), $MachinePrecision] + N[(60.0 * N[(N[(y - x), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -7.2e-31], t$95$1, If[LessEqual[t, 6.1e-33], N[(N[(a * 120.0), $MachinePrecision] + N[(N[(N[(y - x), $MachinePrecision] * -60.0), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot 120 + 60 \cdot \frac{y - x}{t}\\
\mathbf{if}\;t \leq -7.2 \cdot 10^{-31}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 6.1 \cdot 10^{-33}:\\
\;\;\;\;a \cdot 120 + \frac{\left(y - x\right) \cdot -60}{z}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -7.20000000000000007e-31 or 6.1000000000000001e-33 < t Initial program 99.1%
+-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.1%
Simplified99.1%
Taylor expanded in t around inf
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6487.7%
Simplified87.7%
if -7.20000000000000007e-31 < t < 6.1000000000000001e-33Initial 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 0
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f6490.1%
Simplified90.1%
Final simplification88.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ (* a 120.0) (* 60.0 (/ (- y x) t)))))
(if (<= t -1.5e-31)
t_1
(if (<= t 2e-34) (+ (* a 120.0) (* -60.0 (/ (- y x) z))) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (a * 120.0) + (60.0 * ((y - x) / t));
double tmp;
if (t <= -1.5e-31) {
tmp = t_1;
} else if (t <= 2e-34) {
tmp = (a * 120.0) + (-60.0 * ((y - x) / z));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = (a * 120.0d0) + (60.0d0 * ((y - x) / t))
if (t <= (-1.5d-31)) then
tmp = t_1
else if (t <= 2d-34) then
tmp = (a * 120.0d0) + ((-60.0d0) * ((y - x) / z))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (a * 120.0) + (60.0 * ((y - x) / t));
double tmp;
if (t <= -1.5e-31) {
tmp = t_1;
} else if (t <= 2e-34) {
tmp = (a * 120.0) + (-60.0 * ((y - x) / z));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (a * 120.0) + (60.0 * ((y - x) / t)) tmp = 0 if t <= -1.5e-31: tmp = t_1 elif t <= 2e-34: tmp = (a * 120.0) + (-60.0 * ((y - x) / z)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(a * 120.0) + Float64(60.0 * Float64(Float64(y - x) / t))) tmp = 0.0 if (t <= -1.5e-31) tmp = t_1; elseif (t <= 2e-34) tmp = Float64(Float64(a * 120.0) + Float64(-60.0 * Float64(Float64(y - x) / z))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (a * 120.0) + (60.0 * ((y - x) / t)); tmp = 0.0; if (t <= -1.5e-31) tmp = t_1; elseif (t <= 2e-34) tmp = (a * 120.0) + (-60.0 * ((y - x) / z)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(a * 120.0), $MachinePrecision] + N[(60.0 * N[(N[(y - x), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.5e-31], t$95$1, If[LessEqual[t, 2e-34], N[(N[(a * 120.0), $MachinePrecision] + N[(-60.0 * N[(N[(y - x), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot 120 + 60 \cdot \frac{y - x}{t}\\
\mathbf{if}\;t \leq -1.5 \cdot 10^{-31}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 2 \cdot 10^{-34}:\\
\;\;\;\;a \cdot 120 + -60 \cdot \frac{y - x}{z}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -1.49999999999999991e-31 or 1.99999999999999986e-34 < t Initial program 99.1%
+-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.1%
Simplified99.1%
Taylor expanded in t around inf
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6487.7%
Simplified87.7%
if -1.49999999999999991e-31 < t < 1.99999999999999986e-34Initial 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
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f6499.8%
Applied egg-rr99.8%
Taylor expanded in t around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6490.1%
Simplified90.1%
Final simplification88.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ (* a 120.0) (/ (* 60.0 y) t))))
(if (<= t -3e-34)
t_1
(if (<= t 1.14e-29) (+ (* a 120.0) (* -60.0 (/ (- y x) z))) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (a * 120.0) + ((60.0 * y) / t);
double tmp;
if (t <= -3e-34) {
tmp = t_1;
} else if (t <= 1.14e-29) {
tmp = (a * 120.0) + (-60.0 * ((y - x) / z));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = (a * 120.0d0) + ((60.0d0 * y) / t)
if (t <= (-3d-34)) then
tmp = t_1
else if (t <= 1.14d-29) then
tmp = (a * 120.0d0) + ((-60.0d0) * ((y - x) / z))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (a * 120.0) + ((60.0 * y) / t);
double tmp;
if (t <= -3e-34) {
tmp = t_1;
} else if (t <= 1.14e-29) {
tmp = (a * 120.0) + (-60.0 * ((y - x) / z));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (a * 120.0) + ((60.0 * y) / t) tmp = 0 if t <= -3e-34: tmp = t_1 elif t <= 1.14e-29: tmp = (a * 120.0) + (-60.0 * ((y - x) / z)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(a * 120.0) + Float64(Float64(60.0 * y) / t)) tmp = 0.0 if (t <= -3e-34) tmp = t_1; elseif (t <= 1.14e-29) tmp = Float64(Float64(a * 120.0) + Float64(-60.0 * Float64(Float64(y - x) / z))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (a * 120.0) + ((60.0 * y) / t); tmp = 0.0; if (t <= -3e-34) tmp = t_1; elseif (t <= 1.14e-29) tmp = (a * 120.0) + (-60.0 * ((y - x) / z)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(a * 120.0), $MachinePrecision] + N[(N[(60.0 * y), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -3e-34], t$95$1, If[LessEqual[t, 1.14e-29], N[(N[(a * 120.0), $MachinePrecision] + N[(-60.0 * N[(N[(y - x), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot 120 + \frac{60 \cdot y}{t}\\
\mathbf{if}\;t \leq -3 \cdot 10^{-34}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 1.14 \cdot 10^{-29}:\\
\;\;\;\;a \cdot 120 + -60 \cdot \frac{y - x}{z}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -3e-34 or 1.13999999999999995e-29 < t Initial program 99.1%
+-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.1%
Simplified99.1%
Taylor expanded in t around inf
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6487.6%
Simplified87.6%
Taylor expanded in x around 0
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6476.7%
Simplified76.7%
if -3e-34 < t < 1.13999999999999995e-29Initial 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
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f6499.8%
Applied egg-rr99.8%
Taylor expanded in t around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6489.4%
Simplified89.4%
Final simplification82.7%
(FPCore (x y z t a)
:precision binary64
(if (<= a -4.3e-50)
(* a 120.0)
(if (<= a -6.6e-257)
(/ (* 60.0 y) t)
(if (<= a 1.85e-180) (/ (* 60.0 x) z) (* a 120.0)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -4.3e-50) {
tmp = a * 120.0;
} else if (a <= -6.6e-257) {
tmp = (60.0 * y) / t;
} else if (a <= 1.85e-180) {
tmp = (60.0 * 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 <= (-4.3d-50)) then
tmp = a * 120.0d0
else if (a <= (-6.6d-257)) then
tmp = (60.0d0 * y) / t
else if (a <= 1.85d-180) then
tmp = (60.0d0 * 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 <= -4.3e-50) {
tmp = a * 120.0;
} else if (a <= -6.6e-257) {
tmp = (60.0 * y) / t;
} else if (a <= 1.85e-180) {
tmp = (60.0 * x) / z;
} else {
tmp = a * 120.0;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -4.3e-50: tmp = a * 120.0 elif a <= -6.6e-257: tmp = (60.0 * y) / t elif a <= 1.85e-180: tmp = (60.0 * x) / z else: tmp = a * 120.0 return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -4.3e-50) tmp = Float64(a * 120.0); elseif (a <= -6.6e-257) tmp = Float64(Float64(60.0 * y) / t); elseif (a <= 1.85e-180) tmp = Float64(Float64(60.0 * 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 <= -4.3e-50) tmp = a * 120.0; elseif (a <= -6.6e-257) tmp = (60.0 * y) / t; elseif (a <= 1.85e-180) tmp = (60.0 * x) / z; else tmp = a * 120.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -4.3e-50], N[(a * 120.0), $MachinePrecision], If[LessEqual[a, -6.6e-257], N[(N[(60.0 * y), $MachinePrecision] / t), $MachinePrecision], If[LessEqual[a, 1.85e-180], N[(N[(60.0 * x), $MachinePrecision] / z), $MachinePrecision], N[(a * 120.0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -4.3 \cdot 10^{-50}:\\
\;\;\;\;a \cdot 120\\
\mathbf{elif}\;a \leq -6.6 \cdot 10^{-257}:\\
\;\;\;\;\frac{60 \cdot y}{t}\\
\mathbf{elif}\;a \leq 1.85 \cdot 10^{-180}:\\
\;\;\;\;\frac{60 \cdot x}{z}\\
\mathbf{else}:\\
\;\;\;\;a \cdot 120\\
\end{array}
\end{array}
if a < -4.29999999999999997e-50 or 1.85000000000000008e-180 < 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-*.f6469.9%
Simplified69.9%
if -4.29999999999999997e-50 < a < -6.6e-257Initial 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--.f6468.8%
Simplified68.8%
Taylor expanded in y around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6441.0%
Simplified41.0%
if -6.6e-257 < a < 1.85000000000000008e-180Initial program 97.3%
+-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-*.f6497.3%
Simplified97.3%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f6499.8%
Applied egg-rr99.8%
Taylor expanded in t around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6462.8%
Simplified62.8%
Taylor expanded in x around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f6437.9%
Simplified37.9%
Final simplification59.7%
(FPCore (x y z t a)
:precision binary64
(if (<= a -5.6e-50)
(* a 120.0)
(if (<= a -4.8e-258)
(* 60.0 (/ y t))
(if (<= a 2.8e-181) (/ (* 60.0 x) z) (* a 120.0)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -5.6e-50) {
tmp = a * 120.0;
} else if (a <= -4.8e-258) {
tmp = 60.0 * (y / t);
} else if (a <= 2.8e-181) {
tmp = (60.0 * 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 <= (-5.6d-50)) then
tmp = a * 120.0d0
else if (a <= (-4.8d-258)) then
tmp = 60.0d0 * (y / t)
else if (a <= 2.8d-181) then
tmp = (60.0d0 * 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 <= -5.6e-50) {
tmp = a * 120.0;
} else if (a <= -4.8e-258) {
tmp = 60.0 * (y / t);
} else if (a <= 2.8e-181) {
tmp = (60.0 * x) / z;
} else {
tmp = a * 120.0;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -5.6e-50: tmp = a * 120.0 elif a <= -4.8e-258: tmp = 60.0 * (y / t) elif a <= 2.8e-181: tmp = (60.0 * x) / z else: tmp = a * 120.0 return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -5.6e-50) tmp = Float64(a * 120.0); elseif (a <= -4.8e-258) tmp = Float64(60.0 * Float64(y / t)); elseif (a <= 2.8e-181) tmp = Float64(Float64(60.0 * 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 <= -5.6e-50) tmp = a * 120.0; elseif (a <= -4.8e-258) tmp = 60.0 * (y / t); elseif (a <= 2.8e-181) tmp = (60.0 * x) / z; else tmp = a * 120.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -5.6e-50], N[(a * 120.0), $MachinePrecision], If[LessEqual[a, -4.8e-258], N[(60.0 * N[(y / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.8e-181], N[(N[(60.0 * x), $MachinePrecision] / z), $MachinePrecision], N[(a * 120.0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -5.6 \cdot 10^{-50}:\\
\;\;\;\;a \cdot 120\\
\mathbf{elif}\;a \leq -4.8 \cdot 10^{-258}:\\
\;\;\;\;60 \cdot \frac{y}{t}\\
\mathbf{elif}\;a \leq 2.8 \cdot 10^{-181}:\\
\;\;\;\;\frac{60 \cdot x}{z}\\
\mathbf{else}:\\
\;\;\;\;a \cdot 120\\
\end{array}
\end{array}
if a < -5.5999999999999996e-50 or 2.79999999999999986e-181 < 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-*.f6469.9%
Simplified69.9%
if -5.5999999999999996e-50 < a < -4.8000000000000003e-258Initial 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--.f6468.8%
Simplified68.8%
Taylor expanded in a around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6457.1%
Simplified57.1%
Taylor expanded in y around inf
/-lowering-/.f6440.9%
Simplified40.9%
if -4.8000000000000003e-258 < a < 2.79999999999999986e-181Initial program 97.3%
+-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-*.f6497.3%
Simplified97.3%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f6499.8%
Applied egg-rr99.8%
Taylor expanded in t around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6462.8%
Simplified62.8%
Taylor expanded in x around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f6437.9%
Simplified37.9%
Final simplification59.7%
(FPCore (x y z t a)
:precision binary64
(if (<= a -2.1e-50)
(* a 120.0)
(if (<= a -6.8e-255)
(* 60.0 (/ y t))
(if (<= a 1.9e-121) (/ -60.0 (/ z y)) (* a 120.0)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -2.1e-50) {
tmp = a * 120.0;
} else if (a <= -6.8e-255) {
tmp = 60.0 * (y / t);
} else if (a <= 1.9e-121) {
tmp = -60.0 / (z / y);
} 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-50)) then
tmp = a * 120.0d0
else if (a <= (-6.8d-255)) then
tmp = 60.0d0 * (y / t)
else if (a <= 1.9d-121) then
tmp = (-60.0d0) / (z / y)
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-50) {
tmp = a * 120.0;
} else if (a <= -6.8e-255) {
tmp = 60.0 * (y / t);
} else if (a <= 1.9e-121) {
tmp = -60.0 / (z / y);
} else {
tmp = a * 120.0;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -2.1e-50: tmp = a * 120.0 elif a <= -6.8e-255: tmp = 60.0 * (y / t) elif a <= 1.9e-121: tmp = -60.0 / (z / y) else: tmp = a * 120.0 return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -2.1e-50) tmp = Float64(a * 120.0); elseif (a <= -6.8e-255) tmp = Float64(60.0 * Float64(y / t)); elseif (a <= 1.9e-121) tmp = Float64(-60.0 / Float64(z / y)); 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-50) tmp = a * 120.0; elseif (a <= -6.8e-255) tmp = 60.0 * (y / t); elseif (a <= 1.9e-121) tmp = -60.0 / (z / y); else tmp = a * 120.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -2.1e-50], N[(a * 120.0), $MachinePrecision], If[LessEqual[a, -6.8e-255], N[(60.0 * N[(y / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.9e-121], N[(-60.0 / N[(z / y), $MachinePrecision]), $MachinePrecision], N[(a * 120.0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -2.1 \cdot 10^{-50}:\\
\;\;\;\;a \cdot 120\\
\mathbf{elif}\;a \leq -6.8 \cdot 10^{-255}:\\
\;\;\;\;60 \cdot \frac{y}{t}\\
\mathbf{elif}\;a \leq 1.9 \cdot 10^{-121}:\\
\;\;\;\;\frac{-60}{\frac{z}{y}}\\
\mathbf{else}:\\
\;\;\;\;a \cdot 120\\
\end{array}
\end{array}
if a < -2.1000000000000001e-50 or 1.9e-121 < 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-*.f6471.7%
Simplified71.7%
if -2.1000000000000001e-50 < a < -6.79999999999999967e-255Initial 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--.f6470.1%
Simplified70.1%
Taylor expanded in a around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6458.2%
Simplified58.2%
Taylor expanded in y around inf
/-lowering-/.f6441.6%
Simplified41.6%
if -6.79999999999999967e-255 < a < 1.9e-121Initial program 97.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-*.f6497.6%
Simplified97.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--.f6441.2%
Simplified41.2%
Taylor expanded in t around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f6428.7%
Simplified28.7%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6428.7%
Applied egg-rr28.7%
Final simplification58.6%
(FPCore (x y z t a)
:precision binary64
(if (<= a -8e-47)
(* a 120.0)
(if (<= a -8.4e-255)
(* 60.0 (/ y t))
(if (<= a 7.4e-119) (* y (/ -60.0 z)) (* a 120.0)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -8e-47) {
tmp = a * 120.0;
} else if (a <= -8.4e-255) {
tmp = 60.0 * (y / t);
} else if (a <= 7.4e-119) {
tmp = y * (-60.0 / 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 <= (-8d-47)) then
tmp = a * 120.0d0
else if (a <= (-8.4d-255)) then
tmp = 60.0d0 * (y / t)
else if (a <= 7.4d-119) then
tmp = y * ((-60.0d0) / 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 <= -8e-47) {
tmp = a * 120.0;
} else if (a <= -8.4e-255) {
tmp = 60.0 * (y / t);
} else if (a <= 7.4e-119) {
tmp = y * (-60.0 / z);
} else {
tmp = a * 120.0;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -8e-47: tmp = a * 120.0 elif a <= -8.4e-255: tmp = 60.0 * (y / t) elif a <= 7.4e-119: tmp = y * (-60.0 / z) else: tmp = a * 120.0 return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -8e-47) tmp = Float64(a * 120.0); elseif (a <= -8.4e-255) tmp = Float64(60.0 * Float64(y / t)); elseif (a <= 7.4e-119) tmp = Float64(y * Float64(-60.0 / 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 <= -8e-47) tmp = a * 120.0; elseif (a <= -8.4e-255) tmp = 60.0 * (y / t); elseif (a <= 7.4e-119) tmp = y * (-60.0 / z); else tmp = a * 120.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -8e-47], N[(a * 120.0), $MachinePrecision], If[LessEqual[a, -8.4e-255], N[(60.0 * N[(y / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 7.4e-119], N[(y * N[(-60.0 / z), $MachinePrecision]), $MachinePrecision], N[(a * 120.0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -8 \cdot 10^{-47}:\\
\;\;\;\;a \cdot 120\\
\mathbf{elif}\;a \leq -8.4 \cdot 10^{-255}:\\
\;\;\;\;60 \cdot \frac{y}{t}\\
\mathbf{elif}\;a \leq 7.4 \cdot 10^{-119}:\\
\;\;\;\;y \cdot \frac{-60}{z}\\
\mathbf{else}:\\
\;\;\;\;a \cdot 120\\
\end{array}
\end{array}
if a < -7.9999999999999998e-47 or 7.4000000000000003e-119 < 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-*.f6471.7%
Simplified71.7%
if -7.9999999999999998e-47 < a < -8.3999999999999999e-255Initial 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--.f6470.1%
Simplified70.1%
Taylor expanded in a around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6458.2%
Simplified58.2%
Taylor expanded in y around inf
/-lowering-/.f6441.6%
Simplified41.6%
if -8.3999999999999999e-255 < a < 7.4000000000000003e-119Initial program 97.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-*.f6497.6%
Simplified97.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--.f6441.2%
Simplified41.2%
Taylor expanded in t around 0
/-lowering-/.f6428.7%
Simplified28.7%
Final simplification58.5%
(FPCore (x y z t a)
:precision binary64
(if (<= a -3.85e-50)
(* a 120.0)
(if (<= a -2.3e-265)
(* 60.0 (/ y t))
(if (<= a 2.9e-195) (* x (/ -60.0 t)) (* a 120.0)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -3.85e-50) {
tmp = a * 120.0;
} else if (a <= -2.3e-265) {
tmp = 60.0 * (y / t);
} else if (a <= 2.9e-195) {
tmp = x * (-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 <= (-3.85d-50)) then
tmp = a * 120.0d0
else if (a <= (-2.3d-265)) then
tmp = 60.0d0 * (y / t)
else if (a <= 2.9d-195) then
tmp = x * ((-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 <= -3.85e-50) {
tmp = a * 120.0;
} else if (a <= -2.3e-265) {
tmp = 60.0 * (y / t);
} else if (a <= 2.9e-195) {
tmp = x * (-60.0 / t);
} else {
tmp = a * 120.0;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -3.85e-50: tmp = a * 120.0 elif a <= -2.3e-265: tmp = 60.0 * (y / t) elif a <= 2.9e-195: tmp = x * (-60.0 / t) else: tmp = a * 120.0 return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -3.85e-50) tmp = Float64(a * 120.0); elseif (a <= -2.3e-265) tmp = Float64(60.0 * Float64(y / t)); elseif (a <= 2.9e-195) tmp = Float64(x * 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 <= -3.85e-50) tmp = a * 120.0; elseif (a <= -2.3e-265) tmp = 60.0 * (y / t); elseif (a <= 2.9e-195) tmp = x * (-60.0 / t); else tmp = a * 120.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -3.85e-50], N[(a * 120.0), $MachinePrecision], If[LessEqual[a, -2.3e-265], N[(60.0 * N[(y / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.9e-195], N[(x * N[(-60.0 / t), $MachinePrecision]), $MachinePrecision], N[(a * 120.0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -3.85 \cdot 10^{-50}:\\
\;\;\;\;a \cdot 120\\
\mathbf{elif}\;a \leq -2.3 \cdot 10^{-265}:\\
\;\;\;\;60 \cdot \frac{y}{t}\\
\mathbf{elif}\;a \leq 2.9 \cdot 10^{-195}:\\
\;\;\;\;x \cdot \frac{-60}{t}\\
\mathbf{else}:\\
\;\;\;\;a \cdot 120\\
\end{array}
\end{array}
if a < -3.84999999999999982e-50 or 2.9000000000000002e-195 < 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-*.f6468.7%
Simplified68.7%
if -3.84999999999999982e-50 < a < -2.2999999999999999e-265Initial 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--.f6466.1%
Simplified66.1%
Taylor expanded in a around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6454.9%
Simplified54.9%
Taylor expanded in y around inf
/-lowering-/.f6439.3%
Simplified39.3%
if -2.2999999999999999e-265 < a < 2.9000000000000002e-195Initial program 96.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-*.f6496.9%
Simplified96.9%
Taylor expanded in t around inf
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6444.9%
Simplified44.9%
Taylor expanded in x around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f6433.6%
Simplified33.6%
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6433.6%
Applied egg-rr33.6%
Final simplification58.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ (* a 120.0) (/ (* 60.0 y) t))))
(if (<= t -1.25e-30)
t_1
(if (<= t 3.8e-28) (+ (* a 120.0) (/ (* 60.0 x) z)) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (a * 120.0) + ((60.0 * y) / t);
double tmp;
if (t <= -1.25e-30) {
tmp = t_1;
} else if (t <= 3.8e-28) {
tmp = (a * 120.0) + ((60.0 * x) / z);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = (a * 120.0d0) + ((60.0d0 * y) / t)
if (t <= (-1.25d-30)) then
tmp = t_1
else if (t <= 3.8d-28) then
tmp = (a * 120.0d0) + ((60.0d0 * x) / z)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (a * 120.0) + ((60.0 * y) / t);
double tmp;
if (t <= -1.25e-30) {
tmp = t_1;
} else if (t <= 3.8e-28) {
tmp = (a * 120.0) + ((60.0 * x) / z);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (a * 120.0) + ((60.0 * y) / t) tmp = 0 if t <= -1.25e-30: tmp = t_1 elif t <= 3.8e-28: tmp = (a * 120.0) + ((60.0 * x) / z) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(a * 120.0) + Float64(Float64(60.0 * y) / t)) tmp = 0.0 if (t <= -1.25e-30) tmp = t_1; elseif (t <= 3.8e-28) tmp = Float64(Float64(a * 120.0) + Float64(Float64(60.0 * x) / z)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (a * 120.0) + ((60.0 * y) / t); tmp = 0.0; if (t <= -1.25e-30) tmp = t_1; elseif (t <= 3.8e-28) tmp = (a * 120.0) + ((60.0 * x) / z); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(a * 120.0), $MachinePrecision] + N[(N[(60.0 * y), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.25e-30], t$95$1, If[LessEqual[t, 3.8e-28], N[(N[(a * 120.0), $MachinePrecision] + N[(N[(60.0 * x), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot 120 + \frac{60 \cdot y}{t}\\
\mathbf{if}\;t \leq -1.25 \cdot 10^{-30}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 3.8 \cdot 10^{-28}:\\
\;\;\;\;a \cdot 120 + \frac{60 \cdot x}{z}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -1.24999999999999993e-30 or 3.80000000000000009e-28 < t Initial program 99.1%
+-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.1%
Simplified99.1%
Taylor expanded in t around inf
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6487.6%
Simplified87.6%
Taylor expanded in x around 0
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6476.7%
Simplified76.7%
if -1.24999999999999993e-30 < t < 3.80000000000000009e-28Initial 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
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f6499.8%
Applied egg-rr99.8%
Taylor expanded in t around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6489.4%
Simplified89.4%
Taylor expanded in y around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f6470.1%
Simplified70.1%
Final simplification73.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ (* a 120.0) (/ (* 60.0 y) t))))
(if (<= t -6.4e-31)
t_1
(if (<= t 5.3e-45) (+ (* a 120.0) (/ (* y -60.0) z)) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (a * 120.0) + ((60.0 * y) / t);
double tmp;
if (t <= -6.4e-31) {
tmp = t_1;
} else if (t <= 5.3e-45) {
tmp = (a * 120.0) + ((y * -60.0) / z);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = (a * 120.0d0) + ((60.0d0 * y) / t)
if (t <= (-6.4d-31)) then
tmp = t_1
else if (t <= 5.3d-45) then
tmp = (a * 120.0d0) + ((y * (-60.0d0)) / z)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (a * 120.0) + ((60.0 * y) / t);
double tmp;
if (t <= -6.4e-31) {
tmp = t_1;
} else if (t <= 5.3e-45) {
tmp = (a * 120.0) + ((y * -60.0) / z);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (a * 120.0) + ((60.0 * y) / t) tmp = 0 if t <= -6.4e-31: tmp = t_1 elif t <= 5.3e-45: tmp = (a * 120.0) + ((y * -60.0) / z) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(a * 120.0) + Float64(Float64(60.0 * y) / t)) tmp = 0.0 if (t <= -6.4e-31) tmp = t_1; elseif (t <= 5.3e-45) tmp = Float64(Float64(a * 120.0) + Float64(Float64(y * -60.0) / z)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (a * 120.0) + ((60.0 * y) / t); tmp = 0.0; if (t <= -6.4e-31) tmp = t_1; elseif (t <= 5.3e-45) tmp = (a * 120.0) + ((y * -60.0) / z); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(a * 120.0), $MachinePrecision] + N[(N[(60.0 * y), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -6.4e-31], t$95$1, If[LessEqual[t, 5.3e-45], N[(N[(a * 120.0), $MachinePrecision] + N[(N[(y * -60.0), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot 120 + \frac{60 \cdot y}{t}\\
\mathbf{if}\;t \leq -6.4 \cdot 10^{-31}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 5.3 \cdot 10^{-45}:\\
\;\;\;\;a \cdot 120 + \frac{y \cdot -60}{z}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -6.40000000000000036e-31 or 5.2999999999999997e-45 < t Initial program 99.1%
+-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.1%
Simplified99.1%
Taylor expanded in t around inf
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6487.2%
Simplified87.2%
Taylor expanded in x around 0
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6476.1%
Simplified76.1%
if -6.40000000000000036e-31 < t < 5.2999999999999997e-45Initial 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
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f6499.7%
Applied egg-rr99.7%
Taylor expanded in t around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6489.9%
Simplified89.9%
Taylor expanded in y around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f6464.1%
Simplified64.1%
Final simplification70.6%
(FPCore (x y z t a) :precision binary64 (if (<= a -1.9e-50) (* a 120.0) (if (<= a 6.6e-89) (* 60.0 (/ y t)) (* a 120.0))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -1.9e-50) {
tmp = a * 120.0;
} else if (a <= 6.6e-89) {
tmp = 60.0 * (y / 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 <= (-1.9d-50)) then
tmp = a * 120.0d0
else if (a <= 6.6d-89) then
tmp = 60.0d0 * (y / 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 <= -1.9e-50) {
tmp = a * 120.0;
} else if (a <= 6.6e-89) {
tmp = 60.0 * (y / t);
} else {
tmp = a * 120.0;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -1.9e-50: tmp = a * 120.0 elif a <= 6.6e-89: tmp = 60.0 * (y / t) else: tmp = a * 120.0 return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -1.9e-50) tmp = Float64(a * 120.0); elseif (a <= 6.6e-89) tmp = Float64(60.0 * Float64(y / 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 <= -1.9e-50) tmp = a * 120.0; elseif (a <= 6.6e-89) tmp = 60.0 * (y / t); else tmp = a * 120.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -1.9e-50], N[(a * 120.0), $MachinePrecision], If[LessEqual[a, 6.6e-89], N[(60.0 * N[(y / t), $MachinePrecision]), $MachinePrecision], N[(a * 120.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.9 \cdot 10^{-50}:\\
\;\;\;\;a \cdot 120\\
\mathbf{elif}\;a \leq 6.6 \cdot 10^{-89}:\\
\;\;\;\;60 \cdot \frac{y}{t}\\
\mathbf{else}:\\
\;\;\;\;a \cdot 120\\
\end{array}
\end{array}
if a < -1.9e-50 or 6.5999999999999993e-89 < 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-*.f6473.7%
Simplified73.7%
if -1.9e-50 < a < 6.5999999999999993e-89Initial program 98.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-*.f6498.7%
Simplified98.7%
Taylor expanded in t around inf
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6456.9%
Simplified56.9%
Taylor expanded in a around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6449.4%
Simplified49.4%
Taylor expanded in y around inf
/-lowering-/.f6429.2%
Simplified29.2%
Final simplification56.6%
(FPCore (x y z t a) :precision binary64 (+ (* (- y x) (/ 60.0 (- t z))) (* a 120.0)))
double code(double x, double y, double z, double t, double a) {
return ((y - x) * (60.0 / (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 = ((y - x) * (60.0d0 / (t - z))) + (a * 120.0d0)
end function
public static double code(double x, double y, double z, double t, double a) {
return ((y - x) * (60.0 / (t - z))) + (a * 120.0);
}
def code(x, y, z, t, a): return ((y - x) * (60.0 / (t - z))) + (a * 120.0)
function code(x, y, z, t, a) return Float64(Float64(Float64(y - x) * Float64(60.0 / Float64(t - z))) + Float64(a * 120.0)) end
function tmp = code(x, y, z, t, a) tmp = ((y - x) * (60.0 / (t - z))) + (a * 120.0); end
code[x_, y_, z_, t_, a_] := N[(N[(N[(y - x), $MachinePrecision] * N[(60.0 / N[(t - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(a * 120.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(y - x\right) \cdot \frac{60}{t - z} + a \cdot 120
\end{array}
Initial program 99.4%
+-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.4%
Simplified99.4%
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f6499.8%
Applied egg-rr99.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.4%
+-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.4%
Simplified99.4%
Taylor expanded in t around inf
*-lowering-*.f6451.6%
Simplified51.6%
Final simplification51.6%
(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 2024150
(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)))