
(FPCore (x y z t a) :precision binary64 (/ (- (* x y) (* (* z 9.0) t)) (* a 2.0)))
double code(double x, double y, double z, double t, double a) {
return ((x * y) - ((z * 9.0) * t)) / (a * 2.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 = ((x * y) - ((z * 9.0d0) * t)) / (a * 2.0d0)
end function
public static double code(double x, double y, double z, double t, double a) {
return ((x * y) - ((z * 9.0) * t)) / (a * 2.0);
}
def code(x, y, z, t, a): return ((x * y) - ((z * 9.0) * t)) / (a * 2.0)
function code(x, y, z, t, a) return Float64(Float64(Float64(x * y) - Float64(Float64(z * 9.0) * t)) / Float64(a * 2.0)) end
function tmp = code(x, y, z, t, a) tmp = ((x * y) - ((z * 9.0) * t)) / (a * 2.0); end
code[x_, y_, z_, t_, a_] := N[(N[(N[(x * y), $MachinePrecision] - N[(N[(z * 9.0), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot y - \left(z \cdot 9\right) \cdot t}{a \cdot 2}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 8 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (/ (- (* x y) (* (* z 9.0) t)) (* a 2.0)))
double code(double x, double y, double z, double t, double a) {
return ((x * y) - ((z * 9.0) * t)) / (a * 2.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 = ((x * y) - ((z * 9.0d0) * t)) / (a * 2.0d0)
end function
public static double code(double x, double y, double z, double t, double a) {
return ((x * y) - ((z * 9.0) * t)) / (a * 2.0);
}
def code(x, y, z, t, a): return ((x * y) - ((z * 9.0) * t)) / (a * 2.0)
function code(x, y, z, t, a) return Float64(Float64(Float64(x * y) - Float64(Float64(z * 9.0) * t)) / Float64(a * 2.0)) end
function tmp = code(x, y, z, t, a) tmp = ((x * y) - ((z * 9.0) * t)) / (a * 2.0); end
code[x_, y_, z_, t_, a_] := N[(N[(N[(x * y), $MachinePrecision] - N[(N[(z * 9.0), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot y - \left(z \cdot 9\right) \cdot t}{a \cdot 2}
\end{array}
NOTE: x and y should be sorted in increasing order before calling this function. NOTE: z and t should be sorted in increasing order before calling this function. (FPCore (x y z t a) :precision binary64 (if (<= (* x y) 5e+248) (/ (fma z (* t -9.0) (* x y)) (* a 2.0)) (* 0.5 (/ y (/ a x)))))
assert(x < y);
assert(z < t);
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x * y) <= 5e+248) {
tmp = fma(z, (t * -9.0), (x * y)) / (a * 2.0);
} else {
tmp = 0.5 * (y / (a / x));
}
return tmp;
}
x, y = sort([x, y]) z, t = sort([z, t]) function code(x, y, z, t, a) tmp = 0.0 if (Float64(x * y) <= 5e+248) tmp = Float64(fma(z, Float64(t * -9.0), Float64(x * y)) / Float64(a * 2.0)); else tmp = Float64(0.5 * Float64(y / Float64(a / x))); end return tmp end
NOTE: x and y should be sorted in increasing order before calling this function. NOTE: z and t should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := If[LessEqual[N[(x * y), $MachinePrecision], 5e+248], N[(N[(z * N[(t * -9.0), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(y / N[(a / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
[z, t] = \mathsf{sort}([z, t])\\
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq 5 \cdot 10^{+248}:\\
\;\;\;\;\frac{\mathsf{fma}\left(z, t \cdot -9, x \cdot y\right)}{a \cdot 2}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \frac{y}{\frac{a}{x}}\\
\end{array}
\end{array}
if (*.f64 x y) < 4.9999999999999996e248Initial program 92.7%
sub-neg92.7%
+-commutative92.7%
associate-*l*92.6%
distribute-rgt-neg-in92.6%
fma-def93.1%
*-commutative93.1%
distribute-rgt-neg-in93.1%
metadata-eval93.1%
Simplified93.1%
if 4.9999999999999996e248 < (*.f64 x y) Initial program 69.4%
sub-neg69.4%
+-commutative69.4%
neg-sub069.4%
associate-+l-69.4%
sub0-neg69.4%
neg-mul-169.4%
associate-/l*69.4%
associate-/r/69.4%
*-commutative69.4%
sub-neg69.4%
+-commutative69.4%
neg-sub069.4%
associate-+l-69.4%
sub0-neg69.4%
distribute-lft-neg-out69.4%
distribute-rgt-neg-in69.4%
Simplified69.6%
*-commutative69.6%
metadata-eval69.6%
distribute-lft-neg-in69.6%
distribute-rgt-neg-in69.6%
fma-def69.4%
+-commutative69.4%
distribute-rgt-neg-in69.4%
distribute-lft-neg-in69.4%
metadata-eval69.4%
*-commutative69.4%
Applied egg-rr69.4%
Taylor expanded in z around 0 69.4%
associate-/l*96.3%
Simplified96.3%
Final simplification93.4%
NOTE: x and y should be sorted in increasing order before calling this function. NOTE: z and t should be sorted in increasing order before calling this function. (FPCore (x y z t a) :precision binary64 (if (<= (* x y) 5e+248) (* (+ (* x y) (* z (* t -9.0))) (/ 0.5 a)) (* 0.5 (/ y (/ a x)))))
assert(x < y);
assert(z < t);
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x * y) <= 5e+248) {
tmp = ((x * y) + (z * (t * -9.0))) * (0.5 / a);
} else {
tmp = 0.5 * (y / (a / x));
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
NOTE: z and t should be sorted in increasing order before calling this function.
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 ((x * y) <= 5d+248) then
tmp = ((x * y) + (z * (t * (-9.0d0)))) * (0.5d0 / a)
else
tmp = 0.5d0 * (y / (a / x))
end if
code = tmp
end function
assert x < y;
assert z < t;
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x * y) <= 5e+248) {
tmp = ((x * y) + (z * (t * -9.0))) * (0.5 / a);
} else {
tmp = 0.5 * (y / (a / x));
}
return tmp;
}
[x, y] = sort([x, y]) [z, t] = sort([z, t]) def code(x, y, z, t, a): tmp = 0 if (x * y) <= 5e+248: tmp = ((x * y) + (z * (t * -9.0))) * (0.5 / a) else: tmp = 0.5 * (y / (a / x)) return tmp
x, y = sort([x, y]) z, t = sort([z, t]) function code(x, y, z, t, a) tmp = 0.0 if (Float64(x * y) <= 5e+248) tmp = Float64(Float64(Float64(x * y) + Float64(z * Float64(t * -9.0))) * Float64(0.5 / a)); else tmp = Float64(0.5 * Float64(y / Float64(a / x))); end return tmp end
x, y = num2cell(sort([x, y])){:}
z, t = num2cell(sort([z, t])){:}
function tmp_2 = code(x, y, z, t, a)
tmp = 0.0;
if ((x * y) <= 5e+248)
tmp = ((x * y) + (z * (t * -9.0))) * (0.5 / a);
else
tmp = 0.5 * (y / (a / x));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. NOTE: z and t should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := If[LessEqual[N[(x * y), $MachinePrecision], 5e+248], N[(N[(N[(x * y), $MachinePrecision] + N[(z * N[(t * -9.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(0.5 / a), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(y / N[(a / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
[z, t] = \mathsf{sort}([z, t])\\
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq 5 \cdot 10^{+248}:\\
\;\;\;\;\left(x \cdot y + z \cdot \left(t \cdot -9\right)\right) \cdot \frac{0.5}{a}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \frac{y}{\frac{a}{x}}\\
\end{array}
\end{array}
if (*.f64 x y) < 4.9999999999999996e248Initial program 92.7%
sub-neg92.7%
+-commutative92.7%
neg-sub092.7%
associate-+l-92.7%
sub0-neg92.7%
neg-mul-192.7%
associate-/l*92.3%
associate-/r/92.6%
*-commutative92.6%
sub-neg92.6%
+-commutative92.6%
neg-sub092.6%
associate-+l-92.6%
sub0-neg92.6%
distribute-lft-neg-out92.6%
distribute-rgt-neg-in92.6%
Simplified92.6%
*-commutative92.6%
metadata-eval92.6%
distribute-lft-neg-in92.6%
distribute-rgt-neg-in92.6%
fma-def92.6%
+-commutative92.6%
distribute-rgt-neg-in92.6%
distribute-lft-neg-in92.6%
metadata-eval92.6%
*-commutative92.6%
Applied egg-rr92.6%
if 4.9999999999999996e248 < (*.f64 x y) Initial program 69.4%
sub-neg69.4%
+-commutative69.4%
neg-sub069.4%
associate-+l-69.4%
sub0-neg69.4%
neg-mul-169.4%
associate-/l*69.4%
associate-/r/69.4%
*-commutative69.4%
sub-neg69.4%
+-commutative69.4%
neg-sub069.4%
associate-+l-69.4%
sub0-neg69.4%
distribute-lft-neg-out69.4%
distribute-rgt-neg-in69.4%
Simplified69.6%
*-commutative69.6%
metadata-eval69.6%
distribute-lft-neg-in69.6%
distribute-rgt-neg-in69.6%
fma-def69.4%
+-commutative69.4%
distribute-rgt-neg-in69.4%
distribute-lft-neg-in69.4%
metadata-eval69.4%
*-commutative69.4%
Applied egg-rr69.4%
Taylor expanded in z around 0 69.4%
associate-/l*96.3%
Simplified96.3%
Final simplification93.0%
NOTE: x and y should be sorted in increasing order before calling this function. NOTE: z and t should be sorted in increasing order before calling this function. (FPCore (x y z t a) :precision binary64 (if (<= (* x y) 5e+248) (/ (- (* x y) (* z (* t 9.0))) (* a 2.0)) (* 0.5 (/ y (/ a x)))))
assert(x < y);
assert(z < t);
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x * y) <= 5e+248) {
tmp = ((x * y) - (z * (t * 9.0))) / (a * 2.0);
} else {
tmp = 0.5 * (y / (a / x));
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
NOTE: z and t should be sorted in increasing order before calling this function.
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 ((x * y) <= 5d+248) then
tmp = ((x * y) - (z * (t * 9.0d0))) / (a * 2.0d0)
else
tmp = 0.5d0 * (y / (a / x))
end if
code = tmp
end function
assert x < y;
assert z < t;
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x * y) <= 5e+248) {
tmp = ((x * y) - (z * (t * 9.0))) / (a * 2.0);
} else {
tmp = 0.5 * (y / (a / x));
}
return tmp;
}
[x, y] = sort([x, y]) [z, t] = sort([z, t]) def code(x, y, z, t, a): tmp = 0 if (x * y) <= 5e+248: tmp = ((x * y) - (z * (t * 9.0))) / (a * 2.0) else: tmp = 0.5 * (y / (a / x)) return tmp
x, y = sort([x, y]) z, t = sort([z, t]) function code(x, y, z, t, a) tmp = 0.0 if (Float64(x * y) <= 5e+248) tmp = Float64(Float64(Float64(x * y) - Float64(z * Float64(t * 9.0))) / Float64(a * 2.0)); else tmp = Float64(0.5 * Float64(y / Float64(a / x))); end return tmp end
x, y = num2cell(sort([x, y])){:}
z, t = num2cell(sort([z, t])){:}
function tmp_2 = code(x, y, z, t, a)
tmp = 0.0;
if ((x * y) <= 5e+248)
tmp = ((x * y) - (z * (t * 9.0))) / (a * 2.0);
else
tmp = 0.5 * (y / (a / x));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. NOTE: z and t should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := If[LessEqual[N[(x * y), $MachinePrecision], 5e+248], N[(N[(N[(x * y), $MachinePrecision] - N[(z * N[(t * 9.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(y / N[(a / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
[z, t] = \mathsf{sort}([z, t])\\
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq 5 \cdot 10^{+248}:\\
\;\;\;\;\frac{x \cdot y - z \cdot \left(t \cdot 9\right)}{a \cdot 2}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \frac{y}{\frac{a}{x}}\\
\end{array}
\end{array}
if (*.f64 x y) < 4.9999999999999996e248Initial program 92.7%
associate-*l*92.6%
Simplified92.6%
if 4.9999999999999996e248 < (*.f64 x y) Initial program 69.4%
sub-neg69.4%
+-commutative69.4%
neg-sub069.4%
associate-+l-69.4%
sub0-neg69.4%
neg-mul-169.4%
associate-/l*69.4%
associate-/r/69.4%
*-commutative69.4%
sub-neg69.4%
+-commutative69.4%
neg-sub069.4%
associate-+l-69.4%
sub0-neg69.4%
distribute-lft-neg-out69.4%
distribute-rgt-neg-in69.4%
Simplified69.6%
*-commutative69.6%
metadata-eval69.6%
distribute-lft-neg-in69.6%
distribute-rgt-neg-in69.6%
fma-def69.4%
+-commutative69.4%
distribute-rgt-neg-in69.4%
distribute-lft-neg-in69.4%
metadata-eval69.4%
*-commutative69.4%
Applied egg-rr69.4%
Taylor expanded in z around 0 69.4%
associate-/l*96.3%
Simplified96.3%
Final simplification93.0%
NOTE: x and y should be sorted in increasing order before calling this function.
NOTE: z and t should be sorted in increasing order before calling this function.
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* 0.5 (* x (/ y a)))))
(if (<= y -1.35e-79)
t_1
(if (<= y 4.8e+14)
(* -4.5 (* z (/ t a)))
(if (or (<= y 5e+61) (not (<= y 3.1e+89)))
t_1
(* -4.5 (* t (/ z a))))))))assert(x < y);
assert(z < t);
double code(double x, double y, double z, double t, double a) {
double t_1 = 0.5 * (x * (y / a));
double tmp;
if (y <= -1.35e-79) {
tmp = t_1;
} else if (y <= 4.8e+14) {
tmp = -4.5 * (z * (t / a));
} else if ((y <= 5e+61) || !(y <= 3.1e+89)) {
tmp = t_1;
} else {
tmp = -4.5 * (t * (z / a));
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
NOTE: z and t should be sorted in increasing order before calling this function.
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 = 0.5d0 * (x * (y / a))
if (y <= (-1.35d-79)) then
tmp = t_1
else if (y <= 4.8d+14) then
tmp = (-4.5d0) * (z * (t / a))
else if ((y <= 5d+61) .or. (.not. (y <= 3.1d+89))) then
tmp = t_1
else
tmp = (-4.5d0) * (t * (z / a))
end if
code = tmp
end function
assert x < y;
assert z < t;
public static double code(double x, double y, double z, double t, double a) {
double t_1 = 0.5 * (x * (y / a));
double tmp;
if (y <= -1.35e-79) {
tmp = t_1;
} else if (y <= 4.8e+14) {
tmp = -4.5 * (z * (t / a));
} else if ((y <= 5e+61) || !(y <= 3.1e+89)) {
tmp = t_1;
} else {
tmp = -4.5 * (t * (z / a));
}
return tmp;
}
[x, y] = sort([x, y]) [z, t] = sort([z, t]) def code(x, y, z, t, a): t_1 = 0.5 * (x * (y / a)) tmp = 0 if y <= -1.35e-79: tmp = t_1 elif y <= 4.8e+14: tmp = -4.5 * (z * (t / a)) elif (y <= 5e+61) or not (y <= 3.1e+89): tmp = t_1 else: tmp = -4.5 * (t * (z / a)) return tmp
x, y = sort([x, y]) z, t = sort([z, t]) function code(x, y, z, t, a) t_1 = Float64(0.5 * Float64(x * Float64(y / a))) tmp = 0.0 if (y <= -1.35e-79) tmp = t_1; elseif (y <= 4.8e+14) tmp = Float64(-4.5 * Float64(z * Float64(t / a))); elseif ((y <= 5e+61) || !(y <= 3.1e+89)) tmp = t_1; else tmp = Float64(-4.5 * Float64(t * Float64(z / a))); end return tmp end
x, y = num2cell(sort([x, y])){:}
z, t = num2cell(sort([z, t])){:}
function tmp_2 = code(x, y, z, t, a)
t_1 = 0.5 * (x * (y / a));
tmp = 0.0;
if (y <= -1.35e-79)
tmp = t_1;
elseif (y <= 4.8e+14)
tmp = -4.5 * (z * (t / a));
elseif ((y <= 5e+61) || ~((y <= 3.1e+89)))
tmp = t_1;
else
tmp = -4.5 * (t * (z / a));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function.
NOTE: z and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(0.5 * N[(x * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.35e-79], t$95$1, If[LessEqual[y, 4.8e+14], N[(-4.5 * N[(z * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[y, 5e+61], N[Not[LessEqual[y, 3.1e+89]], $MachinePrecision]], t$95$1, N[(-4.5 * N[(t * N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
[z, t] = \mathsf{sort}([z, t])\\
\\
\begin{array}{l}
t_1 := 0.5 \cdot \left(x \cdot \frac{y}{a}\right)\\
\mathbf{if}\;y \leq -1.35 \cdot 10^{-79}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 4.8 \cdot 10^{+14}:\\
\;\;\;\;-4.5 \cdot \left(z \cdot \frac{t}{a}\right)\\
\mathbf{elif}\;y \leq 5 \cdot 10^{+61} \lor \neg \left(y \leq 3.1 \cdot 10^{+89}\right):\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;-4.5 \cdot \left(t \cdot \frac{z}{a}\right)\\
\end{array}
\end{array}
if y < -1.3500000000000001e-79 or 4.8e14 < y < 5.00000000000000018e61 or 3.1e89 < y Initial program 87.8%
sub-neg87.8%
+-commutative87.8%
neg-sub087.8%
associate-+l-87.8%
sub0-neg87.8%
neg-mul-187.8%
associate-/l*87.6%
associate-/r/87.7%
*-commutative87.7%
sub-neg87.7%
+-commutative87.7%
neg-sub087.7%
associate-+l-87.7%
sub0-neg87.7%
distribute-lft-neg-out87.7%
distribute-rgt-neg-in87.7%
Simplified87.8%
*-commutative87.8%
metadata-eval87.8%
distribute-lft-neg-in87.8%
distribute-rgt-neg-in87.8%
fma-def87.8%
+-commutative87.8%
distribute-rgt-neg-in87.8%
distribute-lft-neg-in87.8%
metadata-eval87.8%
*-commutative87.8%
Applied egg-rr87.8%
Taylor expanded in z around 0 66.2%
associate-*l/71.5%
*-commutative71.5%
Simplified71.5%
if -1.3500000000000001e-79 < y < 4.8e14Initial program 94.4%
sub-neg94.4%
+-commutative94.4%
neg-sub094.4%
associate-+l-94.4%
sub0-neg94.4%
neg-mul-194.4%
associate-/l*93.8%
associate-/r/94.3%
*-commutative94.3%
sub-neg94.3%
+-commutative94.3%
neg-sub094.3%
associate-+l-94.3%
sub0-neg94.3%
distribute-lft-neg-out94.3%
distribute-rgt-neg-in94.3%
Simplified94.3%
Taylor expanded in x around 0 70.7%
associate-/l*71.6%
associate-/r/69.3%
Simplified69.3%
if 5.00000000000000018e61 < y < 3.1e89Initial program 71.6%
sub-neg71.6%
+-commutative71.6%
neg-sub071.6%
associate-+l-71.6%
sub0-neg71.6%
neg-mul-171.6%
associate-/l*71.9%
associate-/r/71.9%
*-commutative71.9%
sub-neg71.9%
+-commutative71.9%
neg-sub071.9%
associate-+l-71.9%
sub0-neg71.9%
distribute-lft-neg-out71.9%
distribute-rgt-neg-in71.9%
Simplified72.5%
Taylor expanded in x around 0 44.6%
associate-/l*71.6%
associate-/r/71.8%
Simplified71.8%
associate-*l/44.6%
*-commutative44.6%
Applied egg-rr44.6%
Taylor expanded in z around 0 44.6%
associate-*r/71.4%
Simplified71.4%
Final simplification70.6%
NOTE: x and y should be sorted in increasing order before calling this function.
NOTE: z and t should be sorted in increasing order before calling this function.
(FPCore (x y z t a)
:precision binary64
(if (<= y -1.05e-80)
(* 0.5 (/ y (/ a x)))
(if (<= y 8.8e+16)
(* -4.5 (* z (/ t a)))
(if (or (<= y 5.1e+61) (not (<= y 1e+88)))
(* 0.5 (* x (/ y a)))
(* -4.5 (* t (/ z a)))))))assert(x < y);
assert(z < t);
double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -1.05e-80) {
tmp = 0.5 * (y / (a / x));
} else if (y <= 8.8e+16) {
tmp = -4.5 * (z * (t / a));
} else if ((y <= 5.1e+61) || !(y <= 1e+88)) {
tmp = 0.5 * (x * (y / a));
} else {
tmp = -4.5 * (t * (z / a));
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
NOTE: z and t should be sorted in increasing order before calling this function.
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.05d-80)) then
tmp = 0.5d0 * (y / (a / x))
else if (y <= 8.8d+16) then
tmp = (-4.5d0) * (z * (t / a))
else if ((y <= 5.1d+61) .or. (.not. (y <= 1d+88))) then
tmp = 0.5d0 * (x * (y / a))
else
tmp = (-4.5d0) * (t * (z / a))
end if
code = tmp
end function
assert x < y;
assert z < t;
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -1.05e-80) {
tmp = 0.5 * (y / (a / x));
} else if (y <= 8.8e+16) {
tmp = -4.5 * (z * (t / a));
} else if ((y <= 5.1e+61) || !(y <= 1e+88)) {
tmp = 0.5 * (x * (y / a));
} else {
tmp = -4.5 * (t * (z / a));
}
return tmp;
}
[x, y] = sort([x, y]) [z, t] = sort([z, t]) def code(x, y, z, t, a): tmp = 0 if y <= -1.05e-80: tmp = 0.5 * (y / (a / x)) elif y <= 8.8e+16: tmp = -4.5 * (z * (t / a)) elif (y <= 5.1e+61) or not (y <= 1e+88): tmp = 0.5 * (x * (y / a)) else: tmp = -4.5 * (t * (z / a)) return tmp
x, y = sort([x, y]) z, t = sort([z, t]) function code(x, y, z, t, a) tmp = 0.0 if (y <= -1.05e-80) tmp = Float64(0.5 * Float64(y / Float64(a / x))); elseif (y <= 8.8e+16) tmp = Float64(-4.5 * Float64(z * Float64(t / a))); elseif ((y <= 5.1e+61) || !(y <= 1e+88)) tmp = Float64(0.5 * Float64(x * Float64(y / a))); else tmp = Float64(-4.5 * Float64(t * Float64(z / a))); end return tmp end
x, y = num2cell(sort([x, y])){:}
z, t = num2cell(sort([z, t])){:}
function tmp_2 = code(x, y, z, t, a)
tmp = 0.0;
if (y <= -1.05e-80)
tmp = 0.5 * (y / (a / x));
elseif (y <= 8.8e+16)
tmp = -4.5 * (z * (t / a));
elseif ((y <= 5.1e+61) || ~((y <= 1e+88)))
tmp = 0.5 * (x * (y / a));
else
tmp = -4.5 * (t * (z / a));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. NOTE: z and t should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := If[LessEqual[y, -1.05e-80], N[(0.5 * N[(y / N[(a / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 8.8e+16], N[(-4.5 * N[(z * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[y, 5.1e+61], N[Not[LessEqual[y, 1e+88]], $MachinePrecision]], N[(0.5 * N[(x * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-4.5 * N[(t * N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
[z, t] = \mathsf{sort}([z, t])\\
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.05 \cdot 10^{-80}:\\
\;\;\;\;0.5 \cdot \frac{y}{\frac{a}{x}}\\
\mathbf{elif}\;y \leq 8.8 \cdot 10^{+16}:\\
\;\;\;\;-4.5 \cdot \left(z \cdot \frac{t}{a}\right)\\
\mathbf{elif}\;y \leq 5.1 \cdot 10^{+61} \lor \neg \left(y \leq 10^{+88}\right):\\
\;\;\;\;0.5 \cdot \left(x \cdot \frac{y}{a}\right)\\
\mathbf{else}:\\
\;\;\;\;-4.5 \cdot \left(t \cdot \frac{z}{a}\right)\\
\end{array}
\end{array}
if y < -1.05000000000000001e-80Initial program 86.3%
sub-neg86.3%
+-commutative86.3%
neg-sub086.3%
associate-+l-86.3%
sub0-neg86.3%
neg-mul-186.3%
associate-/l*86.2%
associate-/r/86.2%
*-commutative86.2%
sub-neg86.2%
+-commutative86.2%
neg-sub086.2%
associate-+l-86.2%
sub0-neg86.2%
distribute-lft-neg-out86.2%
distribute-rgt-neg-in86.2%
Simplified86.3%
*-commutative86.3%
metadata-eval86.3%
distribute-lft-neg-in86.3%
distribute-rgt-neg-in86.3%
fma-def86.2%
+-commutative86.2%
distribute-rgt-neg-in86.2%
distribute-lft-neg-in86.2%
metadata-eval86.2%
*-commutative86.2%
Applied egg-rr86.2%
Taylor expanded in z around 0 60.0%
associate-/l*64.4%
Simplified64.4%
if -1.05000000000000001e-80 < y < 8.8e16Initial program 94.4%
sub-neg94.4%
+-commutative94.4%
neg-sub094.4%
associate-+l-94.4%
sub0-neg94.4%
neg-mul-194.4%
associate-/l*93.8%
associate-/r/94.3%
*-commutative94.3%
sub-neg94.3%
+-commutative94.3%
neg-sub094.3%
associate-+l-94.3%
sub0-neg94.3%
distribute-lft-neg-out94.3%
distribute-rgt-neg-in94.3%
Simplified94.3%
Taylor expanded in x around 0 70.7%
associate-/l*71.6%
associate-/r/69.3%
Simplified69.3%
if 8.8e16 < y < 5.1000000000000001e61 or 9.99999999999999959e87 < y Initial program 90.0%
sub-neg90.0%
+-commutative90.0%
neg-sub090.0%
associate-+l-90.0%
sub0-neg90.0%
neg-mul-190.0%
associate-/l*89.8%
associate-/r/89.9%
*-commutative89.9%
sub-neg89.9%
+-commutative89.9%
neg-sub089.9%
associate-+l-89.9%
sub0-neg89.9%
distribute-lft-neg-out89.9%
distribute-rgt-neg-in89.9%
Simplified90.0%
*-commutative90.0%
metadata-eval90.0%
distribute-lft-neg-in90.0%
distribute-rgt-neg-in90.0%
fma-def90.0%
+-commutative90.0%
distribute-rgt-neg-in90.0%
distribute-lft-neg-in90.0%
metadata-eval90.0%
*-commutative90.0%
Applied egg-rr90.0%
Taylor expanded in z around 0 75.2%
associate-*l/81.9%
*-commutative81.9%
Simplified81.9%
if 5.1000000000000001e61 < y < 9.99999999999999959e87Initial program 71.6%
sub-neg71.6%
+-commutative71.6%
neg-sub071.6%
associate-+l-71.6%
sub0-neg71.6%
neg-mul-171.6%
associate-/l*71.9%
associate-/r/71.9%
*-commutative71.9%
sub-neg71.9%
+-commutative71.9%
neg-sub071.9%
associate-+l-71.9%
sub0-neg71.9%
distribute-lft-neg-out71.9%
distribute-rgt-neg-in71.9%
Simplified72.5%
Taylor expanded in x around 0 44.6%
associate-/l*71.6%
associate-/r/71.8%
Simplified71.8%
associate-*l/44.6%
*-commutative44.6%
Applied egg-rr44.6%
Taylor expanded in z around 0 44.6%
associate-*r/71.4%
Simplified71.4%
Final simplification70.6%
NOTE: x and y should be sorted in increasing order before calling this function. NOTE: z and t should be sorted in increasing order before calling this function. (FPCore (x y z t a) :precision binary64 (if (<= (* x y) -2e+29) (* y (/ (* x 0.5) a)) (if (<= (* x y) 1e+54) (* -4.5 (* z (/ t a))) (* 0.5 (* x (/ y a))))))
assert(x < y);
assert(z < t);
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x * y) <= -2e+29) {
tmp = y * ((x * 0.5) / a);
} else if ((x * y) <= 1e+54) {
tmp = -4.5 * (z * (t / a));
} else {
tmp = 0.5 * (x * (y / a));
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
NOTE: z and t should be sorted in increasing order before calling this function.
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 ((x * y) <= (-2d+29)) then
tmp = y * ((x * 0.5d0) / a)
else if ((x * y) <= 1d+54) then
tmp = (-4.5d0) * (z * (t / a))
else
tmp = 0.5d0 * (x * (y / a))
end if
code = tmp
end function
assert x < y;
assert z < t;
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x * y) <= -2e+29) {
tmp = y * ((x * 0.5) / a);
} else if ((x * y) <= 1e+54) {
tmp = -4.5 * (z * (t / a));
} else {
tmp = 0.5 * (x * (y / a));
}
return tmp;
}
[x, y] = sort([x, y]) [z, t] = sort([z, t]) def code(x, y, z, t, a): tmp = 0 if (x * y) <= -2e+29: tmp = y * ((x * 0.5) / a) elif (x * y) <= 1e+54: tmp = -4.5 * (z * (t / a)) else: tmp = 0.5 * (x * (y / a)) return tmp
x, y = sort([x, y]) z, t = sort([z, t]) function code(x, y, z, t, a) tmp = 0.0 if (Float64(x * y) <= -2e+29) tmp = Float64(y * Float64(Float64(x * 0.5) / a)); elseif (Float64(x * y) <= 1e+54) tmp = Float64(-4.5 * Float64(z * Float64(t / a))); else tmp = Float64(0.5 * Float64(x * Float64(y / a))); end return tmp end
x, y = num2cell(sort([x, y])){:}
z, t = num2cell(sort([z, t])){:}
function tmp_2 = code(x, y, z, t, a)
tmp = 0.0;
if ((x * y) <= -2e+29)
tmp = y * ((x * 0.5) / a);
elseif ((x * y) <= 1e+54)
tmp = -4.5 * (z * (t / a));
else
tmp = 0.5 * (x * (y / a));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. NOTE: z and t should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := If[LessEqual[N[(x * y), $MachinePrecision], -2e+29], N[(y * N[(N[(x * 0.5), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 1e+54], N[(-4.5 * N[(z * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(x * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
[z, t] = \mathsf{sort}([z, t])\\
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -2 \cdot 10^{+29}:\\
\;\;\;\;y \cdot \frac{x \cdot 0.5}{a}\\
\mathbf{elif}\;x \cdot y \leq 10^{+54}:\\
\;\;\;\;-4.5 \cdot \left(z \cdot \frac{t}{a}\right)\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(x \cdot \frac{y}{a}\right)\\
\end{array}
\end{array}
if (*.f64 x y) < -1.99999999999999983e29Initial program 89.1%
sub-neg89.1%
+-commutative89.1%
neg-sub089.1%
associate-+l-89.1%
sub0-neg89.1%
neg-mul-189.1%
associate-/l*89.0%
associate-/r/89.0%
*-commutative89.0%
sub-neg89.0%
+-commutative89.0%
neg-sub089.0%
associate-+l-89.0%
sub0-neg89.0%
distribute-lft-neg-out89.0%
distribute-rgt-neg-in89.0%
Simplified89.1%
Taylor expanded in x around 0 87.2%
Taylor expanded in t around 0 81.4%
associate-*r/81.4%
associate-*l/81.4%
*-commutative81.4%
associate-*r*83.0%
*-commutative83.0%
associate-*l/83.1%
Simplified83.1%
if -1.99999999999999983e29 < (*.f64 x y) < 1.0000000000000001e54Initial program 93.0%
sub-neg93.0%
+-commutative93.0%
neg-sub093.0%
associate-+l-93.0%
sub0-neg93.0%
neg-mul-193.0%
associate-/l*92.5%
associate-/r/92.9%
*-commutative92.9%
sub-neg92.9%
+-commutative92.9%
neg-sub092.9%
associate-+l-92.9%
sub0-neg92.9%
distribute-lft-neg-out92.9%
distribute-rgt-neg-in92.9%
Simplified92.9%
Taylor expanded in x around 0 75.9%
associate-/l*77.9%
associate-/r/74.4%
Simplified74.4%
if 1.0000000000000001e54 < (*.f64 x y) Initial program 84.5%
sub-neg84.5%
+-commutative84.5%
neg-sub084.5%
associate-+l-84.5%
sub0-neg84.5%
neg-mul-184.5%
associate-/l*84.4%
associate-/r/84.5%
*-commutative84.5%
sub-neg84.5%
+-commutative84.5%
neg-sub084.5%
associate-+l-84.5%
sub0-neg84.5%
distribute-lft-neg-out84.5%
distribute-rgt-neg-in84.5%
Simplified84.5%
*-commutative84.5%
metadata-eval84.5%
distribute-lft-neg-in84.5%
distribute-rgt-neg-in84.5%
fma-def84.5%
+-commutative84.5%
distribute-rgt-neg-in84.5%
distribute-lft-neg-in84.5%
metadata-eval84.5%
*-commutative84.5%
Applied egg-rr84.5%
Taylor expanded in z around 0 79.1%
associate-*l/85.2%
*-commutative85.2%
Simplified85.2%
Final simplification78.9%
NOTE: x and y should be sorted in increasing order before calling this function. NOTE: z and t should be sorted in increasing order before calling this function. (FPCore (x y z t a) :precision binary64 (if (<= t 3.15e+153) (* -4.5 (* t (/ z a))) (* -4.5 (* z (/ t a)))))
assert(x < y);
assert(z < t);
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= 3.15e+153) {
tmp = -4.5 * (t * (z / a));
} else {
tmp = -4.5 * (z * (t / a));
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
NOTE: z and t should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (t <= 3.15d+153) then
tmp = (-4.5d0) * (t * (z / a))
else
tmp = (-4.5d0) * (z * (t / a))
end if
code = tmp
end function
assert x < y;
assert z < t;
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= 3.15e+153) {
tmp = -4.5 * (t * (z / a));
} else {
tmp = -4.5 * (z * (t / a));
}
return tmp;
}
[x, y] = sort([x, y]) [z, t] = sort([z, t]) def code(x, y, z, t, a): tmp = 0 if t <= 3.15e+153: tmp = -4.5 * (t * (z / a)) else: tmp = -4.5 * (z * (t / a)) return tmp
x, y = sort([x, y]) z, t = sort([z, t]) function code(x, y, z, t, a) tmp = 0.0 if (t <= 3.15e+153) tmp = Float64(-4.5 * Float64(t * Float64(z / a))); else tmp = Float64(-4.5 * Float64(z * Float64(t / a))); end return tmp end
x, y = num2cell(sort([x, y])){:}
z, t = num2cell(sort([z, t])){:}
function tmp_2 = code(x, y, z, t, a)
tmp = 0.0;
if (t <= 3.15e+153)
tmp = -4.5 * (t * (z / a));
else
tmp = -4.5 * (z * (t / a));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. NOTE: z and t should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := If[LessEqual[t, 3.15e+153], N[(-4.5 * N[(t * N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-4.5 * N[(z * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
[z, t] = \mathsf{sort}([z, t])\\
\\
\begin{array}{l}
\mathbf{if}\;t \leq 3.15 \cdot 10^{+153}:\\
\;\;\;\;-4.5 \cdot \left(t \cdot \frac{z}{a}\right)\\
\mathbf{else}:\\
\;\;\;\;-4.5 \cdot \left(z \cdot \frac{t}{a}\right)\\
\end{array}
\end{array}
if t < 3.1500000000000001e153Initial program 92.9%
sub-neg92.9%
+-commutative92.9%
neg-sub092.9%
associate-+l-92.9%
sub0-neg92.9%
neg-mul-192.9%
associate-/l*92.5%
associate-/r/92.8%
*-commutative92.8%
sub-neg92.8%
+-commutative92.8%
neg-sub092.8%
associate-+l-92.8%
sub0-neg92.8%
distribute-lft-neg-out92.8%
distribute-rgt-neg-in92.8%
Simplified92.8%
Taylor expanded in x around 0 46.3%
associate-/l*49.2%
associate-/r/46.0%
Simplified46.0%
associate-*l/46.3%
*-commutative46.3%
Applied egg-rr46.3%
Taylor expanded in z around 0 46.3%
associate-*r/49.3%
Simplified49.3%
if 3.1500000000000001e153 < t Initial program 72.8%
sub-neg72.8%
+-commutative72.8%
neg-sub072.8%
associate-+l-72.8%
sub0-neg72.8%
neg-mul-172.8%
associate-/l*72.8%
associate-/r/72.8%
*-commutative72.8%
sub-neg72.8%
+-commutative72.8%
neg-sub072.8%
associate-+l-72.8%
sub0-neg72.8%
distribute-lft-neg-out72.8%
distribute-rgt-neg-in72.8%
Simplified73.0%
Taylor expanded in x around 0 53.4%
associate-/l*63.8%
associate-/r/72.0%
Simplified72.0%
Final simplification52.4%
NOTE: x and y should be sorted in increasing order before calling this function. NOTE: z and t should be sorted in increasing order before calling this function. (FPCore (x y z t a) :precision binary64 (* -4.5 (* t (/ z a))))
assert(x < y);
assert(z < t);
double code(double x, double y, double z, double t, double a) {
return -4.5 * (t * (z / a));
}
NOTE: x and y should be sorted in increasing order before calling this function.
NOTE: z and t should be sorted in increasing order before calling this function.
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 = (-4.5d0) * (t * (z / a))
end function
assert x < y;
assert z < t;
public static double code(double x, double y, double z, double t, double a) {
return -4.5 * (t * (z / a));
}
[x, y] = sort([x, y]) [z, t] = sort([z, t]) def code(x, y, z, t, a): return -4.5 * (t * (z / a))
x, y = sort([x, y]) z, t = sort([z, t]) function code(x, y, z, t, a) return Float64(-4.5 * Float64(t * Float64(z / a))) end
x, y = num2cell(sort([x, y])){:}
z, t = num2cell(sort([z, t])){:}
function tmp = code(x, y, z, t, a)
tmp = -4.5 * (t * (z / a));
end
NOTE: x and y should be sorted in increasing order before calling this function. NOTE: z and t should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := N[(-4.5 * N[(t * N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
[z, t] = \mathsf{sort}([z, t])\\
\\
-4.5 \cdot \left(t \cdot \frac{z}{a}\right)
\end{array}
Initial program 90.1%
sub-neg90.1%
+-commutative90.1%
neg-sub090.1%
associate-+l-90.1%
sub0-neg90.1%
neg-mul-190.1%
associate-/l*89.8%
associate-/r/90.1%
*-commutative90.1%
sub-neg90.1%
+-commutative90.1%
neg-sub090.1%
associate-+l-90.1%
sub0-neg90.1%
distribute-lft-neg-out90.1%
distribute-rgt-neg-in90.1%
Simplified90.1%
Taylor expanded in x around 0 47.2%
associate-/l*51.2%
associate-/r/49.5%
Simplified49.5%
associate-*l/47.2%
*-commutative47.2%
Applied egg-rr47.2%
Taylor expanded in z around 0 47.2%
associate-*r/51.3%
Simplified51.3%
Final simplification51.3%
(FPCore (x y z t a)
:precision binary64
(if (< a -2.090464557976709e+86)
(- (* 0.5 (/ (* y x) a)) (* 4.5 (/ t (/ a z))))
(if (< a 2.144030707833976e+99)
(/ (- (* x y) (* z (* 9.0 t))) (* a 2.0))
(- (* (/ y a) (* x 0.5)) (* (/ t a) (* z 4.5))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a < -2.090464557976709e+86) {
tmp = (0.5 * ((y * x) / a)) - (4.5 * (t / (a / z)));
} else if (a < 2.144030707833976e+99) {
tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0);
} else {
tmp = ((y / a) * (x * 0.5)) - ((t / a) * (z * 4.5));
}
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.090464557976709d+86)) then
tmp = (0.5d0 * ((y * x) / a)) - (4.5d0 * (t / (a / z)))
else if (a < 2.144030707833976d+99) then
tmp = ((x * y) - (z * (9.0d0 * t))) / (a * 2.0d0)
else
tmp = ((y / a) * (x * 0.5d0)) - ((t / a) * (z * 4.5d0))
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.090464557976709e+86) {
tmp = (0.5 * ((y * x) / a)) - (4.5 * (t / (a / z)));
} else if (a < 2.144030707833976e+99) {
tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0);
} else {
tmp = ((y / a) * (x * 0.5)) - ((t / a) * (z * 4.5));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a < -2.090464557976709e+86: tmp = (0.5 * ((y * x) / a)) - (4.5 * (t / (a / z))) elif a < 2.144030707833976e+99: tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0) else: tmp = ((y / a) * (x * 0.5)) - ((t / a) * (z * 4.5)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a < -2.090464557976709e+86) tmp = Float64(Float64(0.5 * Float64(Float64(y * x) / a)) - Float64(4.5 * Float64(t / Float64(a / z)))); elseif (a < 2.144030707833976e+99) tmp = Float64(Float64(Float64(x * y) - Float64(z * Float64(9.0 * t))) / Float64(a * 2.0)); else tmp = Float64(Float64(Float64(y / a) * Float64(x * 0.5)) - Float64(Float64(t / a) * Float64(z * 4.5))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a < -2.090464557976709e+86) tmp = (0.5 * ((y * x) / a)) - (4.5 * (t / (a / z))); elseif (a < 2.144030707833976e+99) tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0); else tmp = ((y / a) * (x * 0.5)) - ((t / a) * (z * 4.5)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Less[a, -2.090464557976709e+86], N[(N[(0.5 * N[(N[(y * x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] - N[(4.5 * N[(t / N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Less[a, 2.144030707833976e+99], N[(N[(N[(x * y), $MachinePrecision] - N[(z * N[(9.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(N[(y / a), $MachinePrecision] * N[(x * 0.5), $MachinePrecision]), $MachinePrecision] - N[(N[(t / a), $MachinePrecision] * N[(z * 4.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a < -2.090464557976709 \cdot 10^{+86}:\\
\;\;\;\;0.5 \cdot \frac{y \cdot x}{a} - 4.5 \cdot \frac{t}{\frac{a}{z}}\\
\mathbf{elif}\;a < 2.144030707833976 \cdot 10^{+99}:\\
\;\;\;\;\frac{x \cdot y - z \cdot \left(9 \cdot t\right)}{a \cdot 2}\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{a} \cdot \left(x \cdot 0.5\right) - \frac{t}{a} \cdot \left(z \cdot 4.5\right)\\
\end{array}
\end{array}
herbie shell --seed 2023229
(FPCore (x y z t a)
:name "Diagrams.Solve.Polynomial:cubForm from diagrams-solve-0.1, I"
:precision binary64
:herbie-target
(if (< a -2.090464557976709e+86) (- (* 0.5 (/ (* y x) a)) (* 4.5 (/ t (/ a z)))) (if (< a 2.144030707833976e+99) (/ (- (* x y) (* z (* 9.0 t))) (* a 2.0)) (- (* (/ y a) (* x 0.5)) (* (/ t a) (* z 4.5)))))
(/ (- (* x y) (* (* z 9.0) t)) (* a 2.0)))