
(FPCore (x y z t) :precision binary64 (+ (- x (/ y (* z 3.0))) (/ t (* (* z 3.0) y))))
double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y));
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (x - (y / (z * 3.0d0))) + (t / ((z * 3.0d0) * y))
end function
public static double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y));
}
def code(x, y, z, t): return (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y))
function code(x, y, z, t) return Float64(Float64(x - Float64(y / Float64(z * 3.0))) + Float64(t / Float64(Float64(z * 3.0) * y))) end
function tmp = code(x, y, z, t) tmp = (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y)); end
code[x_, y_, z_, t_] := N[(N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t / N[(N[(z * 3.0), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 20 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t) :precision binary64 (+ (- x (/ y (* z 3.0))) (/ t (* (* z 3.0) y))))
double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y));
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (x - (y / (z * 3.0d0))) + (t / ((z * 3.0d0) * y))
end function
public static double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y));
}
def code(x, y, z, t): return (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y))
function code(x, y, z, t) return Float64(Float64(x - Float64(y / Float64(z * 3.0))) + Float64(t / Float64(Float64(z * 3.0) * y))) end
function tmp = code(x, y, z, t) tmp = (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y)); end
code[x_, y_, z_, t_] := N[(N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t / N[(N[(z * 3.0), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y}
\end{array}
(FPCore (x y z t) :precision binary64 (if (<= t 1e+68) (+ (+ (/ (/ t (* z 3.0)) y) x) (/ y (* z -3.0))) (+ (+ x (/ t (* z (* 3.0 y)))) (* (/ 1.0 z) (/ y -3.0)))))
double code(double x, double y, double z, double t) {
double tmp;
if (t <= 1e+68) {
tmp = (((t / (z * 3.0)) / y) + x) + (y / (z * -3.0));
} else {
tmp = (x + (t / (z * (3.0 * y)))) + ((1.0 / z) * (y / -3.0));
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (t <= 1d+68) then
tmp = (((t / (z * 3.0d0)) / y) + x) + (y / (z * (-3.0d0)))
else
tmp = (x + (t / (z * (3.0d0 * y)))) + ((1.0d0 / z) * (y / (-3.0d0)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (t <= 1e+68) {
tmp = (((t / (z * 3.0)) / y) + x) + (y / (z * -3.0));
} else {
tmp = (x + (t / (z * (3.0 * y)))) + ((1.0 / z) * (y / -3.0));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if t <= 1e+68: tmp = (((t / (z * 3.0)) / y) + x) + (y / (z * -3.0)) else: tmp = (x + (t / (z * (3.0 * y)))) + ((1.0 / z) * (y / -3.0)) return tmp
function code(x, y, z, t) tmp = 0.0 if (t <= 1e+68) tmp = Float64(Float64(Float64(Float64(t / Float64(z * 3.0)) / y) + x) + Float64(y / Float64(z * -3.0))); else tmp = Float64(Float64(x + Float64(t / Float64(z * Float64(3.0 * y)))) + Float64(Float64(1.0 / z) * Float64(y / -3.0))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (t <= 1e+68) tmp = (((t / (z * 3.0)) / y) + x) + (y / (z * -3.0)); else tmp = (x + (t / (z * (3.0 * y)))) + ((1.0 / z) * (y / -3.0)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[t, 1e+68], N[(N[(N[(N[(t / N[(z * 3.0), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision] + x), $MachinePrecision] + N[(y / N[(z * -3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + N[(t / N[(z * N[(3.0 * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(1.0 / z), $MachinePrecision] * N[(y / -3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 10^{+68}:\\
\;\;\;\;\left(\frac{\frac{t}{z \cdot 3}}{y} + x\right) + \frac{y}{z \cdot -3}\\
\mathbf{else}:\\
\;\;\;\;\left(x + \frac{t}{z \cdot \left(3 \cdot y\right)}\right) + \frac{1}{z} \cdot \frac{y}{-3}\\
\end{array}
\end{array}
if t < 9.99999999999999953e67Initial program 97.1%
+-commutative97.1%
associate-+r-97.1%
sub-neg97.1%
associate-*l*97.1%
*-commutative97.1%
distribute-frac-neg297.1%
distribute-rgt-neg-in97.1%
metadata-eval97.1%
Simplified97.1%
add-cube-cbrt97.0%
*-commutative97.0%
associate-*l*97.0%
*-commutative97.0%
times-frac98.7%
pow298.7%
Applied egg-rr98.7%
associate-*l/99.1%
associate-*r/99.1%
unpow299.1%
rem-3cbrt-lft99.4%
Simplified99.4%
if 9.99999999999999953e67 < t Initial program 97.7%
+-commutative97.7%
associate-+r-97.7%
sub-neg97.7%
associate-*l*97.8%
*-commutative97.8%
distribute-frac-neg297.8%
distribute-rgt-neg-in97.8%
metadata-eval97.8%
Simplified97.8%
*-un-lft-identity97.8%
times-frac97.8%
Applied egg-rr97.8%
Final simplification99.1%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (/ (/ y -3.0) z)) (t_2 (* 0.3333333333333333 (/ t (* z y)))))
(if (<= y -8e+119)
t_1
(if (<= y -6e+88)
x
(if (<= y -1.8e+23)
(/ (/ y z) -3.0)
(if (<= y -7e-34)
t_2
(if (<= y -1.15e-69) x (if (<= y 9.5e+30) t_2 t_1))))))))
double code(double x, double y, double z, double t) {
double t_1 = (y / -3.0) / z;
double t_2 = 0.3333333333333333 * (t / (z * y));
double tmp;
if (y <= -8e+119) {
tmp = t_1;
} else if (y <= -6e+88) {
tmp = x;
} else if (y <= -1.8e+23) {
tmp = (y / z) / -3.0;
} else if (y <= -7e-34) {
tmp = t_2;
} else if (y <= -1.15e-69) {
tmp = x;
} else if (y <= 9.5e+30) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (y / (-3.0d0)) / z
t_2 = 0.3333333333333333d0 * (t / (z * y))
if (y <= (-8d+119)) then
tmp = t_1
else if (y <= (-6d+88)) then
tmp = x
else if (y <= (-1.8d+23)) then
tmp = (y / z) / (-3.0d0)
else if (y <= (-7d-34)) then
tmp = t_2
else if (y <= (-1.15d-69)) then
tmp = x
else if (y <= 9.5d+30) then
tmp = t_2
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = (y / -3.0) / z;
double t_2 = 0.3333333333333333 * (t / (z * y));
double tmp;
if (y <= -8e+119) {
tmp = t_1;
} else if (y <= -6e+88) {
tmp = x;
} else if (y <= -1.8e+23) {
tmp = (y / z) / -3.0;
} else if (y <= -7e-34) {
tmp = t_2;
} else if (y <= -1.15e-69) {
tmp = x;
} else if (y <= 9.5e+30) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t): t_1 = (y / -3.0) / z t_2 = 0.3333333333333333 * (t / (z * y)) tmp = 0 if y <= -8e+119: tmp = t_1 elif y <= -6e+88: tmp = x elif y <= -1.8e+23: tmp = (y / z) / -3.0 elif y <= -7e-34: tmp = t_2 elif y <= -1.15e-69: tmp = x elif y <= 9.5e+30: tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t) t_1 = Float64(Float64(y / -3.0) / z) t_2 = Float64(0.3333333333333333 * Float64(t / Float64(z * y))) tmp = 0.0 if (y <= -8e+119) tmp = t_1; elseif (y <= -6e+88) tmp = x; elseif (y <= -1.8e+23) tmp = Float64(Float64(y / z) / -3.0); elseif (y <= -7e-34) tmp = t_2; elseif (y <= -1.15e-69) tmp = x; elseif (y <= 9.5e+30) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = (y / -3.0) / z; t_2 = 0.3333333333333333 * (t / (z * y)); tmp = 0.0; if (y <= -8e+119) tmp = t_1; elseif (y <= -6e+88) tmp = x; elseif (y <= -1.8e+23) tmp = (y / z) / -3.0; elseif (y <= -7e-34) tmp = t_2; elseif (y <= -1.15e-69) tmp = x; elseif (y <= 9.5e+30) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(y / -3.0), $MachinePrecision] / z), $MachinePrecision]}, Block[{t$95$2 = N[(0.3333333333333333 * N[(t / N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -8e+119], t$95$1, If[LessEqual[y, -6e+88], x, If[LessEqual[y, -1.8e+23], N[(N[(y / z), $MachinePrecision] / -3.0), $MachinePrecision], If[LessEqual[y, -7e-34], t$95$2, If[LessEqual[y, -1.15e-69], x, If[LessEqual[y, 9.5e+30], t$95$2, t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\frac{y}{-3}}{z}\\
t_2 := 0.3333333333333333 \cdot \frac{t}{z \cdot y}\\
\mathbf{if}\;y \leq -8 \cdot 10^{+119}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -6 \cdot 10^{+88}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq -1.8 \cdot 10^{+23}:\\
\;\;\;\;\frac{\frac{y}{z}}{-3}\\
\mathbf{elif}\;y \leq -7 \cdot 10^{-34}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -1.15 \cdot 10^{-69}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 9.5 \cdot 10^{+30}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -7.99999999999999955e119 or 9.5000000000000003e30 < y Initial program 98.9%
+-commutative98.9%
associate-+r-98.9%
sub-neg98.9%
associate-*l*98.8%
*-commutative98.8%
distribute-frac-neg298.8%
distribute-rgt-neg-in98.8%
metadata-eval98.8%
Simplified98.8%
*-un-lft-identity98.8%
times-frac98.8%
Applied egg-rr98.8%
Taylor expanded in z around 0 77.8%
metadata-eval77.8%
distribute-lft-neg-in77.8%
+-commutative77.8%
distribute-rgt-neg-in77.8%
distribute-lft-in77.8%
sub-neg77.8%
*-commutative77.8%
associate-/l*77.8%
Simplified77.8%
Taylor expanded in t around 0 75.5%
metadata-eval75.5%
times-frac75.7%
*-commutative75.7%
associate-*r/75.7%
neg-mul-175.7%
associate-/r*75.7%
distribute-neg-frac275.7%
metadata-eval75.7%
associate-/l/75.7%
associate-/r*75.7%
Simplified75.7%
if -7.99999999999999955e119 < y < -6.00000000000000011e88 or -7e-34 < y < -1.15e-69Initial program 100.0%
+-commutative100.0%
associate-+r-100.0%
sub-neg100.0%
associate-*l*100.0%
*-commutative100.0%
distribute-frac-neg2100.0%
distribute-rgt-neg-in100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in z around inf 85.0%
if -6.00000000000000011e88 < y < -1.7999999999999999e23Initial program 99.8%
+-commutative99.8%
associate-+r-99.8%
sub-neg99.8%
associate-*l*99.8%
*-commutative99.8%
distribute-frac-neg299.8%
distribute-rgt-neg-in99.8%
metadata-eval99.8%
Simplified99.8%
*-un-lft-identity99.8%
times-frac99.8%
Applied egg-rr99.8%
Taylor expanded in y around inf 48.7%
*-commutative48.7%
metadata-eval48.7%
div-inv48.9%
Applied egg-rr48.9%
if -1.7999999999999999e23 < y < -7e-34 or -1.15e-69 < y < 9.5000000000000003e30Initial program 95.2%
+-commutative95.2%
associate-+r-95.2%
sub-neg95.2%
associate-*l*95.3%
*-commutative95.3%
distribute-frac-neg295.3%
distribute-rgt-neg-in95.3%
metadata-eval95.3%
Simplified95.3%
*-un-lft-identity95.3%
times-frac95.3%
Applied egg-rr95.3%
Taylor expanded in t around inf 66.5%
Final simplification69.8%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (/ (/ y -3.0) z)))
(if (<= y -2.05e+114)
t_1
(if (<= y -1.18e+89)
x
(if (<= y -2.65e+21)
(/ (/ y z) -3.0)
(if (<= y -1.72e-34)
(* 0.3333333333333333 (/ t (* z y)))
(if (<= y -1.4e-59)
x
(if (<= y 7.6e+25)
(* 0.3333333333333333 (/ (/ t z) y))
t_1))))))))
double code(double x, double y, double z, double t) {
double t_1 = (y / -3.0) / z;
double tmp;
if (y <= -2.05e+114) {
tmp = t_1;
} else if (y <= -1.18e+89) {
tmp = x;
} else if (y <= -2.65e+21) {
tmp = (y / z) / -3.0;
} else if (y <= -1.72e-34) {
tmp = 0.3333333333333333 * (t / (z * y));
} else if (y <= -1.4e-59) {
tmp = x;
} else if (y <= 7.6e+25) {
tmp = 0.3333333333333333 * ((t / z) / y);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: t_1
real(8) :: tmp
t_1 = (y / (-3.0d0)) / z
if (y <= (-2.05d+114)) then
tmp = t_1
else if (y <= (-1.18d+89)) then
tmp = x
else if (y <= (-2.65d+21)) then
tmp = (y / z) / (-3.0d0)
else if (y <= (-1.72d-34)) then
tmp = 0.3333333333333333d0 * (t / (z * y))
else if (y <= (-1.4d-59)) then
tmp = x
else if (y <= 7.6d+25) then
tmp = 0.3333333333333333d0 * ((t / z) / y)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = (y / -3.0) / z;
double tmp;
if (y <= -2.05e+114) {
tmp = t_1;
} else if (y <= -1.18e+89) {
tmp = x;
} else if (y <= -2.65e+21) {
tmp = (y / z) / -3.0;
} else if (y <= -1.72e-34) {
tmp = 0.3333333333333333 * (t / (z * y));
} else if (y <= -1.4e-59) {
tmp = x;
} else if (y <= 7.6e+25) {
tmp = 0.3333333333333333 * ((t / z) / y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t): t_1 = (y / -3.0) / z tmp = 0 if y <= -2.05e+114: tmp = t_1 elif y <= -1.18e+89: tmp = x elif y <= -2.65e+21: tmp = (y / z) / -3.0 elif y <= -1.72e-34: tmp = 0.3333333333333333 * (t / (z * y)) elif y <= -1.4e-59: tmp = x elif y <= 7.6e+25: tmp = 0.3333333333333333 * ((t / z) / y) else: tmp = t_1 return tmp
function code(x, y, z, t) t_1 = Float64(Float64(y / -3.0) / z) tmp = 0.0 if (y <= -2.05e+114) tmp = t_1; elseif (y <= -1.18e+89) tmp = x; elseif (y <= -2.65e+21) tmp = Float64(Float64(y / z) / -3.0); elseif (y <= -1.72e-34) tmp = Float64(0.3333333333333333 * Float64(t / Float64(z * y))); elseif (y <= -1.4e-59) tmp = x; elseif (y <= 7.6e+25) tmp = Float64(0.3333333333333333 * Float64(Float64(t / z) / y)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = (y / -3.0) / z; tmp = 0.0; if (y <= -2.05e+114) tmp = t_1; elseif (y <= -1.18e+89) tmp = x; elseif (y <= -2.65e+21) tmp = (y / z) / -3.0; elseif (y <= -1.72e-34) tmp = 0.3333333333333333 * (t / (z * y)); elseif (y <= -1.4e-59) tmp = x; elseif (y <= 7.6e+25) tmp = 0.3333333333333333 * ((t / z) / y); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(y / -3.0), $MachinePrecision] / z), $MachinePrecision]}, If[LessEqual[y, -2.05e+114], t$95$1, If[LessEqual[y, -1.18e+89], x, If[LessEqual[y, -2.65e+21], N[(N[(y / z), $MachinePrecision] / -3.0), $MachinePrecision], If[LessEqual[y, -1.72e-34], N[(0.3333333333333333 * N[(t / N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -1.4e-59], x, If[LessEqual[y, 7.6e+25], N[(0.3333333333333333 * N[(N[(t / z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\frac{y}{-3}}{z}\\
\mathbf{if}\;y \leq -2.05 \cdot 10^{+114}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -1.18 \cdot 10^{+89}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq -2.65 \cdot 10^{+21}:\\
\;\;\;\;\frac{\frac{y}{z}}{-3}\\
\mathbf{elif}\;y \leq -1.72 \cdot 10^{-34}:\\
\;\;\;\;0.3333333333333333 \cdot \frac{t}{z \cdot y}\\
\mathbf{elif}\;y \leq -1.4 \cdot 10^{-59}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 7.6 \cdot 10^{+25}:\\
\;\;\;\;0.3333333333333333 \cdot \frac{\frac{t}{z}}{y}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -2.05e114 or 7.6000000000000001e25 < y Initial program 98.9%
+-commutative98.9%
associate-+r-98.9%
sub-neg98.9%
associate-*l*98.8%
*-commutative98.8%
distribute-frac-neg298.8%
distribute-rgt-neg-in98.8%
metadata-eval98.8%
Simplified98.8%
*-un-lft-identity98.8%
times-frac98.8%
Applied egg-rr98.8%
Taylor expanded in z around 0 77.8%
metadata-eval77.8%
distribute-lft-neg-in77.8%
+-commutative77.8%
distribute-rgt-neg-in77.8%
distribute-lft-in77.8%
sub-neg77.8%
*-commutative77.8%
associate-/l*77.8%
Simplified77.8%
Taylor expanded in t around 0 75.5%
metadata-eval75.5%
times-frac75.7%
*-commutative75.7%
associate-*r/75.7%
neg-mul-175.7%
associate-/r*75.7%
distribute-neg-frac275.7%
metadata-eval75.7%
associate-/l/75.7%
associate-/r*75.7%
Simplified75.7%
if -2.05e114 < y < -1.17999999999999993e89 or -1.7200000000000001e-34 < y < -1.3999999999999999e-59Initial program 100.0%
+-commutative100.0%
associate-+r-100.0%
sub-neg100.0%
associate-*l*100.0%
*-commutative100.0%
distribute-frac-neg2100.0%
distribute-rgt-neg-in100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in z around inf 85.0%
if -1.17999999999999993e89 < y < -2.65e21Initial program 99.8%
+-commutative99.8%
associate-+r-99.8%
sub-neg99.8%
associate-*l*99.8%
*-commutative99.8%
distribute-frac-neg299.8%
distribute-rgt-neg-in99.8%
metadata-eval99.8%
Simplified99.8%
*-un-lft-identity99.8%
times-frac99.8%
Applied egg-rr99.8%
Taylor expanded in y around inf 48.7%
*-commutative48.7%
metadata-eval48.7%
div-inv48.9%
Applied egg-rr48.9%
if -2.65e21 < y < -1.7200000000000001e-34Initial program 99.3%
+-commutative99.3%
associate-+r-99.3%
sub-neg99.3%
associate-*l*99.5%
*-commutative99.5%
distribute-frac-neg299.5%
distribute-rgt-neg-in99.5%
metadata-eval99.5%
Simplified99.5%
*-un-lft-identity99.5%
times-frac99.5%
Applied egg-rr99.5%
Taylor expanded in t around inf 59.7%
if -1.3999999999999999e-59 < y < 7.6000000000000001e25Initial program 94.8%
+-commutative94.8%
associate-+r-94.8%
sub-neg94.8%
associate-*l*94.8%
*-commutative94.8%
distribute-frac-neg294.8%
distribute-rgt-neg-in94.8%
metadata-eval94.8%
Simplified94.8%
*-un-lft-identity94.8%
times-frac94.8%
Applied egg-rr94.8%
Taylor expanded in t around inf 67.3%
associate-/l/71.4%
Simplified71.4%
Final simplification71.5%
(FPCore (x y z t)
:precision binary64
(if (<= y -1.15e+111)
(/ (/ y -3.0) z)
(if (<= y -9.6e+88)
x
(if (<= y -8.5e+21)
(/ (/ y z) -3.0)
(if (<= y -2.1e-35)
(* 0.3333333333333333 (/ t (* z y)))
(if (<= y -1.05e-60)
x
(if (<= y 1.14e+26)
(* 0.3333333333333333 (/ (/ t z) y))
(* (/ -1.0 z) (/ y 3.0)))))))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -1.15e+111) {
tmp = (y / -3.0) / z;
} else if (y <= -9.6e+88) {
tmp = x;
} else if (y <= -8.5e+21) {
tmp = (y / z) / -3.0;
} else if (y <= -2.1e-35) {
tmp = 0.3333333333333333 * (t / (z * y));
} else if (y <= -1.05e-60) {
tmp = x;
} else if (y <= 1.14e+26) {
tmp = 0.3333333333333333 * ((t / z) / y);
} else {
tmp = (-1.0 / z) * (y / 3.0);
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (y <= (-1.15d+111)) then
tmp = (y / (-3.0d0)) / z
else if (y <= (-9.6d+88)) then
tmp = x
else if (y <= (-8.5d+21)) then
tmp = (y / z) / (-3.0d0)
else if (y <= (-2.1d-35)) then
tmp = 0.3333333333333333d0 * (t / (z * y))
else if (y <= (-1.05d-60)) then
tmp = x
else if (y <= 1.14d+26) then
tmp = 0.3333333333333333d0 * ((t / z) / y)
else
tmp = ((-1.0d0) / z) * (y / 3.0d0)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (y <= -1.15e+111) {
tmp = (y / -3.0) / z;
} else if (y <= -9.6e+88) {
tmp = x;
} else if (y <= -8.5e+21) {
tmp = (y / z) / -3.0;
} else if (y <= -2.1e-35) {
tmp = 0.3333333333333333 * (t / (z * y));
} else if (y <= -1.05e-60) {
tmp = x;
} else if (y <= 1.14e+26) {
tmp = 0.3333333333333333 * ((t / z) / y);
} else {
tmp = (-1.0 / z) * (y / 3.0);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if y <= -1.15e+111: tmp = (y / -3.0) / z elif y <= -9.6e+88: tmp = x elif y <= -8.5e+21: tmp = (y / z) / -3.0 elif y <= -2.1e-35: tmp = 0.3333333333333333 * (t / (z * y)) elif y <= -1.05e-60: tmp = x elif y <= 1.14e+26: tmp = 0.3333333333333333 * ((t / z) / y) else: tmp = (-1.0 / z) * (y / 3.0) return tmp
function code(x, y, z, t) tmp = 0.0 if (y <= -1.15e+111) tmp = Float64(Float64(y / -3.0) / z); elseif (y <= -9.6e+88) tmp = x; elseif (y <= -8.5e+21) tmp = Float64(Float64(y / z) / -3.0); elseif (y <= -2.1e-35) tmp = Float64(0.3333333333333333 * Float64(t / Float64(z * y))); elseif (y <= -1.05e-60) tmp = x; elseif (y <= 1.14e+26) tmp = Float64(0.3333333333333333 * Float64(Float64(t / z) / y)); else tmp = Float64(Float64(-1.0 / z) * Float64(y / 3.0)); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (y <= -1.15e+111) tmp = (y / -3.0) / z; elseif (y <= -9.6e+88) tmp = x; elseif (y <= -8.5e+21) tmp = (y / z) / -3.0; elseif (y <= -2.1e-35) tmp = 0.3333333333333333 * (t / (z * y)); elseif (y <= -1.05e-60) tmp = x; elseif (y <= 1.14e+26) tmp = 0.3333333333333333 * ((t / z) / y); else tmp = (-1.0 / z) * (y / 3.0); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[y, -1.15e+111], N[(N[(y / -3.0), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[y, -9.6e+88], x, If[LessEqual[y, -8.5e+21], N[(N[(y / z), $MachinePrecision] / -3.0), $MachinePrecision], If[LessEqual[y, -2.1e-35], N[(0.3333333333333333 * N[(t / N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -1.05e-60], x, If[LessEqual[y, 1.14e+26], N[(0.3333333333333333 * N[(N[(t / z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], N[(N[(-1.0 / z), $MachinePrecision] * N[(y / 3.0), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.15 \cdot 10^{+111}:\\
\;\;\;\;\frac{\frac{y}{-3}}{z}\\
\mathbf{elif}\;y \leq -9.6 \cdot 10^{+88}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq -8.5 \cdot 10^{+21}:\\
\;\;\;\;\frac{\frac{y}{z}}{-3}\\
\mathbf{elif}\;y \leq -2.1 \cdot 10^{-35}:\\
\;\;\;\;0.3333333333333333 \cdot \frac{t}{z \cdot y}\\
\mathbf{elif}\;y \leq -1.05 \cdot 10^{-60}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 1.14 \cdot 10^{+26}:\\
\;\;\;\;0.3333333333333333 \cdot \frac{\frac{t}{z}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{z} \cdot \frac{y}{3}\\
\end{array}
\end{array}
if y < -1.15000000000000001e111Initial program 97.3%
+-commutative97.3%
associate-+r-97.3%
sub-neg97.3%
associate-*l*97.2%
*-commutative97.2%
distribute-frac-neg297.2%
distribute-rgt-neg-in97.2%
metadata-eval97.2%
Simplified97.2%
*-un-lft-identity97.2%
times-frac97.2%
Applied egg-rr97.2%
Taylor expanded in z around 0 75.1%
metadata-eval75.1%
distribute-lft-neg-in75.1%
+-commutative75.1%
distribute-rgt-neg-in75.1%
distribute-lft-in75.1%
sub-neg75.1%
*-commutative75.1%
associate-/l*75.0%
Simplified75.0%
Taylor expanded in t around 0 72.5%
metadata-eval72.5%
times-frac72.6%
*-commutative72.6%
associate-*r/72.6%
neg-mul-172.6%
associate-/r*72.5%
distribute-neg-frac272.5%
metadata-eval72.5%
associate-/l/72.6%
associate-/r*72.7%
Simplified72.7%
if -1.15000000000000001e111 < y < -9.5999999999999996e88 or -2.1e-35 < y < -1.04999999999999996e-60Initial program 100.0%
+-commutative100.0%
associate-+r-100.0%
sub-neg100.0%
associate-*l*100.0%
*-commutative100.0%
distribute-frac-neg2100.0%
distribute-rgt-neg-in100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in z around inf 85.0%
if -9.5999999999999996e88 < y < -8.5e21Initial program 99.8%
+-commutative99.8%
associate-+r-99.8%
sub-neg99.8%
associate-*l*99.8%
*-commutative99.8%
distribute-frac-neg299.8%
distribute-rgt-neg-in99.8%
metadata-eval99.8%
Simplified99.8%
*-un-lft-identity99.8%
times-frac99.8%
Applied egg-rr99.8%
Taylor expanded in y around inf 48.7%
*-commutative48.7%
metadata-eval48.7%
div-inv48.9%
Applied egg-rr48.9%
if -8.5e21 < y < -2.1e-35Initial program 99.3%
+-commutative99.3%
associate-+r-99.3%
sub-neg99.3%
associate-*l*99.5%
*-commutative99.5%
distribute-frac-neg299.5%
distribute-rgt-neg-in99.5%
metadata-eval99.5%
Simplified99.5%
*-un-lft-identity99.5%
times-frac99.5%
Applied egg-rr99.5%
Taylor expanded in t around inf 59.7%
if -1.04999999999999996e-60 < y < 1.1399999999999999e26Initial program 94.8%
+-commutative94.8%
associate-+r-94.8%
sub-neg94.8%
associate-*l*94.8%
*-commutative94.8%
distribute-frac-neg294.8%
distribute-rgt-neg-in94.8%
metadata-eval94.8%
Simplified94.8%
*-un-lft-identity94.8%
times-frac94.8%
Applied egg-rr94.8%
Taylor expanded in t around inf 67.3%
associate-/l/71.4%
Simplified71.4%
if 1.1399999999999999e26 < y Initial program 99.8%
+-commutative99.8%
associate-+r-99.8%
sub-neg99.8%
associate-*l*99.8%
*-commutative99.8%
distribute-frac-neg299.8%
distribute-rgt-neg-in99.8%
metadata-eval99.8%
Simplified99.8%
add-cube-cbrt99.8%
*-commutative99.8%
associate-*l*99.8%
*-commutative99.8%
times-frac99.8%
pow299.8%
Applied egg-rr99.8%
associate-*l/92.0%
associate-*r/92.0%
unpow292.0%
rem-3cbrt-lft92.0%
Simplified92.0%
Taylor expanded in y around inf 77.4%
*-commutative77.4%
associate-*l/77.5%
Simplified77.5%
*-commutative77.5%
associate-/l*77.4%
metadata-eval77.4%
times-frac77.6%
*-commutative77.6%
times-frac77.6%
Applied egg-rr77.6%
Final simplification71.6%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (+ x (* (/ t y) (/ 0.3333333333333333 z))))
(t_2 (- x (/ y (* z 3.0)))))
(if (<= y -9e+21)
t_2
(if (<= y 4e-278)
t_1
(if (<= y 2.2e-197)
(/ 0.3333333333333333 (* y (/ z t)))
(if (<= y 5.4e+23) t_1 t_2))))))
double code(double x, double y, double z, double t) {
double t_1 = x + ((t / y) * (0.3333333333333333 / z));
double t_2 = x - (y / (z * 3.0));
double tmp;
if (y <= -9e+21) {
tmp = t_2;
} else if (y <= 4e-278) {
tmp = t_1;
} else if (y <= 2.2e-197) {
tmp = 0.3333333333333333 / (y * (z / t));
} else if (y <= 5.4e+23) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x + ((t / y) * (0.3333333333333333d0 / z))
t_2 = x - (y / (z * 3.0d0))
if (y <= (-9d+21)) then
tmp = t_2
else if (y <= 4d-278) then
tmp = t_1
else if (y <= 2.2d-197) then
tmp = 0.3333333333333333d0 / (y * (z / t))
else if (y <= 5.4d+23) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = x + ((t / y) * (0.3333333333333333 / z));
double t_2 = x - (y / (z * 3.0));
double tmp;
if (y <= -9e+21) {
tmp = t_2;
} else if (y <= 4e-278) {
tmp = t_1;
} else if (y <= 2.2e-197) {
tmp = 0.3333333333333333 / (y * (z / t));
} else if (y <= 5.4e+23) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t): t_1 = x + ((t / y) * (0.3333333333333333 / z)) t_2 = x - (y / (z * 3.0)) tmp = 0 if y <= -9e+21: tmp = t_2 elif y <= 4e-278: tmp = t_1 elif y <= 2.2e-197: tmp = 0.3333333333333333 / (y * (z / t)) elif y <= 5.4e+23: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t) t_1 = Float64(x + Float64(Float64(t / y) * Float64(0.3333333333333333 / z))) t_2 = Float64(x - Float64(y / Float64(z * 3.0))) tmp = 0.0 if (y <= -9e+21) tmp = t_2; elseif (y <= 4e-278) tmp = t_1; elseif (y <= 2.2e-197) tmp = Float64(0.3333333333333333 / Float64(y * Float64(z / t))); elseif (y <= 5.4e+23) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = x + ((t / y) * (0.3333333333333333 / z)); t_2 = x - (y / (z * 3.0)); tmp = 0.0; if (y <= -9e+21) tmp = t_2; elseif (y <= 4e-278) tmp = t_1; elseif (y <= 2.2e-197) tmp = 0.3333333333333333 / (y * (z / t)); elseif (y <= 5.4e+23) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x + N[(N[(t / y), $MachinePrecision] * N[(0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -9e+21], t$95$2, If[LessEqual[y, 4e-278], t$95$1, If[LessEqual[y, 2.2e-197], N[(0.3333333333333333 / N[(y * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.4e+23], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{t}{y} \cdot \frac{0.3333333333333333}{z}\\
t_2 := x - \frac{y}{z \cdot 3}\\
\mathbf{if}\;y \leq -9 \cdot 10^{+21}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq 4 \cdot 10^{-278}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 2.2 \cdot 10^{-197}:\\
\;\;\;\;\frac{0.3333333333333333}{y \cdot \frac{z}{t}}\\
\mathbf{elif}\;y \leq 5.4 \cdot 10^{+23}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if y < -9e21 or 5.3999999999999997e23 < y Initial program 99.0%
Taylor expanded in t around 0 96.4%
metadata-eval96.4%
times-frac96.5%
*-un-lft-identity96.5%
*-commutative96.5%
Applied egg-rr96.5%
if -9e21 < y < 3.99999999999999975e-278 or 2.2e-197 < y < 5.3999999999999997e23Initial program 95.7%
sub-neg95.7%
associate-+l+95.7%
+-commutative95.7%
remove-double-neg95.7%
distribute-frac-neg95.7%
distribute-neg-in95.7%
remove-double-neg95.7%
sub-neg95.7%
neg-mul-195.7%
times-frac92.2%
distribute-frac-neg92.2%
neg-mul-192.2%
*-commutative92.2%
associate-/l*92.2%
*-commutative92.2%
Simplified92.2%
Taylor expanded in t around inf 92.7%
associate-/r*88.5%
associate-*r/88.4%
associate-*l/88.4%
*-commutative88.4%
Simplified88.4%
if 3.99999999999999975e-278 < y < 2.2e-197Initial program 94.7%
+-commutative94.7%
associate-+r-94.7%
sub-neg94.7%
associate-*l*94.7%
*-commutative94.7%
distribute-frac-neg294.7%
distribute-rgt-neg-in94.7%
metadata-eval94.7%
Simplified94.7%
*-un-lft-identity94.7%
times-frac94.7%
Applied egg-rr94.7%
Taylor expanded in t around inf 89.2%
associate-/l/94.0%
Simplified94.0%
clear-num94.2%
un-div-inv94.4%
div-inv94.2%
clear-num94.2%
Applied egg-rr94.2%
Final simplification92.8%
(FPCore (x y z t) :precision binary64 (if (or (<= (* z 3.0) -5e+20) (not (<= (* z 3.0) 8e+142))) (- x (/ y (* z 3.0))) (* (- (/ t y) y) (/ 0.3333333333333333 z))))
double code(double x, double y, double z, double t) {
double tmp;
if (((z * 3.0) <= -5e+20) || !((z * 3.0) <= 8e+142)) {
tmp = x - (y / (z * 3.0));
} else {
tmp = ((t / y) - y) * (0.3333333333333333 / z);
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (((z * 3.0d0) <= (-5d+20)) .or. (.not. ((z * 3.0d0) <= 8d+142))) then
tmp = x - (y / (z * 3.0d0))
else
tmp = ((t / y) - y) * (0.3333333333333333d0 / z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (((z * 3.0) <= -5e+20) || !((z * 3.0) <= 8e+142)) {
tmp = x - (y / (z * 3.0));
} else {
tmp = ((t / y) - y) * (0.3333333333333333 / z);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if ((z * 3.0) <= -5e+20) or not ((z * 3.0) <= 8e+142): tmp = x - (y / (z * 3.0)) else: tmp = ((t / y) - y) * (0.3333333333333333 / z) return tmp
function code(x, y, z, t) tmp = 0.0 if ((Float64(z * 3.0) <= -5e+20) || !(Float64(z * 3.0) <= 8e+142)) tmp = Float64(x - Float64(y / Float64(z * 3.0))); else tmp = Float64(Float64(Float64(t / y) - y) * Float64(0.3333333333333333 / z)); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (((z * 3.0) <= -5e+20) || ~(((z * 3.0) <= 8e+142))) tmp = x - (y / (z * 3.0)); else tmp = ((t / y) - y) * (0.3333333333333333 / z); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[N[(z * 3.0), $MachinePrecision], -5e+20], N[Not[LessEqual[N[(z * 3.0), $MachinePrecision], 8e+142]], $MachinePrecision]], N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(t / y), $MachinePrecision] - y), $MachinePrecision] * N[(0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \cdot 3 \leq -5 \cdot 10^{+20} \lor \neg \left(z \cdot 3 \leq 8 \cdot 10^{+142}\right):\\
\;\;\;\;x - \frac{y}{z \cdot 3}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{t}{y} - y\right) \cdot \frac{0.3333333333333333}{z}\\
\end{array}
\end{array}
if (*.f64 z 3) < -5e20 or 8.00000000000000041e142 < (*.f64 z 3) Initial program 99.8%
Taylor expanded in t around 0 80.6%
metadata-eval80.6%
times-frac80.8%
*-un-lft-identity80.8%
*-commutative80.8%
Applied egg-rr80.8%
if -5e20 < (*.f64 z 3) < 8.00000000000000041e142Initial program 95.7%
+-commutative95.7%
associate-+r-95.7%
sub-neg95.7%
associate-*l*95.7%
*-commutative95.7%
distribute-frac-neg295.7%
distribute-rgt-neg-in95.7%
metadata-eval95.7%
Simplified95.7%
*-un-lft-identity95.7%
times-frac95.7%
Applied egg-rr95.7%
Taylor expanded in z around 0 84.5%
metadata-eval84.5%
distribute-lft-neg-in84.5%
+-commutative84.5%
distribute-rgt-neg-in84.5%
distribute-lft-in84.5%
sub-neg84.5%
*-commutative84.5%
associate-/l*84.5%
Simplified84.5%
Final simplification83.1%
(FPCore (x y z t) :precision binary64 (if (or (<= y -5.1e-86) (not (<= y 1e-77))) (+ x (* 0.3333333333333333 (/ (- (/ t y) y) z))) (+ x (/ (* t 0.3333333333333333) (* z y)))))
double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -5.1e-86) || !(y <= 1e-77)) {
tmp = x + (0.3333333333333333 * (((t / y) - y) / z));
} else {
tmp = x + ((t * 0.3333333333333333) / (z * y));
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if ((y <= (-5.1d-86)) .or. (.not. (y <= 1d-77))) then
tmp = x + (0.3333333333333333d0 * (((t / y) - y) / z))
else
tmp = x + ((t * 0.3333333333333333d0) / (z * y))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -5.1e-86) || !(y <= 1e-77)) {
tmp = x + (0.3333333333333333 * (((t / y) - y) / z));
} else {
tmp = x + ((t * 0.3333333333333333) / (z * y));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (y <= -5.1e-86) or not (y <= 1e-77): tmp = x + (0.3333333333333333 * (((t / y) - y) / z)) else: tmp = x + ((t * 0.3333333333333333) / (z * y)) return tmp
function code(x, y, z, t) tmp = 0.0 if ((y <= -5.1e-86) || !(y <= 1e-77)) tmp = Float64(x + Float64(0.3333333333333333 * Float64(Float64(Float64(t / y) - y) / z))); else tmp = Float64(x + Float64(Float64(t * 0.3333333333333333) / Float64(z * y))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((y <= -5.1e-86) || ~((y <= 1e-77))) tmp = x + (0.3333333333333333 * (((t / y) - y) / z)); else tmp = x + ((t * 0.3333333333333333) / (z * y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[y, -5.1e-86], N[Not[LessEqual[y, 1e-77]], $MachinePrecision]], N[(x + N[(0.3333333333333333 * N[(N[(N[(t / y), $MachinePrecision] - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(t * 0.3333333333333333), $MachinePrecision] / N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -5.1 \cdot 10^{-86} \lor \neg \left(y \leq 10^{-77}\right):\\
\;\;\;\;x + 0.3333333333333333 \cdot \frac{\frac{t}{y} - y}{z}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{t \cdot 0.3333333333333333}{z \cdot y}\\
\end{array}
\end{array}
if y < -5.10000000000000006e-86 or 9.9999999999999993e-78 < y Initial program 98.6%
sub-neg98.6%
associate-+l+98.6%
+-commutative98.6%
remove-double-neg98.6%
distribute-frac-neg98.6%
distribute-neg-in98.6%
remove-double-neg98.6%
sub-neg98.6%
neg-mul-198.6%
times-frac99.2%
distribute-frac-neg99.2%
neg-mul-199.2%
*-commutative99.2%
associate-/l*99.1%
*-commutative99.1%
Simplified99.8%
Taylor expanded in z around 0 99.7%
if -5.10000000000000006e-86 < y < 9.9999999999999993e-78Initial program 94.7%
+-commutative94.7%
associate-+r-94.7%
sub-neg94.7%
associate-*l*94.6%
*-commutative94.6%
distribute-frac-neg294.6%
distribute-rgt-neg-in94.6%
metadata-eval94.6%
Simplified94.6%
Taylor expanded in y around 0 94.5%
+-commutative94.5%
Simplified94.5%
associate-*r/94.6%
*-commutative94.6%
Applied egg-rr94.6%
Final simplification98.0%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (- (/ t y) y)))
(if (<= y -3.7e-86)
(+ x (* 0.3333333333333333 (/ t_1 z)))
(if (<= y 1.5e-78)
(+ x (/ (* t 0.3333333333333333) (* z y)))
(+ x (* t_1 (/ 0.3333333333333333 z)))))))
double code(double x, double y, double z, double t) {
double t_1 = (t / y) - y;
double tmp;
if (y <= -3.7e-86) {
tmp = x + (0.3333333333333333 * (t_1 / z));
} else if (y <= 1.5e-78) {
tmp = x + ((t * 0.3333333333333333) / (z * y));
} else {
tmp = x + (t_1 * (0.3333333333333333 / z));
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: t_1
real(8) :: tmp
t_1 = (t / y) - y
if (y <= (-3.7d-86)) then
tmp = x + (0.3333333333333333d0 * (t_1 / z))
else if (y <= 1.5d-78) then
tmp = x + ((t * 0.3333333333333333d0) / (z * y))
else
tmp = x + (t_1 * (0.3333333333333333d0 / z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = (t / y) - y;
double tmp;
if (y <= -3.7e-86) {
tmp = x + (0.3333333333333333 * (t_1 / z));
} else if (y <= 1.5e-78) {
tmp = x + ((t * 0.3333333333333333) / (z * y));
} else {
tmp = x + (t_1 * (0.3333333333333333 / z));
}
return tmp;
}
def code(x, y, z, t): t_1 = (t / y) - y tmp = 0 if y <= -3.7e-86: tmp = x + (0.3333333333333333 * (t_1 / z)) elif y <= 1.5e-78: tmp = x + ((t * 0.3333333333333333) / (z * y)) else: tmp = x + (t_1 * (0.3333333333333333 / z)) return tmp
function code(x, y, z, t) t_1 = Float64(Float64(t / y) - y) tmp = 0.0 if (y <= -3.7e-86) tmp = Float64(x + Float64(0.3333333333333333 * Float64(t_1 / z))); elseif (y <= 1.5e-78) tmp = Float64(x + Float64(Float64(t * 0.3333333333333333) / Float64(z * y))); else tmp = Float64(x + Float64(t_1 * Float64(0.3333333333333333 / z))); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = (t / y) - y; tmp = 0.0; if (y <= -3.7e-86) tmp = x + (0.3333333333333333 * (t_1 / z)); elseif (y <= 1.5e-78) tmp = x + ((t * 0.3333333333333333) / (z * y)); else tmp = x + (t_1 * (0.3333333333333333 / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(t / y), $MachinePrecision] - y), $MachinePrecision]}, If[LessEqual[y, -3.7e-86], N[(x + N[(0.3333333333333333 * N[(t$95$1 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.5e-78], N[(x + N[(N[(t * 0.3333333333333333), $MachinePrecision] / N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(t$95$1 * N[(0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t}{y} - y\\
\mathbf{if}\;y \leq -3.7 \cdot 10^{-86}:\\
\;\;\;\;x + 0.3333333333333333 \cdot \frac{t\_1}{z}\\
\mathbf{elif}\;y \leq 1.5 \cdot 10^{-78}:\\
\;\;\;\;x + \frac{t \cdot 0.3333333333333333}{z \cdot y}\\
\mathbf{else}:\\
\;\;\;\;x + t\_1 \cdot \frac{0.3333333333333333}{z}\\
\end{array}
\end{array}
if y < -3.6999999999999998e-86Initial program 98.6%
sub-neg98.6%
associate-+l+98.6%
+-commutative98.6%
remove-double-neg98.6%
distribute-frac-neg98.6%
distribute-neg-in98.6%
remove-double-neg98.6%
sub-neg98.6%
neg-mul-198.6%
times-frac98.7%
distribute-frac-neg98.7%
neg-mul-198.7%
*-commutative98.7%
associate-/l*98.6%
*-commutative98.6%
Simplified99.8%
Taylor expanded in z around 0 99.8%
if -3.6999999999999998e-86 < y < 1.49999999999999994e-78Initial program 94.7%
+-commutative94.7%
associate-+r-94.7%
sub-neg94.7%
associate-*l*94.6%
*-commutative94.6%
distribute-frac-neg294.6%
distribute-rgt-neg-in94.6%
metadata-eval94.6%
Simplified94.6%
Taylor expanded in y around 0 94.5%
+-commutative94.5%
Simplified94.5%
associate-*r/94.6%
*-commutative94.6%
Applied egg-rr94.6%
if 1.49999999999999994e-78 < y Initial program 98.6%
sub-neg98.6%
associate-+l+98.6%
+-commutative98.6%
remove-double-neg98.6%
distribute-frac-neg98.6%
distribute-neg-in98.6%
remove-double-neg98.6%
sub-neg98.6%
neg-mul-198.6%
times-frac99.8%
distribute-frac-neg99.8%
neg-mul-199.8%
*-commutative99.8%
associate-/l*99.7%
*-commutative99.7%
Simplified99.8%
Final simplification98.0%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (- (/ t y) y)))
(if (<= y -1e-85)
(+ x (/ t_1 (* z 3.0)))
(if (<= y 1.22e-79)
(+ x (/ (* t 0.3333333333333333) (* z y)))
(+ x (* t_1 (/ 0.3333333333333333 z)))))))
double code(double x, double y, double z, double t) {
double t_1 = (t / y) - y;
double tmp;
if (y <= -1e-85) {
tmp = x + (t_1 / (z * 3.0));
} else if (y <= 1.22e-79) {
tmp = x + ((t * 0.3333333333333333) / (z * y));
} else {
tmp = x + (t_1 * (0.3333333333333333 / z));
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: t_1
real(8) :: tmp
t_1 = (t / y) - y
if (y <= (-1d-85)) then
tmp = x + (t_1 / (z * 3.0d0))
else if (y <= 1.22d-79) then
tmp = x + ((t * 0.3333333333333333d0) / (z * y))
else
tmp = x + (t_1 * (0.3333333333333333d0 / z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = (t / y) - y;
double tmp;
if (y <= -1e-85) {
tmp = x + (t_1 / (z * 3.0));
} else if (y <= 1.22e-79) {
tmp = x + ((t * 0.3333333333333333) / (z * y));
} else {
tmp = x + (t_1 * (0.3333333333333333 / z));
}
return tmp;
}
def code(x, y, z, t): t_1 = (t / y) - y tmp = 0 if y <= -1e-85: tmp = x + (t_1 / (z * 3.0)) elif y <= 1.22e-79: tmp = x + ((t * 0.3333333333333333) / (z * y)) else: tmp = x + (t_1 * (0.3333333333333333 / z)) return tmp
function code(x, y, z, t) t_1 = Float64(Float64(t / y) - y) tmp = 0.0 if (y <= -1e-85) tmp = Float64(x + Float64(t_1 / Float64(z * 3.0))); elseif (y <= 1.22e-79) tmp = Float64(x + Float64(Float64(t * 0.3333333333333333) / Float64(z * y))); else tmp = Float64(x + Float64(t_1 * Float64(0.3333333333333333 / z))); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = (t / y) - y; tmp = 0.0; if (y <= -1e-85) tmp = x + (t_1 / (z * 3.0)); elseif (y <= 1.22e-79) tmp = x + ((t * 0.3333333333333333) / (z * y)); else tmp = x + (t_1 * (0.3333333333333333 / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(t / y), $MachinePrecision] - y), $MachinePrecision]}, If[LessEqual[y, -1e-85], N[(x + N[(t$95$1 / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.22e-79], N[(x + N[(N[(t * 0.3333333333333333), $MachinePrecision] / N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(t$95$1 * N[(0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t}{y} - y\\
\mathbf{if}\;y \leq -1 \cdot 10^{-85}:\\
\;\;\;\;x + \frac{t\_1}{z \cdot 3}\\
\mathbf{elif}\;y \leq 1.22 \cdot 10^{-79}:\\
\;\;\;\;x + \frac{t \cdot 0.3333333333333333}{z \cdot y}\\
\mathbf{else}:\\
\;\;\;\;x + t\_1 \cdot \frac{0.3333333333333333}{z}\\
\end{array}
\end{array}
if y < -9.9999999999999998e-86Initial program 98.6%
sub-neg98.6%
associate-+l+98.6%
+-commutative98.6%
remove-double-neg98.6%
distribute-frac-neg98.6%
distribute-neg-in98.6%
remove-double-neg98.6%
sub-neg98.6%
neg-mul-198.6%
times-frac98.7%
distribute-frac-neg98.7%
neg-mul-198.7%
*-commutative98.7%
associate-/l*98.6%
*-commutative98.6%
Simplified99.8%
*-commutative99.8%
clear-num99.7%
div-inv99.8%
metadata-eval99.8%
un-div-inv99.8%
Applied egg-rr99.8%
if -9.9999999999999998e-86 < y < 1.22e-79Initial program 94.7%
+-commutative94.7%
associate-+r-94.7%
sub-neg94.7%
associate-*l*94.6%
*-commutative94.6%
distribute-frac-neg294.6%
distribute-rgt-neg-in94.6%
metadata-eval94.6%
Simplified94.6%
Taylor expanded in y around 0 94.5%
+-commutative94.5%
Simplified94.5%
associate-*r/94.6%
*-commutative94.6%
Applied egg-rr94.6%
if 1.22e-79 < y Initial program 98.6%
sub-neg98.6%
associate-+l+98.6%
+-commutative98.6%
remove-double-neg98.6%
distribute-frac-neg98.6%
distribute-neg-in98.6%
remove-double-neg98.6%
sub-neg98.6%
neg-mul-198.6%
times-frac99.8%
distribute-frac-neg99.8%
neg-mul-199.8%
*-commutative99.8%
associate-/l*99.7%
*-commutative99.7%
Simplified99.8%
Final simplification98.0%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (- (/ t y) y)))
(if (<= y -1.1e-50)
(+ x (/ t_1 (* z 3.0)))
(if (<= y 4.5e-80)
(+ x (* t (/ 1.0 (* z (* 3.0 y)))))
(+ x (* t_1 (/ 0.3333333333333333 z)))))))
double code(double x, double y, double z, double t) {
double t_1 = (t / y) - y;
double tmp;
if (y <= -1.1e-50) {
tmp = x + (t_1 / (z * 3.0));
} else if (y <= 4.5e-80) {
tmp = x + (t * (1.0 / (z * (3.0 * y))));
} else {
tmp = x + (t_1 * (0.3333333333333333 / z));
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: t_1
real(8) :: tmp
t_1 = (t / y) - y
if (y <= (-1.1d-50)) then
tmp = x + (t_1 / (z * 3.0d0))
else if (y <= 4.5d-80) then
tmp = x + (t * (1.0d0 / (z * (3.0d0 * y))))
else
tmp = x + (t_1 * (0.3333333333333333d0 / z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = (t / y) - y;
double tmp;
if (y <= -1.1e-50) {
tmp = x + (t_1 / (z * 3.0));
} else if (y <= 4.5e-80) {
tmp = x + (t * (1.0 / (z * (3.0 * y))));
} else {
tmp = x + (t_1 * (0.3333333333333333 / z));
}
return tmp;
}
def code(x, y, z, t): t_1 = (t / y) - y tmp = 0 if y <= -1.1e-50: tmp = x + (t_1 / (z * 3.0)) elif y <= 4.5e-80: tmp = x + (t * (1.0 / (z * (3.0 * y)))) else: tmp = x + (t_1 * (0.3333333333333333 / z)) return tmp
function code(x, y, z, t) t_1 = Float64(Float64(t / y) - y) tmp = 0.0 if (y <= -1.1e-50) tmp = Float64(x + Float64(t_1 / Float64(z * 3.0))); elseif (y <= 4.5e-80) tmp = Float64(x + Float64(t * Float64(1.0 / Float64(z * Float64(3.0 * y))))); else tmp = Float64(x + Float64(t_1 * Float64(0.3333333333333333 / z))); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = (t / y) - y; tmp = 0.0; if (y <= -1.1e-50) tmp = x + (t_1 / (z * 3.0)); elseif (y <= 4.5e-80) tmp = x + (t * (1.0 / (z * (3.0 * y)))); else tmp = x + (t_1 * (0.3333333333333333 / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(t / y), $MachinePrecision] - y), $MachinePrecision]}, If[LessEqual[y, -1.1e-50], N[(x + N[(t$95$1 / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.5e-80], N[(x + N[(t * N[(1.0 / N[(z * N[(3.0 * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(t$95$1 * N[(0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t}{y} - y\\
\mathbf{if}\;y \leq -1.1 \cdot 10^{-50}:\\
\;\;\;\;x + \frac{t\_1}{z \cdot 3}\\
\mathbf{elif}\;y \leq 4.5 \cdot 10^{-80}:\\
\;\;\;\;x + t \cdot \frac{1}{z \cdot \left(3 \cdot y\right)}\\
\mathbf{else}:\\
\;\;\;\;x + t\_1 \cdot \frac{0.3333333333333333}{z}\\
\end{array}
\end{array}
if y < -1.0999999999999999e-50Initial program 98.5%
sub-neg98.5%
associate-+l+98.5%
+-commutative98.5%
remove-double-neg98.5%
distribute-frac-neg98.5%
distribute-neg-in98.5%
remove-double-neg98.5%
sub-neg98.5%
neg-mul-198.5%
times-frac98.6%
distribute-frac-neg98.6%
neg-mul-198.6%
*-commutative98.6%
associate-/l*98.5%
*-commutative98.5%
Simplified99.7%
*-commutative99.7%
clear-num99.7%
div-inv99.7%
metadata-eval99.7%
un-div-inv99.8%
Applied egg-rr99.8%
if -1.0999999999999999e-50 < y < 4.5000000000000003e-80Initial program 95.0%
+-commutative95.0%
associate-+r-95.0%
sub-neg95.0%
associate-*l*95.0%
*-commutative95.0%
distribute-frac-neg295.0%
distribute-rgt-neg-in95.0%
metadata-eval95.0%
Simplified95.0%
Taylor expanded in y around 0 94.9%
+-commutative94.9%
Simplified94.9%
metadata-eval94.9%
associate-/r*85.0%
times-frac85.0%
*-un-lft-identity85.0%
*-commutative85.0%
Applied egg-rr85.0%
associate-/l/95.0%
div-inv95.0%
associate-*l*95.0%
Applied egg-rr95.0%
if 4.5000000000000003e-80 < y Initial program 98.6%
sub-neg98.6%
associate-+l+98.6%
+-commutative98.6%
remove-double-neg98.6%
distribute-frac-neg98.6%
distribute-neg-in98.6%
remove-double-neg98.6%
sub-neg98.6%
neg-mul-198.6%
times-frac99.8%
distribute-frac-neg99.8%
neg-mul-199.8%
*-commutative99.8%
associate-/l*99.7%
*-commutative99.7%
Simplified99.8%
Final simplification98.0%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (/ y (* z -3.0))))
(if (<= t 9.5e-232)
(+ (+ (/ (/ t (* z 3.0)) y) x) t_1)
(+ t_1 (+ x (/ t (* z (* 3.0 y))))))))
double code(double x, double y, double z, double t) {
double t_1 = y / (z * -3.0);
double tmp;
if (t <= 9.5e-232) {
tmp = (((t / (z * 3.0)) / y) + x) + t_1;
} else {
tmp = t_1 + (x + (t / (z * (3.0 * y))));
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: t_1
real(8) :: tmp
t_1 = y / (z * (-3.0d0))
if (t <= 9.5d-232) then
tmp = (((t / (z * 3.0d0)) / y) + x) + t_1
else
tmp = t_1 + (x + (t / (z * (3.0d0 * y))))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = y / (z * -3.0);
double tmp;
if (t <= 9.5e-232) {
tmp = (((t / (z * 3.0)) / y) + x) + t_1;
} else {
tmp = t_1 + (x + (t / (z * (3.0 * y))));
}
return tmp;
}
def code(x, y, z, t): t_1 = y / (z * -3.0) tmp = 0 if t <= 9.5e-232: tmp = (((t / (z * 3.0)) / y) + x) + t_1 else: tmp = t_1 + (x + (t / (z * (3.0 * y)))) return tmp
function code(x, y, z, t) t_1 = Float64(y / Float64(z * -3.0)) tmp = 0.0 if (t <= 9.5e-232) tmp = Float64(Float64(Float64(Float64(t / Float64(z * 3.0)) / y) + x) + t_1); else tmp = Float64(t_1 + Float64(x + Float64(t / Float64(z * Float64(3.0 * y))))); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = y / (z * -3.0); tmp = 0.0; if (t <= 9.5e-232) tmp = (((t / (z * 3.0)) / y) + x) + t_1; else tmp = t_1 + (x + (t / (z * (3.0 * y)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(y / N[(z * -3.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, 9.5e-232], N[(N[(N[(N[(t / N[(z * 3.0), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision] + x), $MachinePrecision] + t$95$1), $MachinePrecision], N[(t$95$1 + N[(x + N[(t / N[(z * N[(3.0 * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{y}{z \cdot -3}\\
\mathbf{if}\;t \leq 9.5 \cdot 10^{-232}:\\
\;\;\;\;\left(\frac{\frac{t}{z \cdot 3}}{y} + x\right) + t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_1 + \left(x + \frac{t}{z \cdot \left(3 \cdot y\right)}\right)\\
\end{array}
\end{array}
if t < 9.50000000000000033e-232Initial program 96.0%
+-commutative96.0%
associate-+r-96.0%
sub-neg96.0%
associate-*l*96.0%
*-commutative96.0%
distribute-frac-neg296.0%
distribute-rgt-neg-in96.0%
metadata-eval96.0%
Simplified96.0%
add-cube-cbrt95.8%
*-commutative95.8%
associate-*l*95.8%
*-commutative95.8%
times-frac98.2%
pow298.2%
Applied egg-rr98.2%
associate-*l/98.9%
associate-*r/98.9%
unpow298.9%
rem-3cbrt-lft99.2%
Simplified99.2%
if 9.50000000000000033e-232 < t Initial program 98.9%
+-commutative98.9%
associate-+r-98.9%
sub-neg98.9%
associate-*l*98.9%
*-commutative98.9%
distribute-frac-neg298.9%
distribute-rgt-neg-in98.9%
metadata-eval98.9%
Simplified98.9%
Final simplification99.1%
(FPCore (x y z t) :precision binary64 (if (or (<= y -1.12e+24) (not (<= y 1.02e+26))) (- x (/ y (* z 3.0))) (+ x (* 0.3333333333333333 (/ t (* z y))))))
double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -1.12e+24) || !(y <= 1.02e+26)) {
tmp = x - (y / (z * 3.0));
} else {
tmp = x + (0.3333333333333333 * (t / (z * y)));
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if ((y <= (-1.12d+24)) .or. (.not. (y <= 1.02d+26))) then
tmp = x - (y / (z * 3.0d0))
else
tmp = x + (0.3333333333333333d0 * (t / (z * y)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -1.12e+24) || !(y <= 1.02e+26)) {
tmp = x - (y / (z * 3.0));
} else {
tmp = x + (0.3333333333333333 * (t / (z * y)));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (y <= -1.12e+24) or not (y <= 1.02e+26): tmp = x - (y / (z * 3.0)) else: tmp = x + (0.3333333333333333 * (t / (z * y))) return tmp
function code(x, y, z, t) tmp = 0.0 if ((y <= -1.12e+24) || !(y <= 1.02e+26)) tmp = Float64(x - Float64(y / Float64(z * 3.0))); else tmp = Float64(x + Float64(0.3333333333333333 * Float64(t / Float64(z * y)))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((y <= -1.12e+24) || ~((y <= 1.02e+26))) tmp = x - (y / (z * 3.0)); else tmp = x + (0.3333333333333333 * (t / (z * y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[y, -1.12e+24], N[Not[LessEqual[y, 1.02e+26]], $MachinePrecision]], N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(0.3333333333333333 * N[(t / N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.12 \cdot 10^{+24} \lor \neg \left(y \leq 1.02 \cdot 10^{+26}\right):\\
\;\;\;\;x - \frac{y}{z \cdot 3}\\
\mathbf{else}:\\
\;\;\;\;x + 0.3333333333333333 \cdot \frac{t}{z \cdot y}\\
\end{array}
\end{array}
if y < -1.12e24 or 1.0200000000000001e26 < y Initial program 99.0%
Taylor expanded in t around 0 96.4%
metadata-eval96.4%
times-frac96.5%
*-un-lft-identity96.5%
*-commutative96.5%
Applied egg-rr96.5%
if -1.12e24 < y < 1.0200000000000001e26Initial program 95.5%
+-commutative95.5%
associate-+r-95.5%
sub-neg95.5%
associate-*l*95.6%
*-commutative95.6%
distribute-frac-neg295.6%
distribute-rgt-neg-in95.6%
metadata-eval95.6%
Simplified95.6%
Taylor expanded in y around 0 93.0%
+-commutative93.0%
Simplified93.0%
Final simplification94.7%
(FPCore (x y z t) :precision binary64 (if (or (<= y -2.35e-60) (not (<= y 0.00094))) (+ x (* y (/ -0.3333333333333333 z))) (* 0.3333333333333333 (/ (/ t z) y))))
double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -2.35e-60) || !(y <= 0.00094)) {
tmp = x + (y * (-0.3333333333333333 / z));
} else {
tmp = 0.3333333333333333 * ((t / z) / y);
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if ((y <= (-2.35d-60)) .or. (.not. (y <= 0.00094d0))) then
tmp = x + (y * ((-0.3333333333333333d0) / z))
else
tmp = 0.3333333333333333d0 * ((t / z) / y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -2.35e-60) || !(y <= 0.00094)) {
tmp = x + (y * (-0.3333333333333333 / z));
} else {
tmp = 0.3333333333333333 * ((t / z) / y);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (y <= -2.35e-60) or not (y <= 0.00094): tmp = x + (y * (-0.3333333333333333 / z)) else: tmp = 0.3333333333333333 * ((t / z) / y) return tmp
function code(x, y, z, t) tmp = 0.0 if ((y <= -2.35e-60) || !(y <= 0.00094)) tmp = Float64(x + Float64(y * Float64(-0.3333333333333333 / z))); else tmp = Float64(0.3333333333333333 * Float64(Float64(t / z) / y)); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((y <= -2.35e-60) || ~((y <= 0.00094))) tmp = x + (y * (-0.3333333333333333 / z)); else tmp = 0.3333333333333333 * ((t / z) / y); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[y, -2.35e-60], N[Not[LessEqual[y, 0.00094]], $MachinePrecision]], N[(x + N[(y * N[(-0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.3333333333333333 * N[(N[(t / z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -2.35 \cdot 10^{-60} \lor \neg \left(y \leq 0.00094\right):\\
\;\;\;\;x + y \cdot \frac{-0.3333333333333333}{z}\\
\mathbf{else}:\\
\;\;\;\;0.3333333333333333 \cdot \frac{\frac{t}{z}}{y}\\
\end{array}
\end{array}
if y < -2.35e-60 or 9.39999999999999972e-4 < y Initial program 99.1%
sub-neg99.1%
associate-+l+99.1%
+-commutative99.1%
remove-double-neg99.1%
distribute-frac-neg99.1%
distribute-neg-in99.1%
remove-double-neg99.1%
sub-neg99.1%
neg-mul-199.1%
times-frac99.1%
distribute-frac-neg99.1%
neg-mul-199.1%
*-commutative99.1%
associate-/l*99.1%
*-commutative99.1%
Simplified99.8%
Taylor expanded in t around 0 90.6%
associate-*r/90.6%
*-commutative90.6%
associate-*r/90.6%
Simplified90.6%
if -2.35e-60 < y < 9.39999999999999972e-4Initial program 94.6%
+-commutative94.6%
associate-+r-94.6%
sub-neg94.6%
associate-*l*94.6%
*-commutative94.6%
distribute-frac-neg294.6%
distribute-rgt-neg-in94.6%
metadata-eval94.6%
Simplified94.6%
*-un-lft-identity94.6%
times-frac94.6%
Applied egg-rr94.6%
Taylor expanded in t around inf 68.2%
associate-/l/72.4%
Simplified72.4%
Final simplification83.1%
(FPCore (x y z t) :precision binary64 (if (or (<= y -1.3e-62) (not (<= y 0.00094))) (- x (/ y (* z 3.0))) (* 0.3333333333333333 (/ (/ t z) y))))
double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -1.3e-62) || !(y <= 0.00094)) {
tmp = x - (y / (z * 3.0));
} else {
tmp = 0.3333333333333333 * ((t / z) / y);
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if ((y <= (-1.3d-62)) .or. (.not. (y <= 0.00094d0))) then
tmp = x - (y / (z * 3.0d0))
else
tmp = 0.3333333333333333d0 * ((t / z) / y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -1.3e-62) || !(y <= 0.00094)) {
tmp = x - (y / (z * 3.0));
} else {
tmp = 0.3333333333333333 * ((t / z) / y);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (y <= -1.3e-62) or not (y <= 0.00094): tmp = x - (y / (z * 3.0)) else: tmp = 0.3333333333333333 * ((t / z) / y) return tmp
function code(x, y, z, t) tmp = 0.0 if ((y <= -1.3e-62) || !(y <= 0.00094)) tmp = Float64(x - Float64(y / Float64(z * 3.0))); else tmp = Float64(0.3333333333333333 * Float64(Float64(t / z) / y)); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((y <= -1.3e-62) || ~((y <= 0.00094))) tmp = x - (y / (z * 3.0)); else tmp = 0.3333333333333333 * ((t / z) / y); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[y, -1.3e-62], N[Not[LessEqual[y, 0.00094]], $MachinePrecision]], N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.3333333333333333 * N[(N[(t / z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.3 \cdot 10^{-62} \lor \neg \left(y \leq 0.00094\right):\\
\;\;\;\;x - \frac{y}{z \cdot 3}\\
\mathbf{else}:\\
\;\;\;\;0.3333333333333333 \cdot \frac{\frac{t}{z}}{y}\\
\end{array}
\end{array}
if y < -1.3e-62 or 9.39999999999999972e-4 < y Initial program 99.1%
Taylor expanded in t around 0 90.6%
metadata-eval90.6%
times-frac90.7%
*-un-lft-identity90.7%
*-commutative90.7%
Applied egg-rr90.7%
if -1.3e-62 < y < 9.39999999999999972e-4Initial program 94.6%
+-commutative94.6%
associate-+r-94.6%
sub-neg94.6%
associate-*l*94.6%
*-commutative94.6%
distribute-frac-neg294.6%
distribute-rgt-neg-in94.6%
metadata-eval94.6%
Simplified94.6%
*-un-lft-identity94.6%
times-frac94.6%
Applied egg-rr94.6%
Taylor expanded in t around inf 68.2%
associate-/l/72.4%
Simplified72.4%
Final simplification83.1%
(FPCore (x y z t) :precision binary64 (if (<= x -5e+28) x (if (<= x 3.2e+28) (* -0.3333333333333333 (/ y z)) x)))
double code(double x, double y, double z, double t) {
double tmp;
if (x <= -5e+28) {
tmp = x;
} else if (x <= 3.2e+28) {
tmp = -0.3333333333333333 * (y / z);
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (x <= (-5d+28)) then
tmp = x
else if (x <= 3.2d+28) then
tmp = (-0.3333333333333333d0) * (y / z)
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (x <= -5e+28) {
tmp = x;
} else if (x <= 3.2e+28) {
tmp = -0.3333333333333333 * (y / z);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if x <= -5e+28: tmp = x elif x <= 3.2e+28: tmp = -0.3333333333333333 * (y / z) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (x <= -5e+28) tmp = x; elseif (x <= 3.2e+28) tmp = Float64(-0.3333333333333333 * Float64(y / z)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (x <= -5e+28) tmp = x; elseif (x <= 3.2e+28) tmp = -0.3333333333333333 * (y / z); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[x, -5e+28], x, If[LessEqual[x, 3.2e+28], N[(-0.3333333333333333 * N[(y / z), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -5 \cdot 10^{+28}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 3.2 \cdot 10^{+28}:\\
\;\;\;\;-0.3333333333333333 \cdot \frac{y}{z}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -4.99999999999999957e28 or 3.2e28 < x Initial program 99.1%
+-commutative99.1%
associate-+r-99.1%
sub-neg99.1%
associate-*l*99.1%
*-commutative99.1%
distribute-frac-neg299.1%
distribute-rgt-neg-in99.1%
metadata-eval99.1%
Simplified99.1%
Taylor expanded in z around inf 57.9%
if -4.99999999999999957e28 < x < 3.2e28Initial program 95.7%
+-commutative95.7%
associate-+r-95.7%
sub-neg95.7%
associate-*l*95.7%
*-commutative95.7%
distribute-frac-neg295.7%
distribute-rgt-neg-in95.7%
metadata-eval95.7%
Simplified95.7%
*-un-lft-identity95.7%
times-frac95.7%
Applied egg-rr95.7%
Taylor expanded in y around inf 54.0%
Final simplification55.8%
(FPCore (x y z t) :precision binary64 (if (<= x -8e+24) x (if (<= x 1.26e+29) (* y (/ -0.3333333333333333 z)) x)))
double code(double x, double y, double z, double t) {
double tmp;
if (x <= -8e+24) {
tmp = x;
} else if (x <= 1.26e+29) {
tmp = y * (-0.3333333333333333 / z);
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (x <= (-8d+24)) then
tmp = x
else if (x <= 1.26d+29) then
tmp = y * ((-0.3333333333333333d0) / z)
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (x <= -8e+24) {
tmp = x;
} else if (x <= 1.26e+29) {
tmp = y * (-0.3333333333333333 / z);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if x <= -8e+24: tmp = x elif x <= 1.26e+29: tmp = y * (-0.3333333333333333 / z) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (x <= -8e+24) tmp = x; elseif (x <= 1.26e+29) tmp = Float64(y * Float64(-0.3333333333333333 / z)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (x <= -8e+24) tmp = x; elseif (x <= 1.26e+29) tmp = y * (-0.3333333333333333 / z); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[x, -8e+24], x, If[LessEqual[x, 1.26e+29], N[(y * N[(-0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -8 \cdot 10^{+24}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 1.26 \cdot 10^{+29}:\\
\;\;\;\;y \cdot \frac{-0.3333333333333333}{z}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -7.9999999999999999e24 or 1.26e29 < x Initial program 99.1%
+-commutative99.1%
associate-+r-99.1%
sub-neg99.1%
associate-*l*99.1%
*-commutative99.1%
distribute-frac-neg299.1%
distribute-rgt-neg-in99.1%
metadata-eval99.1%
Simplified99.1%
Taylor expanded in z around inf 57.9%
if -7.9999999999999999e24 < x < 1.26e29Initial program 95.7%
+-commutative95.7%
associate-+r-95.7%
sub-neg95.7%
associate-*l*95.7%
*-commutative95.7%
distribute-frac-neg295.7%
distribute-rgt-neg-in95.7%
metadata-eval95.7%
Simplified95.7%
*-un-lft-identity95.7%
times-frac95.7%
Applied egg-rr95.7%
Taylor expanded in y around inf 54.0%
*-commutative54.0%
associate-*l/54.0%
associate-/l*54.0%
Simplified54.0%
Final simplification55.8%
(FPCore (x y z t) :precision binary64 (if (<= x -1.05e+29) x (if (<= x 1e+28) (/ -0.3333333333333333 (/ z y)) x)))
double code(double x, double y, double z, double t) {
double tmp;
if (x <= -1.05e+29) {
tmp = x;
} else if (x <= 1e+28) {
tmp = -0.3333333333333333 / (z / y);
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (x <= (-1.05d+29)) then
tmp = x
else if (x <= 1d+28) then
tmp = (-0.3333333333333333d0) / (z / y)
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (x <= -1.05e+29) {
tmp = x;
} else if (x <= 1e+28) {
tmp = -0.3333333333333333 / (z / y);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if x <= -1.05e+29: tmp = x elif x <= 1e+28: tmp = -0.3333333333333333 / (z / y) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (x <= -1.05e+29) tmp = x; elseif (x <= 1e+28) tmp = Float64(-0.3333333333333333 / Float64(z / y)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (x <= -1.05e+29) tmp = x; elseif (x <= 1e+28) tmp = -0.3333333333333333 / (z / y); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[x, -1.05e+29], x, If[LessEqual[x, 1e+28], N[(-0.3333333333333333 / N[(z / y), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.05 \cdot 10^{+29}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 10^{+28}:\\
\;\;\;\;\frac{-0.3333333333333333}{\frac{z}{y}}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -1.0500000000000001e29 or 9.99999999999999958e27 < x Initial program 99.1%
+-commutative99.1%
associate-+r-99.1%
sub-neg99.1%
associate-*l*99.1%
*-commutative99.1%
distribute-frac-neg299.1%
distribute-rgt-neg-in99.1%
metadata-eval99.1%
Simplified99.1%
Taylor expanded in z around inf 57.9%
if -1.0500000000000001e29 < x < 9.99999999999999958e27Initial program 95.7%
+-commutative95.7%
associate-+r-95.7%
sub-neg95.7%
associate-*l*95.7%
*-commutative95.7%
distribute-frac-neg295.7%
distribute-rgt-neg-in95.7%
metadata-eval95.7%
Simplified95.7%
*-un-lft-identity95.7%
times-frac95.7%
Applied egg-rr95.7%
Taylor expanded in y around inf 54.0%
clear-num54.0%
un-div-inv54.0%
Applied egg-rr54.0%
Final simplification55.8%
(FPCore (x y z t) :precision binary64 (if (<= x -1.4e+27) x (if (<= x 1.15e+27) (/ (/ y -3.0) z) x)))
double code(double x, double y, double z, double t) {
double tmp;
if (x <= -1.4e+27) {
tmp = x;
} else if (x <= 1.15e+27) {
tmp = (y / -3.0) / z;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (x <= (-1.4d+27)) then
tmp = x
else if (x <= 1.15d+27) then
tmp = (y / (-3.0d0)) / z
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (x <= -1.4e+27) {
tmp = x;
} else if (x <= 1.15e+27) {
tmp = (y / -3.0) / z;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if x <= -1.4e+27: tmp = x elif x <= 1.15e+27: tmp = (y / -3.0) / z else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (x <= -1.4e+27) tmp = x; elseif (x <= 1.15e+27) tmp = Float64(Float64(y / -3.0) / z); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (x <= -1.4e+27) tmp = x; elseif (x <= 1.15e+27) tmp = (y / -3.0) / z; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[x, -1.4e+27], x, If[LessEqual[x, 1.15e+27], N[(N[(y / -3.0), $MachinePrecision] / z), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.4 \cdot 10^{+27}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 1.15 \cdot 10^{+27}:\\
\;\;\;\;\frac{\frac{y}{-3}}{z}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -1.4e27 or 1.15e27 < x Initial program 99.1%
+-commutative99.1%
associate-+r-99.1%
sub-neg99.1%
associate-*l*99.1%
*-commutative99.1%
distribute-frac-neg299.1%
distribute-rgt-neg-in99.1%
metadata-eval99.1%
Simplified99.1%
Taylor expanded in z around inf 57.9%
if -1.4e27 < x < 1.15e27Initial program 95.7%
+-commutative95.7%
associate-+r-95.7%
sub-neg95.7%
associate-*l*95.7%
*-commutative95.7%
distribute-frac-neg295.7%
distribute-rgt-neg-in95.7%
metadata-eval95.7%
Simplified95.7%
*-un-lft-identity95.7%
times-frac95.7%
Applied egg-rr95.7%
Taylor expanded in z around 0 86.6%
metadata-eval86.6%
distribute-lft-neg-in86.6%
+-commutative86.6%
distribute-rgt-neg-in86.6%
distribute-lft-in86.6%
sub-neg86.6%
*-commutative86.6%
associate-/l*86.6%
Simplified86.6%
Taylor expanded in t around 0 54.0%
metadata-eval54.0%
times-frac54.1%
*-commutative54.1%
associate-*r/54.1%
neg-mul-154.1%
associate-/r*54.1%
distribute-neg-frac254.1%
metadata-eval54.1%
associate-/l/54.1%
associate-/r*54.1%
Simplified54.1%
Final simplification55.8%
(FPCore (x y z t) :precision binary64 (+ (/ y (* z -3.0)) (+ x (/ t (* z (* 3.0 y))))))
double code(double x, double y, double z, double t) {
return (y / (z * -3.0)) + (x + (t / (z * (3.0 * y))));
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (y / (z * (-3.0d0))) + (x + (t / (z * (3.0d0 * y))))
end function
public static double code(double x, double y, double z, double t) {
return (y / (z * -3.0)) + (x + (t / (z * (3.0 * y))));
}
def code(x, y, z, t): return (y / (z * -3.0)) + (x + (t / (z * (3.0 * y))))
function code(x, y, z, t) return Float64(Float64(y / Float64(z * -3.0)) + Float64(x + Float64(t / Float64(z * Float64(3.0 * y))))) end
function tmp = code(x, y, z, t) tmp = (y / (z * -3.0)) + (x + (t / (z * (3.0 * y)))); end
code[x_, y_, z_, t_] := N[(N[(y / N[(z * -3.0), $MachinePrecision]), $MachinePrecision] + N[(x + N[(t / N[(z * N[(3.0 * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{y}{z \cdot -3} + \left(x + \frac{t}{z \cdot \left(3 \cdot y\right)}\right)
\end{array}
Initial program 97.3%
+-commutative97.3%
associate-+r-97.3%
sub-neg97.3%
associate-*l*97.3%
*-commutative97.3%
distribute-frac-neg297.3%
distribute-rgt-neg-in97.3%
metadata-eval97.3%
Simplified97.3%
Final simplification97.3%
(FPCore (x y z t) :precision binary64 x)
double code(double x, double y, double z, double t) {
return x;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = x
end function
public static double code(double x, double y, double z, double t) {
return x;
}
def code(x, y, z, t): return x
function code(x, y, z, t) return x end
function tmp = code(x, y, z, t) tmp = x; end
code[x_, y_, z_, t_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 97.3%
+-commutative97.3%
associate-+r-97.3%
sub-neg97.3%
associate-*l*97.3%
*-commutative97.3%
distribute-frac-neg297.3%
distribute-rgt-neg-in97.3%
metadata-eval97.3%
Simplified97.3%
Taylor expanded in z around inf 31.3%
Final simplification31.3%
(FPCore (x y z t) :precision binary64 (+ (- x (/ y (* z 3.0))) (/ (/ t (* z 3.0)) y)))
double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + ((t / (z * 3.0)) / y);
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (x - (y / (z * 3.0d0))) + ((t / (z * 3.0d0)) / y)
end function
public static double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + ((t / (z * 3.0)) / y);
}
def code(x, y, z, t): return (x - (y / (z * 3.0))) + ((t / (z * 3.0)) / y)
function code(x, y, z, t) return Float64(Float64(x - Float64(y / Float64(z * 3.0))) + Float64(Float64(t / Float64(z * 3.0)) / y)) end
function tmp = code(x, y, z, t) tmp = (x - (y / (z * 3.0))) + ((t / (z * 3.0)) / y); end
code[x_, y_, z_, t_] := N[(N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(t / N[(z * 3.0), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x - \frac{y}{z \cdot 3}\right) + \frac{\frac{t}{z \cdot 3}}{y}
\end{array}
herbie shell --seed 2024043
(FPCore (x y z t)
:name "Diagrams.Solve.Polynomial:cubForm from diagrams-solve-0.1, H"
:precision binary64
:herbie-target
(+ (- x (/ y (* z 3.0))) (/ (/ t (* z 3.0)) y))
(+ (- x (/ y (* z 3.0))) (/ t (* (* z 3.0) y))))