
(FPCore (x y z t a) :precision binary64 (/ (* (* x y) z) (sqrt (- (* z z) (* t a)))))
double code(double x, double y, double z, double t, double a) {
return ((x * y) * z) / sqrt(((z * z) - (t * a)));
}
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) / sqrt(((z * z) - (t * a)))
end function
public static double code(double x, double y, double z, double t, double a) {
return ((x * y) * z) / Math.sqrt(((z * z) - (t * a)));
}
def code(x, y, z, t, a): return ((x * y) * z) / math.sqrt(((z * z) - (t * a)))
function code(x, y, z, t, a) return Float64(Float64(Float64(x * y) * z) / sqrt(Float64(Float64(z * z) - Float64(t * a)))) end
function tmp = code(x, y, z, t, a) tmp = ((x * y) * z) / sqrt(((z * z) - (t * a))); end
code[x_, y_, z_, t_, a_] := N[(N[(N[(x * y), $MachinePrecision] * z), $MachinePrecision] / N[Sqrt[N[(N[(z * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(x \cdot y\right) \cdot z}{\sqrt{z \cdot z - t \cdot a}}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 17 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (/ (* (* x y) z) (sqrt (- (* z z) (* t a)))))
double code(double x, double y, double z, double t, double a) {
return ((x * y) * z) / sqrt(((z * z) - (t * a)));
}
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) / sqrt(((z * z) - (t * a)))
end function
public static double code(double x, double y, double z, double t, double a) {
return ((x * y) * z) / Math.sqrt(((z * z) - (t * a)));
}
def code(x, y, z, t, a): return ((x * y) * z) / math.sqrt(((z * z) - (t * a)))
function code(x, y, z, t, a) return Float64(Float64(Float64(x * y) * z) / sqrt(Float64(Float64(z * z) - Float64(t * a)))) end
function tmp = code(x, y, z, t, a) tmp = ((x * y) * z) / sqrt(((z * z) - (t * a))); end
code[x_, y_, z_, t_, a_] := N[(N[(N[(x * y), $MachinePrecision] * z), $MachinePrecision] / N[Sqrt[N[(N[(z * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(x \cdot y\right) \cdot z}{\sqrt{z \cdot z - t \cdot a}}
\end{array}
(FPCore (x y z t a)
:precision binary64
(if (<= z -1e+133)
(* (/ z (- (/ 0.5 (* (/ 1.0 t) (/ z a))) z)) (* y x))
(if (<= z 6e+30)
(* (* y x) (/ z (sqrt (- (pow z 2.0) (* t a)))))
(* y (* x (/ z (+ z (* -0.5 (* a (/ t z))))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1e+133) {
tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x);
} else if (z <= 6e+30) {
tmp = (y * x) * (z / sqrt((pow(z, 2.0) - (t * a))));
} else {
tmp = y * (x * (z / (z + (-0.5 * (a * (t / z))))));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-1d+133)) then
tmp = (z / ((0.5d0 / ((1.0d0 / t) * (z / a))) - z)) * (y * x)
else if (z <= 6d+30) then
tmp = (y * x) * (z / sqrt(((z ** 2.0d0) - (t * a))))
else
tmp = y * (x * (z / (z + ((-0.5d0) * (a * (t / z))))))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1e+133) {
tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x);
} else if (z <= 6e+30) {
tmp = (y * x) * (z / Math.sqrt((Math.pow(z, 2.0) - (t * a))));
} else {
tmp = y * (x * (z / (z + (-0.5 * (a * (t / z))))));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1e+133: tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x) elif z <= 6e+30: tmp = (y * x) * (z / math.sqrt((math.pow(z, 2.0) - (t * a)))) else: tmp = y * (x * (z / (z + (-0.5 * (a * (t / z)))))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1e+133) tmp = Float64(Float64(z / Float64(Float64(0.5 / Float64(Float64(1.0 / t) * Float64(z / a))) - z)) * Float64(y * x)); elseif (z <= 6e+30) tmp = Float64(Float64(y * x) * Float64(z / sqrt(Float64((z ^ 2.0) - Float64(t * a))))); else tmp = Float64(y * Float64(x * Float64(z / Float64(z + Float64(-0.5 * Float64(a * Float64(t / z))))))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1e+133) tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x); elseif (z <= 6e+30) tmp = (y * x) * (z / sqrt(((z ^ 2.0) - (t * a)))); else tmp = y * (x * (z / (z + (-0.5 * (a * (t / z)))))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1e+133], N[(N[(z / N[(N[(0.5 / N[(N[(1.0 / t), $MachinePrecision] * N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]), $MachinePrecision] * N[(y * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 6e+30], N[(N[(y * x), $MachinePrecision] * N[(z / N[Sqrt[N[(N[Power[z, 2.0], $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * N[(x * N[(z / N[(z + N[(-0.5 * N[(a * N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1 \cdot 10^{+133}:\\
\;\;\;\;\frac{z}{\frac{0.5}{\frac{1}{t} \cdot \frac{z}{a}} - z} \cdot \left(y \cdot x\right)\\
\mathbf{elif}\;z \leq 6 \cdot 10^{+30}:\\
\;\;\;\;\left(y \cdot x\right) \cdot \frac{z}{\sqrt{{z}^{2} - t \cdot a}}\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(x \cdot \frac{z}{z + -0.5 \cdot \left(a \cdot \frac{t}{z}\right)}\right)\\
\end{array}
\end{array}
if z < -1e133Initial program 14.5%
associate-*l/19.4%
associate-/l*19.6%
associate-*l/18.6%
associate-*r/19.6%
*-commutative19.6%
associate-/r/19.6%
associate-*l*19.4%
pow219.4%
Applied egg-rr19.4%
Taylor expanded in z around -inf 84.1%
+-commutative84.1%
mul-1-neg84.1%
sub-neg84.1%
associate-/l*93.9%
associate-*r/93.9%
associate-/l*93.9%
associate-/l/84.1%
Simplified84.1%
*-un-lft-identity84.1%
*-commutative84.1%
times-frac93.9%
Applied egg-rr93.9%
if -1e133 < z < 5.99999999999999956e30Initial program 86.4%
associate-*l/89.9%
associate-/l*86.9%
associate-*l/83.9%
associate-*r/87.2%
*-commutative87.2%
associate-/r/89.7%
associate-*l*91.9%
pow291.9%
Applied egg-rr91.9%
if 5.99999999999999956e30 < z Initial program 45.0%
associate-*l/46.4%
associate-/l*45.3%
associate-*l/42.1%
associate-*r/45.4%
associate-/r/49.5%
associate-*r*49.5%
pow249.5%
Applied egg-rr49.5%
Taylor expanded in z around inf 92.7%
associate-*r/98.6%
Simplified98.6%
Final simplification94.0%
(FPCore (x y z t a)
:precision binary64
(if (<= z -1.12e+49)
(* (/ z (- (/ 0.5 (* (/ 1.0 t) (/ z a))) z)) (* y x))
(if (<= z 6e+30)
(* x (/ z (/ (sqrt (- (* z z) (* t a))) y)))
(* y (* x (/ z (+ z (* -0.5 (* a (/ t z))))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.12e+49) {
tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x);
} else if (z <= 6e+30) {
tmp = x * (z / (sqrt(((z * z) - (t * a))) / y));
} else {
tmp = y * (x * (z / (z + (-0.5 * (a * (t / z))))));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-1.12d+49)) then
tmp = (z / ((0.5d0 / ((1.0d0 / t) * (z / a))) - z)) * (y * x)
else if (z <= 6d+30) then
tmp = x * (z / (sqrt(((z * z) - (t * a))) / y))
else
tmp = y * (x * (z / (z + ((-0.5d0) * (a * (t / z))))))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.12e+49) {
tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x);
} else if (z <= 6e+30) {
tmp = x * (z / (Math.sqrt(((z * z) - (t * a))) / y));
} else {
tmp = y * (x * (z / (z + (-0.5 * (a * (t / z))))));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1.12e+49: tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x) elif z <= 6e+30: tmp = x * (z / (math.sqrt(((z * z) - (t * a))) / y)) else: tmp = y * (x * (z / (z + (-0.5 * (a * (t / z)))))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.12e+49) tmp = Float64(Float64(z / Float64(Float64(0.5 / Float64(Float64(1.0 / t) * Float64(z / a))) - z)) * Float64(y * x)); elseif (z <= 6e+30) tmp = Float64(x * Float64(z / Float64(sqrt(Float64(Float64(z * z) - Float64(t * a))) / y))); else tmp = Float64(y * Float64(x * Float64(z / Float64(z + Float64(-0.5 * Float64(a * Float64(t / z))))))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1.12e+49) tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x); elseif (z <= 6e+30) tmp = x * (z / (sqrt(((z * z) - (t * a))) / y)); else tmp = y * (x * (z / (z + (-0.5 * (a * (t / z)))))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.12e+49], N[(N[(z / N[(N[(0.5 / N[(N[(1.0 / t), $MachinePrecision] * N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]), $MachinePrecision] * N[(y * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 6e+30], N[(x * N[(z / N[(N[Sqrt[N[(N[(z * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * N[(x * N[(z / N[(z + N[(-0.5 * N[(a * N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.12 \cdot 10^{+49}:\\
\;\;\;\;\frac{z}{\frac{0.5}{\frac{1}{t} \cdot \frac{z}{a}} - z} \cdot \left(y \cdot x\right)\\
\mathbf{elif}\;z \leq 6 \cdot 10^{+30}:\\
\;\;\;\;x \cdot \frac{z}{\frac{\sqrt{z \cdot z - t \cdot a}}{y}}\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(x \cdot \frac{z}{z + -0.5 \cdot \left(a \cdot \frac{t}{z}\right)}\right)\\
\end{array}
\end{array}
if z < -1.12000000000000005e49Initial program 39.1%
associate-*l/48.8%
associate-/l*46.0%
associate-*l/44.1%
associate-*r/47.5%
*-commutative47.5%
associate-/r/50.4%
associate-*l*50.2%
pow250.2%
Applied egg-rr50.2%
Taylor expanded in z around -inf 88.8%
+-commutative88.8%
mul-1-neg88.8%
sub-neg88.8%
associate-/l*94.9%
associate-*r/94.9%
associate-/l*94.9%
associate-/l/88.8%
Simplified88.8%
*-un-lft-identity88.8%
*-commutative88.8%
times-frac94.9%
Applied egg-rr94.9%
if -1.12000000000000005e49 < z < 5.99999999999999956e30Initial program 88.0%
associate-*l*84.7%
associate-*r/86.4%
*-commutative86.4%
associate-/l*86.0%
Simplified86.0%
if 5.99999999999999956e30 < z Initial program 45.0%
associate-*l/46.4%
associate-/l*45.3%
associate-*l/42.1%
associate-*r/45.4%
associate-/r/49.5%
associate-*r*49.5%
pow249.5%
Applied egg-rr49.5%
Taylor expanded in z around inf 92.7%
associate-*r/98.6%
Simplified98.6%
Final simplification91.7%
(FPCore (x y z t a)
:precision binary64
(if (<= z -4.8e+49)
(* (/ z (- (/ 0.5 (* (/ 1.0 t) (/ z a))) z)) (* y x))
(if (<= z 6e+30)
(* z (/ (* y x) (sqrt (- (* z z) (* t a)))))
(* y (* x (/ z (+ z (* -0.5 (* a (/ t z))))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -4.8e+49) {
tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x);
} else if (z <= 6e+30) {
tmp = z * ((y * x) / sqrt(((z * z) - (t * a))));
} else {
tmp = y * (x * (z / (z + (-0.5 * (a * (t / z))))));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-4.8d+49)) then
tmp = (z / ((0.5d0 / ((1.0d0 / t) * (z / a))) - z)) * (y * x)
else if (z <= 6d+30) then
tmp = z * ((y * x) / sqrt(((z * z) - (t * a))))
else
tmp = y * (x * (z / (z + ((-0.5d0) * (a * (t / z))))))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -4.8e+49) {
tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x);
} else if (z <= 6e+30) {
tmp = z * ((y * x) / Math.sqrt(((z * z) - (t * a))));
} else {
tmp = y * (x * (z / (z + (-0.5 * (a * (t / z))))));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -4.8e+49: tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x) elif z <= 6e+30: tmp = z * ((y * x) / math.sqrt(((z * z) - (t * a)))) else: tmp = y * (x * (z / (z + (-0.5 * (a * (t / z)))))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -4.8e+49) tmp = Float64(Float64(z / Float64(Float64(0.5 / Float64(Float64(1.0 / t) * Float64(z / a))) - z)) * Float64(y * x)); elseif (z <= 6e+30) tmp = Float64(z * Float64(Float64(y * x) / sqrt(Float64(Float64(z * z) - Float64(t * a))))); else tmp = Float64(y * Float64(x * Float64(z / Float64(z + Float64(-0.5 * Float64(a * Float64(t / z))))))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -4.8e+49) tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x); elseif (z <= 6e+30) tmp = z * ((y * x) / sqrt(((z * z) - (t * a)))); else tmp = y * (x * (z / (z + (-0.5 * (a * (t / z)))))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -4.8e+49], N[(N[(z / N[(N[(0.5 / N[(N[(1.0 / t), $MachinePrecision] * N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]), $MachinePrecision] * N[(y * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 6e+30], N[(z * N[(N[(y * x), $MachinePrecision] / N[Sqrt[N[(N[(z * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * N[(x * N[(z / N[(z + N[(-0.5 * N[(a * N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -4.8 \cdot 10^{+49}:\\
\;\;\;\;\frac{z}{\frac{0.5}{\frac{1}{t} \cdot \frac{z}{a}} - z} \cdot \left(y \cdot x\right)\\
\mathbf{elif}\;z \leq 6 \cdot 10^{+30}:\\
\;\;\;\;z \cdot \frac{y \cdot x}{\sqrt{z \cdot z - t \cdot a}}\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(x \cdot \frac{z}{z + -0.5 \cdot \left(a \cdot \frac{t}{z}\right)}\right)\\
\end{array}
\end{array}
if z < -4.8e49Initial program 37.7%
associate-*l/46.5%
associate-/l*43.6%
associate-*l/41.5%
associate-*r/45.1%
*-commutative45.1%
associate-/r/48.1%
associate-*l*47.9%
pow247.9%
Applied egg-rr47.9%
Taylor expanded in z around -inf 89.7%
+-commutative89.7%
mul-1-neg89.7%
sub-neg89.7%
associate-/l*96.1%
associate-*r/96.1%
associate-/l*96.1%
associate-/l/89.7%
Simplified89.7%
*-un-lft-identity89.7%
*-commutative89.7%
times-frac96.1%
Applied egg-rr96.1%
if -4.8e49 < z < 5.99999999999999956e30Initial program 87.6%
associate-*l/88.8%
Simplified88.8%
if 5.99999999999999956e30 < z Initial program 45.0%
associate-*l/46.4%
associate-/l*45.3%
associate-*l/42.1%
associate-*r/45.4%
associate-/r/49.5%
associate-*r*49.5%
pow249.5%
Applied egg-rr49.5%
Taylor expanded in z around inf 92.7%
associate-*r/98.6%
Simplified98.6%
Final simplification93.2%
(FPCore (x y z t a)
:precision binary64
(if (<= z -5.2e-160)
(* (/ z (- (/ 0.5 (* (/ 1.0 t) (/ z a))) z)) (* y x))
(if (<= z 2.05e-126)
(* x (/ z (/ (sqrt (* t (- a))) y)))
(* (* y x) (/ z (+ z (* -0.5 (* a (/ t z)))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -5.2e-160) {
tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x);
} else if (z <= 2.05e-126) {
tmp = x * (z / (sqrt((t * -a)) / y));
} else {
tmp = (y * x) * (z / (z + (-0.5 * (a * (t / z)))));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-5.2d-160)) then
tmp = (z / ((0.5d0 / ((1.0d0 / t) * (z / a))) - z)) * (y * x)
else if (z <= 2.05d-126) then
tmp = x * (z / (sqrt((t * -a)) / y))
else
tmp = (y * x) * (z / (z + ((-0.5d0) * (a * (t / z)))))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -5.2e-160) {
tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x);
} else if (z <= 2.05e-126) {
tmp = x * (z / (Math.sqrt((t * -a)) / y));
} else {
tmp = (y * x) * (z / (z + (-0.5 * (a * (t / z)))));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -5.2e-160: tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x) elif z <= 2.05e-126: tmp = x * (z / (math.sqrt((t * -a)) / y)) else: tmp = (y * x) * (z / (z + (-0.5 * (a * (t / z))))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -5.2e-160) tmp = Float64(Float64(z / Float64(Float64(0.5 / Float64(Float64(1.0 / t) * Float64(z / a))) - z)) * Float64(y * x)); elseif (z <= 2.05e-126) tmp = Float64(x * Float64(z / Float64(sqrt(Float64(t * Float64(-a))) / y))); else tmp = Float64(Float64(y * x) * Float64(z / Float64(z + Float64(-0.5 * Float64(a * Float64(t / z)))))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -5.2e-160) tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x); elseif (z <= 2.05e-126) tmp = x * (z / (sqrt((t * -a)) / y)); else tmp = (y * x) * (z / (z + (-0.5 * (a * (t / z))))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -5.2e-160], N[(N[(z / N[(N[(0.5 / N[(N[(1.0 / t), $MachinePrecision] * N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]), $MachinePrecision] * N[(y * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.05e-126], N[(x * N[(z / N[(N[Sqrt[N[(t * (-a)), $MachinePrecision]], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(y * x), $MachinePrecision] * N[(z / N[(z + N[(-0.5 * N[(a * N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -5.2 \cdot 10^{-160}:\\
\;\;\;\;\frac{z}{\frac{0.5}{\frac{1}{t} \cdot \frac{z}{a}} - z} \cdot \left(y \cdot x\right)\\
\mathbf{elif}\;z \leq 2.05 \cdot 10^{-126}:\\
\;\;\;\;x \cdot \frac{z}{\frac{\sqrt{t \cdot \left(-a\right)}}{y}}\\
\mathbf{else}:\\
\;\;\;\;\left(y \cdot x\right) \cdot \frac{z}{z + -0.5 \cdot \left(a \cdot \frac{t}{z}\right)}\\
\end{array}
\end{array}
if z < -5.20000000000000007e-160Initial program 57.5%
associate-*l/64.7%
associate-/l*62.3%
associate-*l/57.9%
associate-*r/63.2%
*-commutative63.2%
associate-/r/65.8%
associate-*l*65.6%
pow265.6%
Applied egg-rr65.6%
Taylor expanded in z around -inf 82.9%
+-commutative82.9%
mul-1-neg82.9%
sub-neg82.9%
associate-/l*86.8%
associate-*r/86.8%
associate-/l*86.8%
associate-/l/82.9%
Simplified82.9%
*-un-lft-identity82.9%
*-commutative82.9%
times-frac86.9%
Applied egg-rr86.9%
if -5.20000000000000007e-160 < z < 2.0499999999999999e-126Initial program 82.2%
associate-*l*74.0%
associate-*r/74.0%
*-commutative74.0%
associate-/l*76.5%
Simplified76.5%
Taylor expanded in z around 0 76.4%
associate-*r*76.4%
neg-mul-176.4%
Simplified76.4%
if 2.0499999999999999e-126 < z Initial program 61.7%
associate-*l/61.8%
associate-/l*60.1%
associate-*l/59.7%
associate-*r/62.0%
*-commutative62.0%
associate-/r/65.6%
associate-*l*65.5%
pow265.5%
Applied egg-rr65.5%
Taylor expanded in z around inf 85.3%
associate-*r/88.2%
Simplified89.1%
Final simplification85.8%
(FPCore (x y z t a)
:precision binary64
(if (<= z -7.2e-158)
(* (/ z (- (/ 0.5 (* (/ 1.0 t) (/ z a))) z)) (* y x))
(if (<= z 5.5e-127)
(* (* y x) (/ z (sqrt (* t (- a)))))
(* (* y x) (/ z (+ z (* -0.5 (* a (/ t z)))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -7.2e-158) {
tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x);
} else if (z <= 5.5e-127) {
tmp = (y * x) * (z / sqrt((t * -a)));
} else {
tmp = (y * x) * (z / (z + (-0.5 * (a * (t / z)))));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-7.2d-158)) then
tmp = (z / ((0.5d0 / ((1.0d0 / t) * (z / a))) - z)) * (y * x)
else if (z <= 5.5d-127) then
tmp = (y * x) * (z / sqrt((t * -a)))
else
tmp = (y * x) * (z / (z + ((-0.5d0) * (a * (t / z)))))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -7.2e-158) {
tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x);
} else if (z <= 5.5e-127) {
tmp = (y * x) * (z / Math.sqrt((t * -a)));
} else {
tmp = (y * x) * (z / (z + (-0.5 * (a * (t / z)))));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -7.2e-158: tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x) elif z <= 5.5e-127: tmp = (y * x) * (z / math.sqrt((t * -a))) else: tmp = (y * x) * (z / (z + (-0.5 * (a * (t / z))))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -7.2e-158) tmp = Float64(Float64(z / Float64(Float64(0.5 / Float64(Float64(1.0 / t) * Float64(z / a))) - z)) * Float64(y * x)); elseif (z <= 5.5e-127) tmp = Float64(Float64(y * x) * Float64(z / sqrt(Float64(t * Float64(-a))))); else tmp = Float64(Float64(y * x) * Float64(z / Float64(z + Float64(-0.5 * Float64(a * Float64(t / z)))))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -7.2e-158) tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x); elseif (z <= 5.5e-127) tmp = (y * x) * (z / sqrt((t * -a))); else tmp = (y * x) * (z / (z + (-0.5 * (a * (t / z))))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -7.2e-158], N[(N[(z / N[(N[(0.5 / N[(N[(1.0 / t), $MachinePrecision] * N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]), $MachinePrecision] * N[(y * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.5e-127], N[(N[(y * x), $MachinePrecision] * N[(z / N[Sqrt[N[(t * (-a)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(y * x), $MachinePrecision] * N[(z / N[(z + N[(-0.5 * N[(a * N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -7.2 \cdot 10^{-158}:\\
\;\;\;\;\frac{z}{\frac{0.5}{\frac{1}{t} \cdot \frac{z}{a}} - z} \cdot \left(y \cdot x\right)\\
\mathbf{elif}\;z \leq 5.5 \cdot 10^{-127}:\\
\;\;\;\;\left(y \cdot x\right) \cdot \frac{z}{\sqrt{t \cdot \left(-a\right)}}\\
\mathbf{else}:\\
\;\;\;\;\left(y \cdot x\right) \cdot \frac{z}{z + -0.5 \cdot \left(a \cdot \frac{t}{z}\right)}\\
\end{array}
\end{array}
if z < -7.19999999999999982e-158Initial program 57.5%
associate-*l/64.7%
associate-/l*62.3%
associate-*l/57.9%
associate-*r/63.2%
*-commutative63.2%
associate-/r/65.8%
associate-*l*65.6%
pow265.6%
Applied egg-rr65.6%
Taylor expanded in z around -inf 82.9%
+-commutative82.9%
mul-1-neg82.9%
sub-neg82.9%
associate-/l*86.8%
associate-*r/86.8%
associate-/l*86.8%
associate-/l/82.9%
Simplified82.9%
*-un-lft-identity82.9%
*-commutative82.9%
times-frac86.9%
Applied egg-rr86.9%
if -7.19999999999999982e-158 < z < 5.50000000000000036e-127Initial program 82.2%
associate-*l/83.5%
associate-/l*81.7%
associate-*l/77.5%
associate-*r/76.5%
*-commutative76.5%
associate-/r/76.5%
associate-*l*83.6%
pow283.6%
Applied egg-rr83.6%
Taylor expanded in z around 0 83.5%
*-commutative83.5%
neg-mul-183.5%
distribute-rgt-neg-in83.5%
Simplified83.5%
if 5.50000000000000036e-127 < z Initial program 61.7%
associate-*l/61.8%
associate-/l*60.1%
associate-*l/59.7%
associate-*r/62.0%
*-commutative62.0%
associate-/r/65.6%
associate-*l*65.5%
pow265.5%
Applied egg-rr65.5%
Taylor expanded in z around inf 85.3%
associate-*r/88.2%
Simplified89.1%
Final simplification87.1%
(FPCore (x y z t a)
:precision binary64
(if (<= z -6.5e-190)
(* y (- x))
(if (<= z 2.8e-104)
(* x (/ z (/ (+ z (* -0.5 (/ (* t a) z))) y)))
(* y x))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -6.5e-190) {
tmp = y * -x;
} else if (z <= 2.8e-104) {
tmp = x * (z / ((z + (-0.5 * ((t * a) / z))) / y));
} else {
tmp = y * x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-6.5d-190)) then
tmp = y * -x
else if (z <= 2.8d-104) then
tmp = x * (z / ((z + ((-0.5d0) * ((t * a) / z))) / y))
else
tmp = y * x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -6.5e-190) {
tmp = y * -x;
} else if (z <= 2.8e-104) {
tmp = x * (z / ((z + (-0.5 * ((t * a) / z))) / y));
} else {
tmp = y * x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -6.5e-190: tmp = y * -x elif z <= 2.8e-104: tmp = x * (z / ((z + (-0.5 * ((t * a) / z))) / y)) else: tmp = y * x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -6.5e-190) tmp = Float64(y * Float64(-x)); elseif (z <= 2.8e-104) tmp = Float64(x * Float64(z / Float64(Float64(z + Float64(-0.5 * Float64(Float64(t * a) / z))) / y))); else tmp = Float64(y * x); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -6.5e-190) tmp = y * -x; elseif (z <= 2.8e-104) tmp = x * (z / ((z + (-0.5 * ((t * a) / z))) / y)); else tmp = y * x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -6.5e-190], N[(y * (-x)), $MachinePrecision], If[LessEqual[z, 2.8e-104], N[(x * N[(z / N[(N[(z + N[(-0.5 * N[(N[(t * a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -6.5 \cdot 10^{-190}:\\
\;\;\;\;y \cdot \left(-x\right)\\
\mathbf{elif}\;z \leq 2.8 \cdot 10^{-104}:\\
\;\;\;\;x \cdot \frac{z}{\frac{z + -0.5 \cdot \frac{t \cdot a}{z}}{y}}\\
\mathbf{else}:\\
\;\;\;\;y \cdot x\\
\end{array}
\end{array}
if z < -6.4999999999999997e-190Initial program 58.7%
associate-*l*58.4%
associate-*r/64.5%
*-commutative64.5%
associate-/l*64.2%
Simplified64.2%
Taylor expanded in z around -inf 83.4%
mul-1-neg83.4%
*-commutative83.4%
distribute-rgt-neg-in83.4%
Simplified83.4%
if -6.4999999999999997e-190 < z < 2.8e-104Initial program 80.6%
associate-*l*72.5%
associate-*r/72.6%
*-commutative72.6%
associate-/l*75.0%
Simplified75.0%
Taylor expanded in z around inf 51.1%
if 2.8e-104 < z Initial program 61.2%
associate-*l*60.9%
associate-*r/64.8%
*-commutative64.8%
associate-/l*61.4%
Simplified61.4%
Taylor expanded in z around inf 87.8%
*-commutative87.8%
Simplified87.8%
Final simplification79.1%
(FPCore (x y z t a) :precision binary64 (if (<= z -6.2e-199) (* (/ z (- (/ 0.5 (* (/ 1.0 t) (/ z a))) z)) (* y x)) (* (* y x) (/ z (+ z (* -0.5 (* a (/ t z))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -6.2e-199) {
tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x);
} else {
tmp = (y * x) * (z / (z + (-0.5 * (a * (t / z)))));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-6.2d-199)) then
tmp = (z / ((0.5d0 / ((1.0d0 / t) * (z / a))) - z)) * (y * x)
else
tmp = (y * x) * (z / (z + ((-0.5d0) * (a * (t / z)))))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -6.2e-199) {
tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x);
} else {
tmp = (y * x) * (z / (z + (-0.5 * (a * (t / z)))));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -6.2e-199: tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x) else: tmp = (y * x) * (z / (z + (-0.5 * (a * (t / z))))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -6.2e-199) tmp = Float64(Float64(z / Float64(Float64(0.5 / Float64(Float64(1.0 / t) * Float64(z / a))) - z)) * Float64(y * x)); else tmp = Float64(Float64(y * x) * Float64(z / Float64(z + Float64(-0.5 * Float64(a * Float64(t / z)))))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -6.2e-199) tmp = (z / ((0.5 / ((1.0 / t) * (z / a))) - z)) * (y * x); else tmp = (y * x) * (z / (z + (-0.5 * (a * (t / z))))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -6.2e-199], N[(N[(z / N[(N[(0.5 / N[(N[(1.0 / t), $MachinePrecision] * N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]), $MachinePrecision] * N[(y * x), $MachinePrecision]), $MachinePrecision], N[(N[(y * x), $MachinePrecision] * N[(z / N[(z + N[(-0.5 * N[(a * N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -6.2 \cdot 10^{-199}:\\
\;\;\;\;\frac{z}{\frac{0.5}{\frac{1}{t} \cdot \frac{z}{a}} - z} \cdot \left(y \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;\left(y \cdot x\right) \cdot \frac{z}{z + -0.5 \cdot \left(a \cdot \frac{t}{z}\right)}\\
\end{array}
\end{array}
if z < -6.20000000000000024e-199Initial program 58.7%
associate-*l/65.7%
associate-/l*63.3%
associate-*l/59.1%
associate-*r/64.2%
*-commutative64.2%
associate-/r/66.7%
associate-*l*66.6%
pow266.6%
Applied egg-rr66.6%
Taylor expanded in z around -inf 81.7%
+-commutative81.7%
mul-1-neg81.7%
sub-neg81.7%
associate-/l*85.4%
associate-*r/85.4%
associate-/l*85.4%
associate-/l/81.7%
Simplified81.7%
*-un-lft-identity81.7%
*-commutative81.7%
times-frac85.5%
Applied egg-rr85.5%
if -6.20000000000000024e-199 < z Initial program 67.5%
associate-*l/67.9%
associate-/l*66.2%
associate-*l/64.5%
associate-*r/65.8%
*-commutative65.8%
associate-/r/68.4%
associate-*l*70.6%
pow270.6%
Applied egg-rr70.6%
Taylor expanded in z around inf 75.1%
associate-*r/77.2%
Simplified77.8%
Final simplification81.0%
(FPCore (x y z t a) :precision binary64 (if (<= z -6.6e-189) (* y (- x)) (if (<= z 5.2e-109) (* x (/ z (* -0.5 (* (/ t z) (/ a y))))) (* y x))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -6.6e-189) {
tmp = y * -x;
} else if (z <= 5.2e-109) {
tmp = x * (z / (-0.5 * ((t / z) * (a / y))));
} else {
tmp = y * x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-6.6d-189)) then
tmp = y * -x
else if (z <= 5.2d-109) then
tmp = x * (z / ((-0.5d0) * ((t / z) * (a / y))))
else
tmp = y * x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -6.6e-189) {
tmp = y * -x;
} else if (z <= 5.2e-109) {
tmp = x * (z / (-0.5 * ((t / z) * (a / y))));
} else {
tmp = y * x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -6.6e-189: tmp = y * -x elif z <= 5.2e-109: tmp = x * (z / (-0.5 * ((t / z) * (a / y)))) else: tmp = y * x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -6.6e-189) tmp = Float64(y * Float64(-x)); elseif (z <= 5.2e-109) tmp = Float64(x * Float64(z / Float64(-0.5 * Float64(Float64(t / z) * Float64(a / y))))); else tmp = Float64(y * x); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -6.6e-189) tmp = y * -x; elseif (z <= 5.2e-109) tmp = x * (z / (-0.5 * ((t / z) * (a / y)))); else tmp = y * x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -6.6e-189], N[(y * (-x)), $MachinePrecision], If[LessEqual[z, 5.2e-109], N[(x * N[(z / N[(-0.5 * N[(N[(t / z), $MachinePrecision] * N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -6.6 \cdot 10^{-189}:\\
\;\;\;\;y \cdot \left(-x\right)\\
\mathbf{elif}\;z \leq 5.2 \cdot 10^{-109}:\\
\;\;\;\;x \cdot \frac{z}{-0.5 \cdot \left(\frac{t}{z} \cdot \frac{a}{y}\right)}\\
\mathbf{else}:\\
\;\;\;\;y \cdot x\\
\end{array}
\end{array}
if z < -6.6000000000000002e-189Initial program 58.7%
associate-*l*58.4%
associate-*r/64.5%
*-commutative64.5%
associate-/l*64.2%
Simplified64.2%
Taylor expanded in z around -inf 83.4%
mul-1-neg83.4%
*-commutative83.4%
distribute-rgt-neg-in83.4%
Simplified83.4%
if -6.6000000000000002e-189 < z < 5.1999999999999997e-109Initial program 80.6%
associate-*l*72.5%
associate-*r/72.6%
*-commutative72.6%
associate-/l*75.0%
Simplified75.0%
Taylor expanded in z around inf 51.1%
Taylor expanded in z around 0 46.9%
times-frac46.8%
Simplified46.8%
if 5.1999999999999997e-109 < z Initial program 61.2%
associate-*l*60.9%
associate-*r/64.8%
*-commutative64.8%
associate-/l*61.4%
Simplified61.4%
Taylor expanded in z around inf 87.8%
*-commutative87.8%
Simplified87.8%
Final simplification78.3%
(FPCore (x y z t a) :precision binary64 (if (<= z -4.6e-198) (* y (- x)) (if (<= z 5.2e-109) (/ (* z x) (* -0.5 (* (/ t z) (/ a y)))) (* y x))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -4.6e-198) {
tmp = y * -x;
} else if (z <= 5.2e-109) {
tmp = (z * x) / (-0.5 * ((t / z) * (a / y)));
} else {
tmp = y * x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-4.6d-198)) then
tmp = y * -x
else if (z <= 5.2d-109) then
tmp = (z * x) / ((-0.5d0) * ((t / z) * (a / y)))
else
tmp = y * x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -4.6e-198) {
tmp = y * -x;
} else if (z <= 5.2e-109) {
tmp = (z * x) / (-0.5 * ((t / z) * (a / y)));
} else {
tmp = y * x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -4.6e-198: tmp = y * -x elif z <= 5.2e-109: tmp = (z * x) / (-0.5 * ((t / z) * (a / y))) else: tmp = y * x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -4.6e-198) tmp = Float64(y * Float64(-x)); elseif (z <= 5.2e-109) tmp = Float64(Float64(z * x) / Float64(-0.5 * Float64(Float64(t / z) * Float64(a / y)))); else tmp = Float64(y * x); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -4.6e-198) tmp = y * -x; elseif (z <= 5.2e-109) tmp = (z * x) / (-0.5 * ((t / z) * (a / y))); else tmp = y * x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -4.6e-198], N[(y * (-x)), $MachinePrecision], If[LessEqual[z, 5.2e-109], N[(N[(z * x), $MachinePrecision] / N[(-0.5 * N[(N[(t / z), $MachinePrecision] * N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -4.6 \cdot 10^{-198}:\\
\;\;\;\;y \cdot \left(-x\right)\\
\mathbf{elif}\;z \leq 5.2 \cdot 10^{-109}:\\
\;\;\;\;\frac{z \cdot x}{-0.5 \cdot \left(\frac{t}{z} \cdot \frac{a}{y}\right)}\\
\mathbf{else}:\\
\;\;\;\;y \cdot x\\
\end{array}
\end{array}
if z < -4.60000000000000027e-198Initial program 58.7%
associate-*l*58.4%
associate-*r/64.5%
*-commutative64.5%
associate-/l*64.2%
Simplified64.2%
Taylor expanded in z around -inf 83.4%
mul-1-neg83.4%
*-commutative83.4%
distribute-rgt-neg-in83.4%
Simplified83.4%
if -4.60000000000000027e-198 < z < 5.1999999999999997e-109Initial program 80.6%
associate-*l*72.5%
associate-*r/72.6%
*-commutative72.6%
associate-/l*75.0%
Simplified75.0%
Taylor expanded in z around inf 51.1%
associate-*r/51.0%
+-commutative51.0%
fma-def51.0%
associate-/l*50.9%
Applied egg-rr50.9%
Taylor expanded in a around inf 46.9%
times-frac46.8%
Simplified46.8%
if 5.1999999999999997e-109 < z Initial program 61.2%
associate-*l*60.9%
associate-*r/64.8%
*-commutative64.8%
associate-/l*61.4%
Simplified61.4%
Taylor expanded in z around inf 87.8%
*-commutative87.8%
Simplified87.8%
Final simplification78.3%
(FPCore (x y z t a) :precision binary64 (if (<= z -2.85e-191) (* y (- x)) (if (<= z 8.5e-157) (/ (* z x) (/ (* t (* -0.5 (/ a z))) y)) (* y x))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.85e-191) {
tmp = y * -x;
} else if (z <= 8.5e-157) {
tmp = (z * x) / ((t * (-0.5 * (a / z))) / y);
} else {
tmp = y * x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-2.85d-191)) then
tmp = y * -x
else if (z <= 8.5d-157) then
tmp = (z * x) / ((t * ((-0.5d0) * (a / z))) / y)
else
tmp = y * x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.85e-191) {
tmp = y * -x;
} else if (z <= 8.5e-157) {
tmp = (z * x) / ((t * (-0.5 * (a / z))) / y);
} else {
tmp = y * x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.85e-191: tmp = y * -x elif z <= 8.5e-157: tmp = (z * x) / ((t * (-0.5 * (a / z))) / y) else: tmp = y * x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.85e-191) tmp = Float64(y * Float64(-x)); elseif (z <= 8.5e-157) tmp = Float64(Float64(z * x) / Float64(Float64(t * Float64(-0.5 * Float64(a / z))) / y)); else tmp = Float64(y * x); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.85e-191) tmp = y * -x; elseif (z <= 8.5e-157) tmp = (z * x) / ((t * (-0.5 * (a / z))) / y); else tmp = y * x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.85e-191], N[(y * (-x)), $MachinePrecision], If[LessEqual[z, 8.5e-157], N[(N[(z * x), $MachinePrecision] / N[(N[(t * N[(-0.5 * N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], N[(y * x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.85 \cdot 10^{-191}:\\
\;\;\;\;y \cdot \left(-x\right)\\
\mathbf{elif}\;z \leq 8.5 \cdot 10^{-157}:\\
\;\;\;\;\frac{z \cdot x}{\frac{t \cdot \left(-0.5 \cdot \frac{a}{z}\right)}{y}}\\
\mathbf{else}:\\
\;\;\;\;y \cdot x\\
\end{array}
\end{array}
if z < -2.8499999999999999e-191Initial program 58.7%
associate-*l*58.4%
associate-*r/64.5%
*-commutative64.5%
associate-/l*64.2%
Simplified64.2%
Taylor expanded in z around -inf 83.4%
mul-1-neg83.4%
*-commutative83.4%
distribute-rgt-neg-in83.4%
Simplified83.4%
if -2.8499999999999999e-191 < z < 8.49999999999999976e-157Initial program 79.7%
associate-*l*70.2%
associate-*r/70.3%
*-commutative70.3%
associate-/l*73.2%
Simplified73.2%
Taylor expanded in z around inf 52.1%
associate-*r/52.0%
+-commutative52.0%
fma-def52.0%
associate-/l*51.9%
Applied egg-rr51.9%
Taylor expanded in a around inf 49.5%
associate-*l/49.5%
associate-*r*49.5%
*-commutative49.5%
Simplified49.5%
if 8.49999999999999976e-157 < z Initial program 62.8%
associate-*l*62.5%
associate-*r/66.2%
*-commutative66.2%
associate-/l*63.0%
Simplified63.0%
Taylor expanded in z around inf 84.2%
*-commutative84.2%
Simplified84.2%
Final simplification78.3%
(FPCore (x y z t a) :precision binary64 (if (<= z -1e-189) (* y (- x)) (* y (* x (/ z (+ z (* -0.5 (* a (/ t z)))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1e-189) {
tmp = y * -x;
} else {
tmp = y * (x * (z / (z + (-0.5 * (a * (t / z))))));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-1d-189)) then
tmp = y * -x
else
tmp = y * (x * (z / (z + ((-0.5d0) * (a * (t / z))))))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1e-189) {
tmp = y * -x;
} else {
tmp = y * (x * (z / (z + (-0.5 * (a * (t / z))))));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1e-189: tmp = y * -x else: tmp = y * (x * (z / (z + (-0.5 * (a * (t / z)))))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1e-189) tmp = Float64(y * Float64(-x)); else tmp = Float64(y * Float64(x * Float64(z / Float64(z + Float64(-0.5 * Float64(a * Float64(t / z))))))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1e-189) tmp = y * -x; else tmp = y * (x * (z / (z + (-0.5 * (a * (t / z)))))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1e-189], N[(y * (-x)), $MachinePrecision], N[(y * N[(x * N[(z / N[(z + N[(-0.5 * N[(a * N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1 \cdot 10^{-189}:\\
\;\;\;\;y \cdot \left(-x\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(x \cdot \frac{z}{z + -0.5 \cdot \left(a \cdot \frac{t}{z}\right)}\right)\\
\end{array}
\end{array}
if z < -1.00000000000000007e-189Initial program 58.7%
associate-*l*58.4%
associate-*r/64.5%
*-commutative64.5%
associate-/l*64.2%
Simplified64.2%
Taylor expanded in z around -inf 83.4%
mul-1-neg83.4%
*-commutative83.4%
distribute-rgt-neg-in83.4%
Simplified83.4%
if -1.00000000000000007e-189 < z Initial program 67.5%
associate-*l/67.9%
associate-/l*66.2%
associate-*l/64.5%
associate-*r/65.8%
associate-/r/68.4%
associate-*r*69.3%
pow269.3%
Applied egg-rr69.3%
Taylor expanded in z around inf 74.6%
associate-*r/77.2%
Simplified77.2%
Final simplification79.8%
(FPCore (x y z t a) :precision binary64 (if (<= z -6.5e-198) (* y (- x)) (* (* y x) (/ z (+ z (* -0.5 (* a (/ t z))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -6.5e-198) {
tmp = y * -x;
} else {
tmp = (y * x) * (z / (z + (-0.5 * (a * (t / z)))));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-6.5d-198)) then
tmp = y * -x
else
tmp = (y * x) * (z / (z + ((-0.5d0) * (a * (t / z)))))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -6.5e-198) {
tmp = y * -x;
} else {
tmp = (y * x) * (z / (z + (-0.5 * (a * (t / z)))));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -6.5e-198: tmp = y * -x else: tmp = (y * x) * (z / (z + (-0.5 * (a * (t / z))))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -6.5e-198) tmp = Float64(y * Float64(-x)); else tmp = Float64(Float64(y * x) * Float64(z / Float64(z + Float64(-0.5 * Float64(a * Float64(t / z)))))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -6.5e-198) tmp = y * -x; else tmp = (y * x) * (z / (z + (-0.5 * (a * (t / z))))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -6.5e-198], N[(y * (-x)), $MachinePrecision], N[(N[(y * x), $MachinePrecision] * N[(z / N[(z + N[(-0.5 * N[(a * N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -6.5 \cdot 10^{-198}:\\
\;\;\;\;y \cdot \left(-x\right)\\
\mathbf{else}:\\
\;\;\;\;\left(y \cdot x\right) \cdot \frac{z}{z + -0.5 \cdot \left(a \cdot \frac{t}{z}\right)}\\
\end{array}
\end{array}
if z < -6.5000000000000004e-198Initial program 58.7%
associate-*l*58.4%
associate-*r/64.5%
*-commutative64.5%
associate-/l*64.2%
Simplified64.2%
Taylor expanded in z around -inf 83.4%
mul-1-neg83.4%
*-commutative83.4%
distribute-rgt-neg-in83.4%
Simplified83.4%
if -6.5000000000000004e-198 < z Initial program 67.5%
associate-*l/67.9%
associate-/l*66.2%
associate-*l/64.5%
associate-*r/65.8%
*-commutative65.8%
associate-/r/68.4%
associate-*l*70.6%
pow270.6%
Applied egg-rr70.6%
Taylor expanded in z around inf 75.1%
associate-*r/77.2%
Simplified77.8%
Final simplification80.2%
(FPCore (x y z t a) :precision binary64 (if (<= z -2.5e-192) (* y (- x)) (if (<= z 8.6e-107) (/ (* x (* z (- y))) (- z)) (* y x))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.5e-192) {
tmp = y * -x;
} else if (z <= 8.6e-107) {
tmp = (x * (z * -y)) / -z;
} else {
tmp = y * x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-2.5d-192)) then
tmp = y * -x
else if (z <= 8.6d-107) then
tmp = (x * (z * -y)) / -z
else
tmp = y * x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.5e-192) {
tmp = y * -x;
} else if (z <= 8.6e-107) {
tmp = (x * (z * -y)) / -z;
} else {
tmp = y * x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.5e-192: tmp = y * -x elif z <= 8.6e-107: tmp = (x * (z * -y)) / -z else: tmp = y * x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.5e-192) tmp = Float64(y * Float64(-x)); elseif (z <= 8.6e-107) tmp = Float64(Float64(x * Float64(z * Float64(-y))) / Float64(-z)); else tmp = Float64(y * x); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.5e-192) tmp = y * -x; elseif (z <= 8.6e-107) tmp = (x * (z * -y)) / -z; else tmp = y * x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.5e-192], N[(y * (-x)), $MachinePrecision], If[LessEqual[z, 8.6e-107], N[(N[(x * N[(z * (-y)), $MachinePrecision]), $MachinePrecision] / (-z)), $MachinePrecision], N[(y * x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.5 \cdot 10^{-192}:\\
\;\;\;\;y \cdot \left(-x\right)\\
\mathbf{elif}\;z \leq 8.6 \cdot 10^{-107}:\\
\;\;\;\;\frac{x \cdot \left(z \cdot \left(-y\right)\right)}{-z}\\
\mathbf{else}:\\
\;\;\;\;y \cdot x\\
\end{array}
\end{array}
if z < -2.5e-192Initial program 58.7%
associate-*l*58.4%
associate-*r/64.5%
*-commutative64.5%
associate-/l*64.2%
Simplified64.2%
Taylor expanded in z around -inf 83.4%
mul-1-neg83.4%
*-commutative83.4%
distribute-rgt-neg-in83.4%
Simplified83.4%
if -2.5e-192 < z < 8.5999999999999995e-107Initial program 80.6%
associate-*l*72.5%
*-commutative72.5%
associate-*l*76.7%
associate-*r/75.9%
*-commutative75.9%
Simplified75.9%
Taylor expanded in z around -inf 20.7%
associate-*r/20.7%
neg-mul-120.7%
Simplified20.7%
associate-*l/37.1%
frac-2neg37.1%
add-sqr-sqrt21.9%
sqrt-unprod41.1%
sqr-neg41.1%
sqrt-unprod17.4%
add-sqr-sqrt44.0%
Applied egg-rr44.0%
neg-mul-144.0%
associate-*r*42.1%
*-commutative42.1%
associate-*r*46.8%
associate-*r*46.8%
mul-1-neg46.8%
Simplified46.8%
if 8.5999999999999995e-107 < z Initial program 61.2%
associate-*l*60.9%
associate-*r/64.8%
*-commutative64.8%
associate-/l*61.4%
Simplified61.4%
Taylor expanded in z around inf 87.8%
*-commutative87.8%
Simplified87.8%
Final simplification78.3%
(FPCore (x y z t a) :precision binary64 (if (<= z -1.3e-198) (* y (- x)) (if (<= z 1e-107) (* x (/ (* z y) z)) (* y x))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.3e-198) {
tmp = y * -x;
} else if (z <= 1e-107) {
tmp = x * ((z * y) / z);
} else {
tmp = y * x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-1.3d-198)) then
tmp = y * -x
else if (z <= 1d-107) then
tmp = x * ((z * y) / z)
else
tmp = y * x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.3e-198) {
tmp = y * -x;
} else if (z <= 1e-107) {
tmp = x * ((z * y) / z);
} else {
tmp = y * x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1.3e-198: tmp = y * -x elif z <= 1e-107: tmp = x * ((z * y) / z) else: tmp = y * x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.3e-198) tmp = Float64(y * Float64(-x)); elseif (z <= 1e-107) tmp = Float64(x * Float64(Float64(z * y) / z)); else tmp = Float64(y * x); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1.3e-198) tmp = y * -x; elseif (z <= 1e-107) tmp = x * ((z * y) / z); else tmp = y * x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.3e-198], N[(y * (-x)), $MachinePrecision], If[LessEqual[z, 1e-107], N[(x * N[(N[(z * y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], N[(y * x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.3 \cdot 10^{-198}:\\
\;\;\;\;y \cdot \left(-x\right)\\
\mathbf{elif}\;z \leq 10^{-107}:\\
\;\;\;\;x \cdot \frac{z \cdot y}{z}\\
\mathbf{else}:\\
\;\;\;\;y \cdot x\\
\end{array}
\end{array}
if z < -1.30000000000000003e-198Initial program 58.7%
associate-*l*58.4%
associate-*r/64.5%
*-commutative64.5%
associate-/l*64.2%
Simplified64.2%
Taylor expanded in z around -inf 83.4%
mul-1-neg83.4%
*-commutative83.4%
distribute-rgt-neg-in83.4%
Simplified83.4%
if -1.30000000000000003e-198 < z < 1e-107Initial program 80.6%
associate-*l*72.5%
associate-*r/72.6%
*-commutative72.6%
associate-/l*75.0%
Simplified75.0%
Taylor expanded in z around -inf 16.9%
neg-mul-116.9%
Simplified16.9%
*-un-lft-identity16.9%
div-inv16.9%
times-frac33.7%
add-sqr-sqrt11.0%
sqrt-unprod9.9%
sqr-neg9.9%
sqrt-prod32.0%
add-sqr-sqrt42.8%
Applied egg-rr42.8%
associate-*l/42.8%
*-un-lft-identity42.8%
div-inv42.8%
inv-pow42.8%
pow-flip42.9%
metadata-eval42.9%
pow142.9%
Applied egg-rr42.9%
if 1e-107 < z Initial program 61.2%
associate-*l*60.9%
associate-*r/64.8%
*-commutative64.8%
associate-/l*61.4%
Simplified61.4%
Taylor expanded in z around inf 87.8%
*-commutative87.8%
Simplified87.8%
Final simplification77.5%
(FPCore (x y z t a) :precision binary64 (if (<= z -5.8e-198) (* y (- x)) (if (<= z 4.8e-69) (/ (* y (* z x)) z) (* y x))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -5.8e-198) {
tmp = y * -x;
} else if (z <= 4.8e-69) {
tmp = (y * (z * x)) / z;
} else {
tmp = y * x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-5.8d-198)) then
tmp = y * -x
else if (z <= 4.8d-69) then
tmp = (y * (z * x)) / z
else
tmp = y * x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -5.8e-198) {
tmp = y * -x;
} else if (z <= 4.8e-69) {
tmp = (y * (z * x)) / z;
} else {
tmp = y * x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -5.8e-198: tmp = y * -x elif z <= 4.8e-69: tmp = (y * (z * x)) / z else: tmp = y * x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -5.8e-198) tmp = Float64(y * Float64(-x)); elseif (z <= 4.8e-69) tmp = Float64(Float64(y * Float64(z * x)) / z); else tmp = Float64(y * x); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -5.8e-198) tmp = y * -x; elseif (z <= 4.8e-69) tmp = (y * (z * x)) / z; else tmp = y * x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -5.8e-198], N[(y * (-x)), $MachinePrecision], If[LessEqual[z, 4.8e-69], N[(N[(y * N[(z * x), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], N[(y * x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -5.8 \cdot 10^{-198}:\\
\;\;\;\;y \cdot \left(-x\right)\\
\mathbf{elif}\;z \leq 4.8 \cdot 10^{-69}:\\
\;\;\;\;\frac{y \cdot \left(z \cdot x\right)}{z}\\
\mathbf{else}:\\
\;\;\;\;y \cdot x\\
\end{array}
\end{array}
if z < -5.80000000000000001e-198Initial program 58.7%
associate-*l*58.4%
associate-*r/64.5%
*-commutative64.5%
associate-/l*64.2%
Simplified64.2%
Taylor expanded in z around -inf 83.4%
mul-1-neg83.4%
*-commutative83.4%
distribute-rgt-neg-in83.4%
Simplified83.4%
if -5.80000000000000001e-198 < z < 4.8000000000000002e-69Initial program 82.2%
associate-*l*75.5%
*-commutative75.5%
associate-*l*79.0%
associate-*r/78.3%
*-commutative78.3%
Simplified78.3%
Taylor expanded in z around -inf 22.5%
associate-*r/22.5%
neg-mul-122.5%
Simplified22.5%
associate-*l/36.0%
add-sqr-sqrt21.7%
sqrt-unprod41.2%
sqr-neg41.2%
sqrt-unprod19.6%
add-sqr-sqrt48.7%
Applied egg-rr48.7%
if 4.8000000000000002e-69 < z Initial program 58.0%
associate-*l*57.7%
associate-*r/62.0%
*-commutative62.0%
associate-/l*58.2%
Simplified58.2%
Taylor expanded in z around inf 89.7%
*-commutative89.7%
Simplified89.7%
Final simplification77.7%
(FPCore (x y z t a) :precision binary64 (if (<= z -2e-310) (* y (- x)) (* y x)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2e-310) {
tmp = y * -x;
} else {
tmp = y * x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-2d-310)) then
tmp = y * -x
else
tmp = y * x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2e-310) {
tmp = y * -x;
} else {
tmp = y * x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2e-310: tmp = y * -x else: tmp = y * x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2e-310) tmp = Float64(y * Float64(-x)); else tmp = Float64(y * x); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2e-310) tmp = y * -x; else tmp = y * x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2e-310], N[(y * (-x)), $MachinePrecision], N[(y * x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2 \cdot 10^{-310}:\\
\;\;\;\;y \cdot \left(-x\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot x\\
\end{array}
\end{array}
if z < -1.999999999999994e-310Initial program 61.5%
associate-*l*60.5%
associate-*r/66.0%
*-commutative66.0%
associate-/l*65.7%
Simplified65.7%
Taylor expanded in z around -inf 75.7%
mul-1-neg75.7%
*-commutative75.7%
distribute-rgt-neg-in75.7%
Simplified75.7%
if -1.999999999999994e-310 < z Initial program 65.8%
associate-*l*63.4%
associate-*r/66.3%
*-commutative66.3%
associate-/l*64.7%
Simplified64.7%
Taylor expanded in z around inf 73.4%
*-commutative73.4%
Simplified73.4%
Final simplification74.5%
(FPCore (x y z t a) :precision binary64 (* y x))
double code(double x, double y, double z, double t, double a) {
return y * x;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = y * x
end function
public static double code(double x, double y, double z, double t, double a) {
return y * x;
}
def code(x, y, z, t, a): return y * x
function code(x, y, z, t, a) return Float64(y * x) end
function tmp = code(x, y, z, t, a) tmp = y * x; end
code[x_, y_, z_, t_, a_] := N[(y * x), $MachinePrecision]
\begin{array}{l}
\\
y \cdot x
\end{array}
Initial program 63.8%
associate-*l*62.0%
associate-*r/66.2%
*-commutative66.2%
associate-/l*65.2%
Simplified65.2%
Taylor expanded in z around inf 43.8%
*-commutative43.8%
Simplified43.8%
Final simplification43.8%
(FPCore (x y z t a)
:precision binary64
(if (< z -3.1921305903852764e+46)
(- (* y x))
(if (< z 5.976268120920894e+90)
(/ (* x z) (/ (sqrt (- (* z z) (* a t))) y))
(* y x))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z < -3.1921305903852764e+46) {
tmp = -(y * x);
} else if (z < 5.976268120920894e+90) {
tmp = (x * z) / (sqrt(((z * z) - (a * t))) / y);
} else {
tmp = y * x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z < (-3.1921305903852764d+46)) then
tmp = -(y * x)
else if (z < 5.976268120920894d+90) then
tmp = (x * z) / (sqrt(((z * z) - (a * t))) / y)
else
tmp = y * x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z < -3.1921305903852764e+46) {
tmp = -(y * x);
} else if (z < 5.976268120920894e+90) {
tmp = (x * z) / (Math.sqrt(((z * z) - (a * t))) / y);
} else {
tmp = y * x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z < -3.1921305903852764e+46: tmp = -(y * x) elif z < 5.976268120920894e+90: tmp = (x * z) / (math.sqrt(((z * z) - (a * t))) / y) else: tmp = y * x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z < -3.1921305903852764e+46) tmp = Float64(-Float64(y * x)); elseif (z < 5.976268120920894e+90) tmp = Float64(Float64(x * z) / Float64(sqrt(Float64(Float64(z * z) - Float64(a * t))) / y)); else tmp = Float64(y * x); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z < -3.1921305903852764e+46) tmp = -(y * x); elseif (z < 5.976268120920894e+90) tmp = (x * z) / (sqrt(((z * z) - (a * t))) / y); else tmp = y * x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Less[z, -3.1921305903852764e+46], (-N[(y * x), $MachinePrecision]), If[Less[z, 5.976268120920894e+90], N[(N[(x * z), $MachinePrecision] / N[(N[Sqrt[N[(N[(z * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], N[(y * x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z < -3.1921305903852764 \cdot 10^{+46}:\\
\;\;\;\;-y \cdot x\\
\mathbf{elif}\;z < 5.976268120920894 \cdot 10^{+90}:\\
\;\;\;\;\frac{x \cdot z}{\frac{\sqrt{z \cdot z - a \cdot t}}{y}}\\
\mathbf{else}:\\
\;\;\;\;y \cdot x\\
\end{array}
\end{array}
herbie shell --seed 2023336
(FPCore (x y z t a)
:name "Statistics.Math.RootFinding:ridders from math-functions-0.1.5.2"
:precision binary64
:herbie-target
(if (< z -3.1921305903852764e+46) (- (* y x)) (if (< z 5.976268120920894e+90) (/ (* x z) (/ (sqrt (- (* z z) (* a t))) y)) (* y x)))
(/ (* (* x y) z) (sqrt (- (* z z) (* t a)))))