
(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
(let* ((t_1 (/ y (* z -3.0))))
(if (<= t 0.0001)
(+ (+ (/ 1.0 (* z (/ (* y 3.0) t))) x) t_1)
(+ t_1 (+ x (/ t (* z (* y 3.0))))))))
double code(double x, double y, double z, double t) {
double t_1 = y / (z * -3.0);
double tmp;
if (t <= 0.0001) {
tmp = ((1.0 / (z * ((y * 3.0) / t))) + x) + t_1;
} else {
tmp = t_1 + (x + (t / (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) :: t_1
real(8) :: tmp
t_1 = y / (z * (-3.0d0))
if (t <= 0.0001d0) then
tmp = ((1.0d0 / (z * ((y * 3.0d0) / t))) + x) + t_1
else
tmp = t_1 + (x + (t / (z * (y * 3.0d0))))
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 <= 0.0001) {
tmp = ((1.0 / (z * ((y * 3.0) / t))) + x) + t_1;
} else {
tmp = t_1 + (x + (t / (z * (y * 3.0))));
}
return tmp;
}
def code(x, y, z, t): t_1 = y / (z * -3.0) tmp = 0 if t <= 0.0001: tmp = ((1.0 / (z * ((y * 3.0) / t))) + x) + t_1 else: tmp = t_1 + (x + (t / (z * (y * 3.0)))) return tmp
function code(x, y, z, t) t_1 = Float64(y / Float64(z * -3.0)) tmp = 0.0 if (t <= 0.0001) tmp = Float64(Float64(Float64(1.0 / Float64(z * Float64(Float64(y * 3.0) / t))) + x) + t_1); else tmp = Float64(t_1 + Float64(x + Float64(t / Float64(z * Float64(y * 3.0))))); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = y / (z * -3.0); tmp = 0.0; if (t <= 0.0001) tmp = ((1.0 / (z * ((y * 3.0) / t))) + x) + t_1; else tmp = t_1 + (x + (t / (z * (y * 3.0)))); 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, 0.0001], N[(N[(N[(1.0 / N[(z * N[(N[(y * 3.0), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision] + t$95$1), $MachinePrecision], N[(t$95$1 + N[(x + N[(t / N[(z * N[(y * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{y}{z \cdot -3}\\
\mathbf{if}\;t \leq 0.0001:\\
\;\;\;\;\left(\frac{1}{z \cdot \frac{y \cdot 3}{t}} + x\right) + t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_1 + \left(x + \frac{t}{z \cdot \left(y \cdot 3\right)}\right)\\
\end{array}
\end{array}
if t < 1.00000000000000005e-4Initial program 95.6%
+-commutative95.6%
associate-+r-95.6%
sub-neg95.6%
associate-*l*95.6%
*-commutative95.6%
distribute-frac-neg295.6%
distribute-rgt-neg-in95.6%
metadata-eval95.6%
Simplified95.6%
clear-num95.6%
inv-pow95.6%
Applied egg-rr95.6%
unpow-195.6%
associate-/l*98.7%
Simplified98.7%
if 1.00000000000000005e-4 < t Initial program 98.1%
+-commutative98.1%
associate-+r-98.1%
sub-neg98.1%
associate-*l*98.1%
*-commutative98.1%
distribute-frac-neg298.1%
distribute-rgt-neg-in98.1%
metadata-eval98.1%
Simplified98.1%
Final simplification98.6%
(FPCore (x y z t) :precision binary64 (if (<= (* z 3.0) -1e+90) (+ (/ y (* z -3.0)) (+ x (/ t (* z (* y 3.0))))) (+ x (* (* 0.3333333333333333 (/ 1.0 z)) (- (/ t y) y)))))
double code(double x, double y, double z, double t) {
double tmp;
if ((z * 3.0) <= -1e+90) {
tmp = (y / (z * -3.0)) + (x + (t / (z * (y * 3.0))));
} else {
tmp = x + ((0.3333333333333333 * (1.0 / z)) * ((t / y) - 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 ((z * 3.0d0) <= (-1d+90)) then
tmp = (y / (z * (-3.0d0))) + (x + (t / (z * (y * 3.0d0))))
else
tmp = x + ((0.3333333333333333d0 * (1.0d0 / z)) * ((t / y) - y))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((z * 3.0) <= -1e+90) {
tmp = (y / (z * -3.0)) + (x + (t / (z * (y * 3.0))));
} else {
tmp = x + ((0.3333333333333333 * (1.0 / z)) * ((t / y) - y));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (z * 3.0) <= -1e+90: tmp = (y / (z * -3.0)) + (x + (t / (z * (y * 3.0)))) else: tmp = x + ((0.3333333333333333 * (1.0 / z)) * ((t / y) - y)) return tmp
function code(x, y, z, t) tmp = 0.0 if (Float64(z * 3.0) <= -1e+90) tmp = Float64(Float64(y / Float64(z * -3.0)) + Float64(x + Float64(t / Float64(z * Float64(y * 3.0))))); else tmp = Float64(x + Float64(Float64(0.3333333333333333 * Float64(1.0 / z)) * Float64(Float64(t / y) - y))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((z * 3.0) <= -1e+90) tmp = (y / (z * -3.0)) + (x + (t / (z * (y * 3.0)))); else tmp = x + ((0.3333333333333333 * (1.0 / z)) * ((t / y) - y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[N[(z * 3.0), $MachinePrecision], -1e+90], N[(N[(y / N[(z * -3.0), $MachinePrecision]), $MachinePrecision] + N[(x + N[(t / N[(z * N[(y * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(0.3333333333333333 * N[(1.0 / z), $MachinePrecision]), $MachinePrecision] * N[(N[(t / y), $MachinePrecision] - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \cdot 3 \leq -1 \cdot 10^{+90}:\\
\;\;\;\;\frac{y}{z \cdot -3} + \left(x + \frac{t}{z \cdot \left(y \cdot 3\right)}\right)\\
\mathbf{else}:\\
\;\;\;\;x + \left(0.3333333333333333 \cdot \frac{1}{z}\right) \cdot \left(\frac{t}{y} - y\right)\\
\end{array}
\end{array}
if (*.f64 z 3) < -9.99999999999999966e89Initial program 99.8%
+-commutative99.8%
associate-+r-99.8%
sub-neg99.8%
associate-*l*99.9%
*-commutative99.9%
distribute-frac-neg299.9%
distribute-rgt-neg-in99.9%
metadata-eval99.9%
Simplified99.9%
if -9.99999999999999966e89 < (*.f64 z 3) Initial program 95.4%
sub-neg95.4%
associate-+l+95.4%
+-commutative95.4%
remove-double-neg95.4%
distribute-frac-neg95.4%
distribute-neg-in95.4%
remove-double-neg95.4%
sub-neg95.4%
neg-mul-195.4%
times-frac97.5%
distribute-frac-neg97.5%
neg-mul-197.5%
*-commutative97.5%
associate-/l*97.5%
*-commutative97.5%
Simplified97.9%
div-inv98.0%
Applied egg-rr98.0%
Final simplification98.3%
(FPCore (x y z t)
:precision binary64
(if (<= y -11.6)
(- x (* y (/ 0.3333333333333333 z)))
(if (<= y 9500000000.0)
(+ x (* 0.3333333333333333 (/ 1.0 (* y (/ z t)))))
(+ x (* y (* 0.3333333333333333 (/ -1.0 z)))))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -11.6) {
tmp = x - (y * (0.3333333333333333 / z));
} else if (y <= 9500000000.0) {
tmp = x + (0.3333333333333333 * (1.0 / (y * (z / t))));
} else {
tmp = x + (y * (0.3333333333333333 * (-1.0 / 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 (y <= (-11.6d0)) then
tmp = x - (y * (0.3333333333333333d0 / z))
else if (y <= 9500000000.0d0) then
tmp = x + (0.3333333333333333d0 * (1.0d0 / (y * (z / t))))
else
tmp = x + (y * (0.3333333333333333d0 * ((-1.0d0) / z)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (y <= -11.6) {
tmp = x - (y * (0.3333333333333333 / z));
} else if (y <= 9500000000.0) {
tmp = x + (0.3333333333333333 * (1.0 / (y * (z / t))));
} else {
tmp = x + (y * (0.3333333333333333 * (-1.0 / z)));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if y <= -11.6: tmp = x - (y * (0.3333333333333333 / z)) elif y <= 9500000000.0: tmp = x + (0.3333333333333333 * (1.0 / (y * (z / t)))) else: tmp = x + (y * (0.3333333333333333 * (-1.0 / z))) return tmp
function code(x, y, z, t) tmp = 0.0 if (y <= -11.6) tmp = Float64(x - Float64(y * Float64(0.3333333333333333 / z))); elseif (y <= 9500000000.0) tmp = Float64(x + Float64(0.3333333333333333 * Float64(1.0 / Float64(y * Float64(z / t))))); else tmp = Float64(x + Float64(y * Float64(0.3333333333333333 * Float64(-1.0 / z)))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (y <= -11.6) tmp = x - (y * (0.3333333333333333 / z)); elseif (y <= 9500000000.0) tmp = x + (0.3333333333333333 * (1.0 / (y * (z / t)))); else tmp = x + (y * (0.3333333333333333 * (-1.0 / z))); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[y, -11.6], N[(x - N[(y * N[(0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 9500000000.0], N[(x + N[(0.3333333333333333 * N[(1.0 / N[(y * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(y * N[(0.3333333333333333 * N[(-1.0 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -11.6:\\
\;\;\;\;x - y \cdot \frac{0.3333333333333333}{z}\\
\mathbf{elif}\;y \leq 9500000000:\\
\;\;\;\;x + 0.3333333333333333 \cdot \frac{1}{y \cdot \frac{z}{t}}\\
\mathbf{else}:\\
\;\;\;\;x + y \cdot \left(0.3333333333333333 \cdot \frac{-1}{z}\right)\\
\end{array}
\end{array}
if y < -11.5999999999999996Initial program 98.3%
sub-neg98.3%
associate-+l+98.3%
+-commutative98.3%
remove-double-neg98.3%
distribute-frac-neg98.3%
distribute-neg-in98.3%
remove-double-neg98.3%
sub-neg98.3%
neg-mul-198.3%
times-frac98.3%
distribute-frac-neg98.3%
neg-mul-198.3%
*-commutative98.3%
associate-/l*98.3%
*-commutative98.3%
Simplified99.8%
Taylor expanded in t around 0 94.8%
neg-mul-194.8%
Simplified94.8%
if -11.5999999999999996 < y < 9.5e9Initial program 93.2%
sub-neg93.2%
associate-+l+93.2%
+-commutative93.2%
remove-double-neg93.2%
distribute-frac-neg93.2%
distribute-neg-in93.2%
remove-double-neg93.2%
sub-neg93.2%
neg-mul-193.2%
times-frac93.1%
distribute-frac-neg93.1%
neg-mul-193.1%
*-commutative93.1%
associate-/l*93.1%
*-commutative93.1%
Simplified93.0%
Taylor expanded in t around inf 87.3%
clear-num62.2%
inv-pow62.2%
*-commutative62.2%
*-un-lft-identity62.2%
times-frac61.4%
/-rgt-identity61.4%
Applied egg-rr87.3%
unpow-161.4%
associate-*r/62.2%
*-commutative62.2%
associate-/l*65.8%
Simplified91.1%
if 9.5e9 < y Initial program 99.8%
sub-neg99.8%
associate-+l+99.8%
+-commutative99.8%
remove-double-neg99.8%
distribute-frac-neg99.8%
distribute-neg-in99.8%
remove-double-neg99.8%
sub-neg99.8%
neg-mul-199.8%
times-frac99.8%
distribute-frac-neg99.8%
neg-mul-199.8%
*-commutative99.8%
associate-/l*99.8%
*-commutative99.8%
Simplified99.7%
div-inv99.8%
Applied egg-rr99.8%
Taylor expanded in t around 0 99.8%
neg-mul-199.7%
Simplified99.8%
Final simplification94.1%
(FPCore (x y z t) :precision binary64 (if (or (<= y -1.9e-45) (not (<= y 1.5e-150))) (- x (* y (/ 0.3333333333333333 z))) (* 0.3333333333333333 (/ 1.0 (* y (/ z t))))))
double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -1.9e-45) || !(y <= 1.5e-150)) {
tmp = x - (y * (0.3333333333333333 / z));
} else {
tmp = 0.3333333333333333 * (1.0 / (y * (z / t)));
}
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.9d-45)) .or. (.not. (y <= 1.5d-150))) then
tmp = x - (y * (0.3333333333333333d0 / z))
else
tmp = 0.3333333333333333d0 * (1.0d0 / (y * (z / t)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -1.9e-45) || !(y <= 1.5e-150)) {
tmp = x - (y * (0.3333333333333333 / z));
} else {
tmp = 0.3333333333333333 * (1.0 / (y * (z / t)));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (y <= -1.9e-45) or not (y <= 1.5e-150): tmp = x - (y * (0.3333333333333333 / z)) else: tmp = 0.3333333333333333 * (1.0 / (y * (z / t))) return tmp
function code(x, y, z, t) tmp = 0.0 if ((y <= -1.9e-45) || !(y <= 1.5e-150)) tmp = Float64(x - Float64(y * Float64(0.3333333333333333 / z))); else tmp = Float64(0.3333333333333333 * Float64(1.0 / Float64(y * Float64(z / t)))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((y <= -1.9e-45) || ~((y <= 1.5e-150))) tmp = x - (y * (0.3333333333333333 / z)); else tmp = 0.3333333333333333 * (1.0 / (y * (z / t))); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[y, -1.9e-45], N[Not[LessEqual[y, 1.5e-150]], $MachinePrecision]], N[(x - N[(y * N[(0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.3333333333333333 * N[(1.0 / N[(y * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.9 \cdot 10^{-45} \lor \neg \left(y \leq 1.5 \cdot 10^{-150}\right):\\
\;\;\;\;x - y \cdot \frac{0.3333333333333333}{z}\\
\mathbf{else}:\\
\;\;\;\;0.3333333333333333 \cdot \frac{1}{y \cdot \frac{z}{t}}\\
\end{array}
\end{array}
if y < -1.89999999999999999e-45 or 1.5000000000000001e-150 < 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-frac98.6%
distribute-frac-neg98.6%
neg-mul-198.6%
*-commutative98.6%
associate-/l*98.5%
*-commutative98.5%
Simplified99.1%
Taylor expanded in t around 0 88.0%
neg-mul-188.0%
Simplified88.0%
if -1.89999999999999999e-45 < y < 1.5000000000000001e-150Initial program 91.5%
+-commutative91.5%
associate-+r-91.5%
sub-neg91.5%
associate-*l*91.4%
*-commutative91.4%
distribute-frac-neg291.4%
distribute-rgt-neg-in91.4%
metadata-eval91.4%
Simplified91.4%
clear-num91.4%
inv-pow91.4%
Applied egg-rr91.4%
unpow-191.4%
associate-/l*92.3%
Simplified92.3%
Taylor expanded in z around 0 70.4%
+-commutative70.4%
metadata-eval70.4%
associate-*r*70.4%
neg-mul-170.4%
distribute-lft-in70.4%
sub-neg70.4%
associate-*r/70.4%
Simplified70.4%
Taylor expanded in t around inf 69.6%
clear-num69.6%
inv-pow69.6%
*-commutative69.6%
*-un-lft-identity69.6%
times-frac68.7%
/-rgt-identity68.7%
Applied egg-rr68.7%
unpow-168.7%
associate-*r/69.6%
*-commutative69.6%
associate-/l*74.8%
Simplified74.8%
Final simplification83.4%
(FPCore (x y z t) :precision binary64 (if (or (<= z -7.8e+179) (not (<= z 1.56e+61))) (- x (* y (/ 0.3333333333333333 z))) (* 0.3333333333333333 (/ (- (/ t y) y) z))))
double code(double x, double y, double z, double t) {
double tmp;
if ((z <= -7.8e+179) || !(z <= 1.56e+61)) {
tmp = x - (y * (0.3333333333333333 / z));
} else {
tmp = 0.3333333333333333 * (((t / y) - y) / 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 <= (-7.8d+179)) .or. (.not. (z <= 1.56d+61))) then
tmp = x - (y * (0.3333333333333333d0 / z))
else
tmp = 0.3333333333333333d0 * (((t / y) - y) / z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((z <= -7.8e+179) || !(z <= 1.56e+61)) {
tmp = x - (y * (0.3333333333333333 / z));
} else {
tmp = 0.3333333333333333 * (((t / y) - y) / z);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (z <= -7.8e+179) or not (z <= 1.56e+61): tmp = x - (y * (0.3333333333333333 / z)) else: tmp = 0.3333333333333333 * (((t / y) - y) / z) return tmp
function code(x, y, z, t) tmp = 0.0 if ((z <= -7.8e+179) || !(z <= 1.56e+61)) tmp = Float64(x - Float64(y * Float64(0.3333333333333333 / z))); else tmp = Float64(0.3333333333333333 * Float64(Float64(Float64(t / y) - y) / z)); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((z <= -7.8e+179) || ~((z <= 1.56e+61))) tmp = x - (y * (0.3333333333333333 / z)); else tmp = 0.3333333333333333 * (((t / y) - y) / z); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[z, -7.8e+179], N[Not[LessEqual[z, 1.56e+61]], $MachinePrecision]], N[(x - N[(y * N[(0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.3333333333333333 * N[(N[(N[(t / y), $MachinePrecision] - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -7.8 \cdot 10^{+179} \lor \neg \left(z \leq 1.56 \cdot 10^{+61}\right):\\
\;\;\;\;x - y \cdot \frac{0.3333333333333333}{z}\\
\mathbf{else}:\\
\;\;\;\;0.3333333333333333 \cdot \frac{\frac{t}{y} - y}{z}\\
\end{array}
\end{array}
if z < -7.79999999999999947e179 or 1.56000000000000012e61 < z Initial program 99.9%
sub-neg99.9%
associate-+l+99.9%
+-commutative99.9%
remove-double-neg99.9%
distribute-frac-neg99.9%
distribute-neg-in99.9%
remove-double-neg99.9%
sub-neg99.9%
neg-mul-199.9%
times-frac90.9%
distribute-frac-neg90.9%
neg-mul-190.9%
*-commutative90.9%
associate-/l*90.8%
*-commutative90.8%
Simplified90.9%
Taylor expanded in t around 0 84.4%
neg-mul-184.4%
Simplified84.4%
if -7.79999999999999947e179 < z < 1.56000000000000012e61Initial program 95.0%
+-commutative95.0%
associate-+r-95.0%
sub-neg95.0%
associate-*l*94.9%
*-commutative94.9%
distribute-frac-neg294.9%
distribute-rgt-neg-in94.9%
metadata-eval94.9%
Simplified94.9%
clear-num94.9%
inv-pow94.9%
Applied egg-rr94.9%
unpow-194.9%
associate-/l*97.8%
Simplified97.8%
Taylor expanded in z around 0 86.3%
+-commutative86.3%
metadata-eval86.3%
associate-*r*86.3%
neg-mul-186.3%
distribute-lft-in86.3%
sub-neg86.3%
associate-*r/85.9%
Simplified85.9%
Final simplification85.5%
(FPCore (x y z t) :precision binary64 (if (or (<= y -20.5) (not (<= y 1660000000.0))) (- x (* y (/ 0.3333333333333333 z))) (+ x (* 0.3333333333333333 (/ t (* z y))))))
double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -20.5) || !(y <= 1660000000.0)) {
tmp = x - (y * (0.3333333333333333 / z));
} 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 <= (-20.5d0)) .or. (.not. (y <= 1660000000.0d0))) then
tmp = x - (y * (0.3333333333333333d0 / z))
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 <= -20.5) || !(y <= 1660000000.0)) {
tmp = x - (y * (0.3333333333333333 / z));
} else {
tmp = x + (0.3333333333333333 * (t / (z * y)));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (y <= -20.5) or not (y <= 1660000000.0): tmp = x - (y * (0.3333333333333333 / z)) else: tmp = x + (0.3333333333333333 * (t / (z * y))) return tmp
function code(x, y, z, t) tmp = 0.0 if ((y <= -20.5) || !(y <= 1660000000.0)) tmp = Float64(x - Float64(y * Float64(0.3333333333333333 / z))); 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 <= -20.5) || ~((y <= 1660000000.0))) tmp = x - (y * (0.3333333333333333 / z)); else tmp = x + (0.3333333333333333 * (t / (z * y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[y, -20.5], N[Not[LessEqual[y, 1660000000.0]], $MachinePrecision]], N[(x - N[(y * N[(0.3333333333333333 / z), $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 -20.5 \lor \neg \left(y \leq 1660000000\right):\\
\;\;\;\;x - y \cdot \frac{0.3333333333333333}{z}\\
\mathbf{else}:\\
\;\;\;\;x + 0.3333333333333333 \cdot \frac{t}{z \cdot y}\\
\end{array}
\end{array}
if y < -20.5 or 1.66e9 < y Initial program 99.0%
sub-neg99.0%
associate-+l+99.0%
+-commutative99.0%
remove-double-neg99.0%
distribute-frac-neg99.0%
distribute-neg-in99.0%
remove-double-neg99.0%
sub-neg99.0%
neg-mul-199.0%
times-frac99.0%
distribute-frac-neg99.0%
neg-mul-199.0%
*-commutative99.0%
associate-/l*99.0%
*-commutative99.0%
Simplified99.7%
Taylor expanded in t around 0 97.1%
neg-mul-197.1%
Simplified97.1%
if -20.5 < y < 1.66e9Initial program 93.2%
sub-neg93.2%
associate-+l+93.2%
+-commutative93.2%
remove-double-neg93.2%
distribute-frac-neg93.2%
distribute-neg-in93.2%
remove-double-neg93.2%
sub-neg93.2%
neg-mul-193.2%
times-frac93.1%
distribute-frac-neg93.1%
neg-mul-193.1%
*-commutative93.1%
associate-/l*93.1%
*-commutative93.1%
Simplified93.0%
Taylor expanded in t around inf 87.3%
Final simplification92.2%
(FPCore (x y z t) :precision binary64 (if (or (<= y -12.0) (not (<= y 720000000.0))) (- x (* y (/ 0.3333333333333333 z))) (+ x (* (/ 0.3333333333333333 y) (/ t z)))))
double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -12.0) || !(y <= 720000000.0)) {
tmp = x - (y * (0.3333333333333333 / z));
} else {
tmp = x + ((0.3333333333333333 / y) * (t / 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 ((y <= (-12.0d0)) .or. (.not. (y <= 720000000.0d0))) then
tmp = x - (y * (0.3333333333333333d0 / z))
else
tmp = x + ((0.3333333333333333d0 / y) * (t / z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -12.0) || !(y <= 720000000.0)) {
tmp = x - (y * (0.3333333333333333 / z));
} else {
tmp = x + ((0.3333333333333333 / y) * (t / z));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (y <= -12.0) or not (y <= 720000000.0): tmp = x - (y * (0.3333333333333333 / z)) else: tmp = x + ((0.3333333333333333 / y) * (t / z)) return tmp
function code(x, y, z, t) tmp = 0.0 if ((y <= -12.0) || !(y <= 720000000.0)) tmp = Float64(x - Float64(y * Float64(0.3333333333333333 / z))); else tmp = Float64(x + Float64(Float64(0.3333333333333333 / y) * Float64(t / z))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((y <= -12.0) || ~((y <= 720000000.0))) tmp = x - (y * (0.3333333333333333 / z)); else tmp = x + ((0.3333333333333333 / y) * (t / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[y, -12.0], N[Not[LessEqual[y, 720000000.0]], $MachinePrecision]], N[(x - N[(y * N[(0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(0.3333333333333333 / y), $MachinePrecision] * N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -12 \lor \neg \left(y \leq 720000000\right):\\
\;\;\;\;x - y \cdot \frac{0.3333333333333333}{z}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{0.3333333333333333}{y} \cdot \frac{t}{z}\\
\end{array}
\end{array}
if y < -12 or 7.2e8 < y Initial program 99.0%
sub-neg99.0%
associate-+l+99.0%
+-commutative99.0%
remove-double-neg99.0%
distribute-frac-neg99.0%
distribute-neg-in99.0%
remove-double-neg99.0%
sub-neg99.0%
neg-mul-199.0%
times-frac99.0%
distribute-frac-neg99.0%
neg-mul-199.0%
*-commutative99.0%
associate-/l*99.0%
*-commutative99.0%
Simplified99.7%
Taylor expanded in t around 0 97.1%
neg-mul-197.1%
Simplified97.1%
if -12 < y < 7.2e8Initial program 93.2%
sub-neg93.2%
associate-+l+93.2%
+-commutative93.2%
remove-double-neg93.2%
distribute-frac-neg93.2%
distribute-neg-in93.2%
remove-double-neg93.2%
sub-neg93.2%
neg-mul-193.2%
times-frac93.1%
distribute-frac-neg93.1%
neg-mul-193.1%
*-commutative93.1%
associate-/l*93.1%
*-commutative93.1%
Simplified93.0%
clear-num93.0%
inv-pow93.0%
Applied egg-rr93.0%
unpow-193.0%
Simplified93.0%
Taylor expanded in t around inf 87.3%
associate-*r/87.3%
times-frac91.1%
Simplified91.1%
Final simplification94.1%
(FPCore (x y z t)
:precision binary64
(if (<= y -13.5)
(- x (* y (/ 0.3333333333333333 z)))
(if (<= y 3500000000.0)
(+ x (* (/ 0.3333333333333333 y) (/ t z)))
(+ x (* y (* 0.3333333333333333 (/ -1.0 z)))))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -13.5) {
tmp = x - (y * (0.3333333333333333 / z));
} else if (y <= 3500000000.0) {
tmp = x + ((0.3333333333333333 / y) * (t / z));
} else {
tmp = x + (y * (0.3333333333333333 * (-1.0 / 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 (y <= (-13.5d0)) then
tmp = x - (y * (0.3333333333333333d0 / z))
else if (y <= 3500000000.0d0) then
tmp = x + ((0.3333333333333333d0 / y) * (t / z))
else
tmp = x + (y * (0.3333333333333333d0 * ((-1.0d0) / z)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (y <= -13.5) {
tmp = x - (y * (0.3333333333333333 / z));
} else if (y <= 3500000000.0) {
tmp = x + ((0.3333333333333333 / y) * (t / z));
} else {
tmp = x + (y * (0.3333333333333333 * (-1.0 / z)));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if y <= -13.5: tmp = x - (y * (0.3333333333333333 / z)) elif y <= 3500000000.0: tmp = x + ((0.3333333333333333 / y) * (t / z)) else: tmp = x + (y * (0.3333333333333333 * (-1.0 / z))) return tmp
function code(x, y, z, t) tmp = 0.0 if (y <= -13.5) tmp = Float64(x - Float64(y * Float64(0.3333333333333333 / z))); elseif (y <= 3500000000.0) tmp = Float64(x + Float64(Float64(0.3333333333333333 / y) * Float64(t / z))); else tmp = Float64(x + Float64(y * Float64(0.3333333333333333 * Float64(-1.0 / z)))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (y <= -13.5) tmp = x - (y * (0.3333333333333333 / z)); elseif (y <= 3500000000.0) tmp = x + ((0.3333333333333333 / y) * (t / z)); else tmp = x + (y * (0.3333333333333333 * (-1.0 / z))); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[y, -13.5], N[(x - N[(y * N[(0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3500000000.0], N[(x + N[(N[(0.3333333333333333 / y), $MachinePrecision] * N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(y * N[(0.3333333333333333 * N[(-1.0 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -13.5:\\
\;\;\;\;x - y \cdot \frac{0.3333333333333333}{z}\\
\mathbf{elif}\;y \leq 3500000000:\\
\;\;\;\;x + \frac{0.3333333333333333}{y} \cdot \frac{t}{z}\\
\mathbf{else}:\\
\;\;\;\;x + y \cdot \left(0.3333333333333333 \cdot \frac{-1}{z}\right)\\
\end{array}
\end{array}
if y < -13.5Initial program 98.3%
sub-neg98.3%
associate-+l+98.3%
+-commutative98.3%
remove-double-neg98.3%
distribute-frac-neg98.3%
distribute-neg-in98.3%
remove-double-neg98.3%
sub-neg98.3%
neg-mul-198.3%
times-frac98.3%
distribute-frac-neg98.3%
neg-mul-198.3%
*-commutative98.3%
associate-/l*98.3%
*-commutative98.3%
Simplified99.8%
Taylor expanded in t around 0 94.8%
neg-mul-194.8%
Simplified94.8%
if -13.5 < y < 3.5e9Initial program 93.2%
sub-neg93.2%
associate-+l+93.2%
+-commutative93.2%
remove-double-neg93.2%
distribute-frac-neg93.2%
distribute-neg-in93.2%
remove-double-neg93.2%
sub-neg93.2%
neg-mul-193.2%
times-frac93.1%
distribute-frac-neg93.1%
neg-mul-193.1%
*-commutative93.1%
associate-/l*93.1%
*-commutative93.1%
Simplified93.0%
clear-num93.0%
inv-pow93.0%
Applied egg-rr93.0%
unpow-193.0%
Simplified93.0%
Taylor expanded in t around inf 87.3%
associate-*r/87.3%
times-frac91.1%
Simplified91.1%
if 3.5e9 < y Initial program 99.8%
sub-neg99.8%
associate-+l+99.8%
+-commutative99.8%
remove-double-neg99.8%
distribute-frac-neg99.8%
distribute-neg-in99.8%
remove-double-neg99.8%
sub-neg99.8%
neg-mul-199.8%
times-frac99.8%
distribute-frac-neg99.8%
neg-mul-199.8%
*-commutative99.8%
associate-/l*99.8%
*-commutative99.8%
Simplified99.7%
div-inv99.8%
Applied egg-rr99.8%
Taylor expanded in t around 0 99.8%
neg-mul-199.7%
Simplified99.8%
Final simplification94.1%
(FPCore (x y z t) :precision binary64 (if (or (<= y -1.15e-47) (not (<= y 5e-150))) (- x (* 0.3333333333333333 (/ y z))) (* 0.3333333333333333 (/ t (* z y)))))
double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -1.15e-47) || !(y <= 5e-150)) {
tmp = x - (0.3333333333333333 * (y / 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 <= (-1.15d-47)) .or. (.not. (y <= 5d-150))) then
tmp = x - (0.3333333333333333d0 * (y / 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 <= -1.15e-47) || !(y <= 5e-150)) {
tmp = x - (0.3333333333333333 * (y / z));
} else {
tmp = 0.3333333333333333 * (t / (z * y));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (y <= -1.15e-47) or not (y <= 5e-150): tmp = x - (0.3333333333333333 * (y / z)) else: tmp = 0.3333333333333333 * (t / (z * y)) return tmp
function code(x, y, z, t) tmp = 0.0 if ((y <= -1.15e-47) || !(y <= 5e-150)) tmp = Float64(x - Float64(0.3333333333333333 * Float64(y / z))); else tmp = 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.15e-47) || ~((y <= 5e-150))) tmp = x - (0.3333333333333333 * (y / z)); else tmp = 0.3333333333333333 * (t / (z * y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[y, -1.15e-47], N[Not[LessEqual[y, 5e-150]], $MachinePrecision]], N[(x - N[(0.3333333333333333 * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.3333333333333333 * N[(t / N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.15 \cdot 10^{-47} \lor \neg \left(y \leq 5 \cdot 10^{-150}\right):\\
\;\;\;\;x - 0.3333333333333333 \cdot \frac{y}{z}\\
\mathbf{else}:\\
\;\;\;\;0.3333333333333333 \cdot \frac{t}{z \cdot y}\\
\end{array}
\end{array}
if y < -1.14999999999999991e-47 or 4.9999999999999999e-150 < y Initial program 98.6%
Taylor expanded in t around 0 87.5%
if -1.14999999999999991e-47 < y < 4.9999999999999999e-150Initial program 91.5%
+-commutative91.5%
associate-+r-91.5%
sub-neg91.5%
associate-*l*91.4%
*-commutative91.4%
distribute-frac-neg291.4%
distribute-rgt-neg-in91.4%
metadata-eval91.4%
Simplified91.4%
clear-num91.4%
inv-pow91.4%
Applied egg-rr91.4%
unpow-191.4%
associate-/l*92.3%
Simplified92.3%
Taylor expanded in z around 0 70.4%
+-commutative70.4%
metadata-eval70.4%
associate-*r*70.4%
neg-mul-170.4%
distribute-lft-in70.4%
sub-neg70.4%
associate-*r/70.4%
Simplified70.4%
Taylor expanded in t around inf 69.6%
Final simplification81.3%
(FPCore (x y z t) :precision binary64 (if (or (<= y -4.6e-48) (not (<= y 4.5e-150))) (- x (* 0.3333333333333333 (/ y z))) (/ (* t 0.3333333333333333) (* z y))))
double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -4.6e-48) || !(y <= 4.5e-150)) {
tmp = x - (0.3333333333333333 * (y / z));
} else {
tmp = (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 <= (-4.6d-48)) .or. (.not. (y <= 4.5d-150))) then
tmp = x - (0.3333333333333333d0 * (y / z))
else
tmp = (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 <= -4.6e-48) || !(y <= 4.5e-150)) {
tmp = x - (0.3333333333333333 * (y / z));
} else {
tmp = (t * 0.3333333333333333) / (z * y);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (y <= -4.6e-48) or not (y <= 4.5e-150): tmp = x - (0.3333333333333333 * (y / z)) else: tmp = (t * 0.3333333333333333) / (z * y) return tmp
function code(x, y, z, t) tmp = 0.0 if ((y <= -4.6e-48) || !(y <= 4.5e-150)) tmp = Float64(x - Float64(0.3333333333333333 * Float64(y / z))); else tmp = 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 <= -4.6e-48) || ~((y <= 4.5e-150))) tmp = x - (0.3333333333333333 * (y / z)); else tmp = (t * 0.3333333333333333) / (z * y); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[y, -4.6e-48], N[Not[LessEqual[y, 4.5e-150]], $MachinePrecision]], N[(x - N[(0.3333333333333333 * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t * 0.3333333333333333), $MachinePrecision] / N[(z * y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -4.6 \cdot 10^{-48} \lor \neg \left(y \leq 4.5 \cdot 10^{-150}\right):\\
\;\;\;\;x - 0.3333333333333333 \cdot \frac{y}{z}\\
\mathbf{else}:\\
\;\;\;\;\frac{t \cdot 0.3333333333333333}{z \cdot y}\\
\end{array}
\end{array}
if y < -4.6000000000000001e-48 or 4.5000000000000002e-150 < y Initial program 98.6%
Taylor expanded in t around 0 87.5%
if -4.6000000000000001e-48 < y < 4.5000000000000002e-150Initial program 91.5%
+-commutative91.5%
associate-+r-91.5%
sub-neg91.5%
associate-*l*91.4%
*-commutative91.4%
distribute-frac-neg291.4%
distribute-rgt-neg-in91.4%
metadata-eval91.4%
Simplified91.4%
clear-num91.4%
inv-pow91.4%
Applied egg-rr91.4%
unpow-191.4%
associate-/l*92.3%
Simplified92.3%
Taylor expanded in z around 0 70.4%
+-commutative70.4%
metadata-eval70.4%
associate-*r*70.4%
neg-mul-170.4%
distribute-lft-in70.4%
sub-neg70.4%
associate-*r/70.4%
Simplified70.4%
Taylor expanded in t around inf 69.6%
associate-*r/69.6%
*-commutative69.6%
*-commutative69.6%
Applied egg-rr69.6%
Final simplification81.3%
(FPCore (x y z t) :precision binary64 (if (or (<= y -2.4e-47) (not (<= y 2.8e-150))) (- x (* y (/ 0.3333333333333333 z))) (/ (* t 0.3333333333333333) (* z y))))
double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -2.4e-47) || !(y <= 2.8e-150)) {
tmp = x - (y * (0.3333333333333333 / z));
} else {
tmp = (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 <= (-2.4d-47)) .or. (.not. (y <= 2.8d-150))) then
tmp = x - (y * (0.3333333333333333d0 / z))
else
tmp = (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 <= -2.4e-47) || !(y <= 2.8e-150)) {
tmp = x - (y * (0.3333333333333333 / z));
} else {
tmp = (t * 0.3333333333333333) / (z * y);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (y <= -2.4e-47) or not (y <= 2.8e-150): tmp = x - (y * (0.3333333333333333 / z)) else: tmp = (t * 0.3333333333333333) / (z * y) return tmp
function code(x, y, z, t) tmp = 0.0 if ((y <= -2.4e-47) || !(y <= 2.8e-150)) tmp = Float64(x - Float64(y * Float64(0.3333333333333333 / z))); else tmp = 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 <= -2.4e-47) || ~((y <= 2.8e-150))) tmp = x - (y * (0.3333333333333333 / z)); else tmp = (t * 0.3333333333333333) / (z * y); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[y, -2.4e-47], N[Not[LessEqual[y, 2.8e-150]], $MachinePrecision]], N[(x - N[(y * N[(0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t * 0.3333333333333333), $MachinePrecision] / N[(z * y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -2.4 \cdot 10^{-47} \lor \neg \left(y \leq 2.8 \cdot 10^{-150}\right):\\
\;\;\;\;x - y \cdot \frac{0.3333333333333333}{z}\\
\mathbf{else}:\\
\;\;\;\;\frac{t \cdot 0.3333333333333333}{z \cdot y}\\
\end{array}
\end{array}
if y < -2.3999999999999999e-47 or 2.79999999999999996e-150 < 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-frac98.6%
distribute-frac-neg98.6%
neg-mul-198.6%
*-commutative98.6%
associate-/l*98.5%
*-commutative98.5%
Simplified99.1%
Taylor expanded in t around 0 88.0%
neg-mul-188.0%
Simplified88.0%
if -2.3999999999999999e-47 < y < 2.79999999999999996e-150Initial program 91.5%
+-commutative91.5%
associate-+r-91.5%
sub-neg91.5%
associate-*l*91.4%
*-commutative91.4%
distribute-frac-neg291.4%
distribute-rgt-neg-in91.4%
metadata-eval91.4%
Simplified91.4%
clear-num91.4%
inv-pow91.4%
Applied egg-rr91.4%
unpow-191.4%
associate-/l*92.3%
Simplified92.3%
Taylor expanded in z around 0 70.4%
+-commutative70.4%
metadata-eval70.4%
associate-*r*70.4%
neg-mul-170.4%
distribute-lft-in70.4%
sub-neg70.4%
associate-*r/70.4%
Simplified70.4%
Taylor expanded in t around inf 69.6%
associate-*r/69.6%
*-commutative69.6%
*-commutative69.6%
Applied egg-rr69.6%
Final simplification81.6%
(FPCore (x y z t)
:precision binary64
(if (<= y -0.007)
(* y (/ -0.3333333333333333 z))
(if (<= y 5200000000000.0)
(* 0.3333333333333333 (/ t (* z y)))
(/ y (* z -3.0)))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -0.007) {
tmp = y * (-0.3333333333333333 / z);
} else if (y <= 5200000000000.0) {
tmp = 0.3333333333333333 * (t / (z * y));
} else {
tmp = y / (z * -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 <= (-0.007d0)) then
tmp = y * ((-0.3333333333333333d0) / z)
else if (y <= 5200000000000.0d0) then
tmp = 0.3333333333333333d0 * (t / (z * y))
else
tmp = y / (z * (-3.0d0))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (y <= -0.007) {
tmp = y * (-0.3333333333333333 / z);
} else if (y <= 5200000000000.0) {
tmp = 0.3333333333333333 * (t / (z * y));
} else {
tmp = y / (z * -3.0);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if y <= -0.007: tmp = y * (-0.3333333333333333 / z) elif y <= 5200000000000.0: tmp = 0.3333333333333333 * (t / (z * y)) else: tmp = y / (z * -3.0) return tmp
function code(x, y, z, t) tmp = 0.0 if (y <= -0.007) tmp = Float64(y * Float64(-0.3333333333333333 / z)); elseif (y <= 5200000000000.0) tmp = Float64(0.3333333333333333 * Float64(t / Float64(z * y))); else tmp = Float64(y / Float64(z * -3.0)); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (y <= -0.007) tmp = y * (-0.3333333333333333 / z); elseif (y <= 5200000000000.0) tmp = 0.3333333333333333 * (t / (z * y)); else tmp = y / (z * -3.0); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[y, -0.007], N[(y * N[(-0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5200000000000.0], N[(0.3333333333333333 * N[(t / N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y / N[(z * -3.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -0.007:\\
\;\;\;\;y \cdot \frac{-0.3333333333333333}{z}\\
\mathbf{elif}\;y \leq 5200000000000:\\
\;\;\;\;0.3333333333333333 \cdot \frac{t}{z \cdot y}\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{z \cdot -3}\\
\end{array}
\end{array}
if y < -0.00700000000000000015Initial program 98.3%
+-commutative98.3%
associate-+r-98.3%
sub-neg98.3%
associate-*l*98.3%
*-commutative98.3%
distribute-frac-neg298.3%
distribute-rgt-neg-in98.3%
metadata-eval98.3%
Simplified98.3%
clear-num98.3%
inv-pow98.3%
Applied egg-rr98.3%
unpow-198.3%
associate-/l*98.3%
Simplified98.3%
Taylor expanded in y around inf 75.4%
associate-*r/75.4%
metadata-eval75.4%
associate-*r*75.4%
neg-mul-175.4%
associate-*l/75.5%
*-commutative75.5%
distribute-lft-neg-out75.5%
distribute-rgt-neg-in75.5%
distribute-neg-frac75.5%
metadata-eval75.5%
Simplified75.5%
if -0.00700000000000000015 < y < 5.2e12Initial program 93.1%
+-commutative93.1%
associate-+r-93.1%
sub-neg93.1%
associate-*l*93.1%
*-commutative93.1%
distribute-frac-neg293.1%
distribute-rgt-neg-in93.1%
metadata-eval93.1%
Simplified93.1%
clear-num93.1%
inv-pow93.1%
Applied egg-rr93.1%
unpow-193.1%
associate-/l*94.3%
Simplified94.3%
Taylor expanded in z around 0 68.8%
+-commutative68.8%
metadata-eval68.8%
associate-*r*68.8%
neg-mul-168.8%
distribute-lft-in68.8%
sub-neg68.8%
associate-*r/68.9%
Simplified68.9%
Taylor expanded in t around inf 63.2%
if 5.2e12 < 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%
clear-num99.8%
inv-pow99.8%
Applied egg-rr99.8%
unpow-199.8%
associate-/l*99.8%
Simplified99.8%
Taylor expanded in y around inf 66.9%
associate-*r/68.2%
metadata-eval68.2%
associate-*r*68.2%
neg-mul-168.2%
associate-*l/68.1%
*-commutative68.1%
distribute-lft-neg-out68.1%
distribute-rgt-neg-in68.1%
distribute-neg-frac68.1%
metadata-eval68.1%
Simplified68.1%
clear-num68.1%
un-div-inv68.1%
div-inv68.2%
metadata-eval68.2%
Applied egg-rr68.2%
Final simplification67.7%
(FPCore (x y z t) :precision binary64 (if (or (<= y -13.0) (not (<= y 2.2e+34))) (* (/ y z) -0.3333333333333333) x))
double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -13.0) || !(y <= 2.2e+34)) {
tmp = (y / z) * -0.3333333333333333;
} 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 ((y <= (-13.0d0)) .or. (.not. (y <= 2.2d+34))) then
tmp = (y / z) * (-0.3333333333333333d0)
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -13.0) || !(y <= 2.2e+34)) {
tmp = (y / z) * -0.3333333333333333;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (y <= -13.0) or not (y <= 2.2e+34): tmp = (y / z) * -0.3333333333333333 else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if ((y <= -13.0) || !(y <= 2.2e+34)) tmp = Float64(Float64(y / z) * -0.3333333333333333); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((y <= -13.0) || ~((y <= 2.2e+34))) tmp = (y / z) * -0.3333333333333333; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[y, -13.0], N[Not[LessEqual[y, 2.2e+34]], $MachinePrecision]], N[(N[(y / z), $MachinePrecision] * -0.3333333333333333), $MachinePrecision], x]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -13 \lor \neg \left(y \leq 2.2 \cdot 10^{+34}\right):\\
\;\;\;\;\frac{y}{z} \cdot -0.3333333333333333\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if y < -13 or 2.2000000000000002e34 < y Initial program 99.0%
+-commutative99.0%
associate-+r-99.0%
sub-neg99.0%
associate-*l*99.0%
*-commutative99.0%
distribute-frac-neg299.0%
distribute-rgt-neg-in99.0%
metadata-eval99.0%
Simplified99.0%
clear-num99.0%
inv-pow99.0%
Applied egg-rr99.0%
unpow-199.0%
associate-/l*99.0%
Simplified99.0%
Taylor expanded in y around inf 74.7%
if -13 < y < 2.2000000000000002e34Initial program 93.4%
sub-neg93.4%
associate-+l+93.4%
+-commutative93.4%
remove-double-neg93.4%
distribute-frac-neg93.4%
distribute-neg-in93.4%
remove-double-neg93.4%
sub-neg93.4%
neg-mul-193.4%
times-frac93.3%
distribute-frac-neg93.3%
neg-mul-193.3%
*-commutative93.3%
associate-/l*93.3%
*-commutative93.3%
Simplified93.2%
Taylor expanded in x around inf 30.4%
Final simplification52.0%
(FPCore (x y z t) :precision binary64 (if (or (<= y -15.0) (not (<= y 1.9e+34))) (* y (/ -0.3333333333333333 z)) x))
double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -15.0) || !(y <= 1.9e+34)) {
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 ((y <= (-15.0d0)) .or. (.not. (y <= 1.9d+34))) 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 ((y <= -15.0) || !(y <= 1.9e+34)) {
tmp = y * (-0.3333333333333333 / z);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (y <= -15.0) or not (y <= 1.9e+34): tmp = y * (-0.3333333333333333 / z) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if ((y <= -15.0) || !(y <= 1.9e+34)) 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 ((y <= -15.0) || ~((y <= 1.9e+34))) tmp = y * (-0.3333333333333333 / z); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[y, -15.0], N[Not[LessEqual[y, 1.9e+34]], $MachinePrecision]], N[(y * N[(-0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision], x]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -15 \lor \neg \left(y \leq 1.9 \cdot 10^{+34}\right):\\
\;\;\;\;y \cdot \frac{-0.3333333333333333}{z}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if y < -15 or 1.9000000000000001e34 < y Initial program 99.0%
+-commutative99.0%
associate-+r-99.0%
sub-neg99.0%
associate-*l*99.0%
*-commutative99.0%
distribute-frac-neg299.0%
distribute-rgt-neg-in99.0%
metadata-eval99.0%
Simplified99.0%
clear-num99.0%
inv-pow99.0%
Applied egg-rr99.0%
unpow-199.0%
associate-/l*99.0%
Simplified99.0%
Taylor expanded in y around inf 74.7%
associate-*r/75.3%
metadata-eval75.3%
associate-*r*75.3%
neg-mul-175.3%
associate-*l/75.3%
*-commutative75.3%
distribute-lft-neg-out75.3%
distribute-rgt-neg-in75.3%
distribute-neg-frac75.3%
metadata-eval75.3%
Simplified75.3%
if -15 < y < 1.9000000000000001e34Initial program 93.4%
sub-neg93.4%
associate-+l+93.4%
+-commutative93.4%
remove-double-neg93.4%
distribute-frac-neg93.4%
distribute-neg-in93.4%
remove-double-neg93.4%
sub-neg93.4%
neg-mul-193.4%
times-frac93.3%
distribute-frac-neg93.3%
neg-mul-193.3%
*-commutative93.3%
associate-/l*93.3%
*-commutative93.3%
Simplified93.2%
Taylor expanded in x around inf 30.4%
Final simplification52.3%
(FPCore (x y z t) :precision binary64 (if (<= y -15.5) (* y (/ -0.3333333333333333 z)) (if (<= y 5.8e+34) x (/ -0.3333333333333333 (/ z y)))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -15.5) {
tmp = y * (-0.3333333333333333 / z);
} else if (y <= 5.8e+34) {
tmp = x;
} else {
tmp = -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 <= (-15.5d0)) then
tmp = y * ((-0.3333333333333333d0) / z)
else if (y <= 5.8d+34) then
tmp = x
else
tmp = (-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 <= -15.5) {
tmp = y * (-0.3333333333333333 / z);
} else if (y <= 5.8e+34) {
tmp = x;
} else {
tmp = -0.3333333333333333 / (z / y);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if y <= -15.5: tmp = y * (-0.3333333333333333 / z) elif y <= 5.8e+34: tmp = x else: tmp = -0.3333333333333333 / (z / y) return tmp
function code(x, y, z, t) tmp = 0.0 if (y <= -15.5) tmp = Float64(y * Float64(-0.3333333333333333 / z)); elseif (y <= 5.8e+34) tmp = x; else tmp = Float64(-0.3333333333333333 / Float64(z / y)); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (y <= -15.5) tmp = y * (-0.3333333333333333 / z); elseif (y <= 5.8e+34) tmp = x; else tmp = -0.3333333333333333 / (z / y); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[y, -15.5], N[(y * N[(-0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.8e+34], x, N[(-0.3333333333333333 / N[(z / y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -15.5:\\
\;\;\;\;y \cdot \frac{-0.3333333333333333}{z}\\
\mathbf{elif}\;y \leq 5.8 \cdot 10^{+34}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;\frac{-0.3333333333333333}{\frac{z}{y}}\\
\end{array}
\end{array}
if y < -15.5Initial program 98.3%
+-commutative98.3%
associate-+r-98.3%
sub-neg98.3%
associate-*l*98.3%
*-commutative98.3%
distribute-frac-neg298.3%
distribute-rgt-neg-in98.3%
metadata-eval98.3%
Simplified98.3%
clear-num98.3%
inv-pow98.3%
Applied egg-rr98.3%
unpow-198.3%
associate-/l*98.3%
Simplified98.3%
Taylor expanded in y around inf 77.5%
associate-*r/77.5%
metadata-eval77.5%
associate-*r*77.5%
neg-mul-177.5%
associate-*l/77.6%
*-commutative77.6%
distribute-lft-neg-out77.6%
distribute-rgt-neg-in77.6%
distribute-neg-frac77.6%
metadata-eval77.6%
Simplified77.6%
if -15.5 < y < 5.8000000000000003e34Initial program 93.4%
sub-neg93.4%
associate-+l+93.4%
+-commutative93.4%
remove-double-neg93.4%
distribute-frac-neg93.4%
distribute-neg-in93.4%
remove-double-neg93.4%
sub-neg93.4%
neg-mul-193.4%
times-frac93.3%
distribute-frac-neg93.3%
neg-mul-193.3%
*-commutative93.3%
associate-/l*93.3%
*-commutative93.3%
Simplified93.2%
Taylor expanded in x around inf 30.4%
if 5.8000000000000003e34 < 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%
clear-num99.8%
inv-pow99.8%
Applied egg-rr99.8%
unpow-199.8%
associate-/l*99.8%
Simplified99.8%
Taylor expanded in y around inf 71.3%
clear-num71.3%
un-div-inv72.7%
Applied egg-rr72.7%
Final simplification52.4%
(FPCore (x y z t) :precision binary64 (if (<= y -23.5) (* y (/ -0.3333333333333333 z)) (if (<= y 3.5e+34) x (/ y (* z -3.0)))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -23.5) {
tmp = y * (-0.3333333333333333 / z);
} else if (y <= 3.5e+34) {
tmp = x;
} else {
tmp = y / (z * -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 <= (-23.5d0)) then
tmp = y * ((-0.3333333333333333d0) / z)
else if (y <= 3.5d+34) then
tmp = x
else
tmp = y / (z * (-3.0d0))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (y <= -23.5) {
tmp = y * (-0.3333333333333333 / z);
} else if (y <= 3.5e+34) {
tmp = x;
} else {
tmp = y / (z * -3.0);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if y <= -23.5: tmp = y * (-0.3333333333333333 / z) elif y <= 3.5e+34: tmp = x else: tmp = y / (z * -3.0) return tmp
function code(x, y, z, t) tmp = 0.0 if (y <= -23.5) tmp = Float64(y * Float64(-0.3333333333333333 / z)); elseif (y <= 3.5e+34) tmp = x; else tmp = Float64(y / Float64(z * -3.0)); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (y <= -23.5) tmp = y * (-0.3333333333333333 / z); elseif (y <= 3.5e+34) tmp = x; else tmp = y / (z * -3.0); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[y, -23.5], N[(y * N[(-0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.5e+34], x, N[(y / N[(z * -3.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -23.5:\\
\;\;\;\;y \cdot \frac{-0.3333333333333333}{z}\\
\mathbf{elif}\;y \leq 3.5 \cdot 10^{+34}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{z \cdot -3}\\
\end{array}
\end{array}
if y < -23.5Initial program 98.3%
+-commutative98.3%
associate-+r-98.3%
sub-neg98.3%
associate-*l*98.3%
*-commutative98.3%
distribute-frac-neg298.3%
distribute-rgt-neg-in98.3%
metadata-eval98.3%
Simplified98.3%
clear-num98.3%
inv-pow98.3%
Applied egg-rr98.3%
unpow-198.3%
associate-/l*98.3%
Simplified98.3%
Taylor expanded in y around inf 77.5%
associate-*r/77.5%
metadata-eval77.5%
associate-*r*77.5%
neg-mul-177.5%
associate-*l/77.6%
*-commutative77.6%
distribute-lft-neg-out77.6%
distribute-rgt-neg-in77.6%
distribute-neg-frac77.6%
metadata-eval77.6%
Simplified77.6%
if -23.5 < y < 3.49999999999999998e34Initial program 93.4%
sub-neg93.4%
associate-+l+93.4%
+-commutative93.4%
remove-double-neg93.4%
distribute-frac-neg93.4%
distribute-neg-in93.4%
remove-double-neg93.4%
sub-neg93.4%
neg-mul-193.4%
times-frac93.3%
distribute-frac-neg93.3%
neg-mul-193.3%
*-commutative93.3%
associate-/l*93.3%
*-commutative93.3%
Simplified93.2%
Taylor expanded in x around inf 30.4%
if 3.49999999999999998e34 < 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%
clear-num99.8%
inv-pow99.8%
Applied egg-rr99.8%
unpow-199.8%
associate-/l*99.8%
Simplified99.8%
Taylor expanded in y around inf 71.3%
associate-*r/72.7%
metadata-eval72.7%
associate-*r*72.7%
neg-mul-172.7%
associate-*l/72.6%
*-commutative72.6%
distribute-lft-neg-out72.6%
distribute-rgt-neg-in72.6%
distribute-neg-frac72.6%
metadata-eval72.6%
Simplified72.6%
clear-num72.6%
un-div-inv72.7%
div-inv72.8%
metadata-eval72.8%
Applied egg-rr72.8%
Final simplification52.4%
(FPCore (x y z t) :precision binary64 (+ x (* (* 0.3333333333333333 (/ 1.0 z)) (- (/ t y) y))))
double code(double x, double y, double z, double t) {
return x + ((0.3333333333333333 * (1.0 / z)) * ((t / y) - 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 + ((0.3333333333333333d0 * (1.0d0 / z)) * ((t / y) - y))
end function
public static double code(double x, double y, double z, double t) {
return x + ((0.3333333333333333 * (1.0 / z)) * ((t / y) - y));
}
def code(x, y, z, t): return x + ((0.3333333333333333 * (1.0 / z)) * ((t / y) - y))
function code(x, y, z, t) return Float64(x + Float64(Float64(0.3333333333333333 * Float64(1.0 / z)) * Float64(Float64(t / y) - y))) end
function tmp = code(x, y, z, t) tmp = x + ((0.3333333333333333 * (1.0 / z)) * ((t / y) - y)); end
code[x_, y_, z_, t_] := N[(x + N[(N[(0.3333333333333333 * N[(1.0 / z), $MachinePrecision]), $MachinePrecision] * N[(N[(t / y), $MachinePrecision] - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(0.3333333333333333 \cdot \frac{1}{z}\right) \cdot \left(\frac{t}{y} - y\right)
\end{array}
Initial program 96.2%
sub-neg96.2%
associate-+l+96.2%
+-commutative96.2%
remove-double-neg96.2%
distribute-frac-neg96.2%
distribute-neg-in96.2%
remove-double-neg96.2%
sub-neg96.2%
neg-mul-196.2%
times-frac96.1%
distribute-frac-neg96.1%
neg-mul-196.1%
*-commutative96.1%
associate-/l*96.0%
*-commutative96.0%
Simplified96.4%
div-inv96.4%
Applied egg-rr96.4%
Final simplification96.4%
(FPCore (x y z t) :precision binary64 (+ x (* 0.3333333333333333 (/ (- (/ t y) y) z))))
double code(double x, double y, double z, double t) {
return x + (0.3333333333333333 * (((t / y) - y) / z));
}
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 + (0.3333333333333333d0 * (((t / y) - y) / z))
end function
public static double code(double x, double y, double z, double t) {
return x + (0.3333333333333333 * (((t / y) - y) / z));
}
def code(x, y, z, t): return x + (0.3333333333333333 * (((t / y) - y) / z))
function code(x, y, z, t) return Float64(x + Float64(0.3333333333333333 * Float64(Float64(Float64(t / y) - y) / z))) end
function tmp = code(x, y, z, t) tmp = x + (0.3333333333333333 * (((t / y) - y) / z)); end
code[x_, y_, z_, t_] := N[(x + N[(0.3333333333333333 * N[(N[(N[(t / y), $MachinePrecision] - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + 0.3333333333333333 \cdot \frac{\frac{t}{y} - y}{z}
\end{array}
Initial program 96.2%
sub-neg96.2%
associate-+l+96.2%
+-commutative96.2%
remove-double-neg96.2%
distribute-frac-neg96.2%
distribute-neg-in96.2%
remove-double-neg96.2%
sub-neg96.2%
neg-mul-196.2%
times-frac96.1%
distribute-frac-neg96.1%
neg-mul-196.1%
*-commutative96.1%
associate-/l*96.0%
*-commutative96.0%
Simplified96.4%
Taylor expanded in z around 0 96.1%
Final simplification96.1%
(FPCore (x y z t) :precision binary64 (+ x (* (- (/ t y) y) (/ 0.3333333333333333 z))))
double code(double x, double y, double z, double t) {
return x + (((t / y) - y) * (0.3333333333333333 / z));
}
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 + (((t / y) - y) * (0.3333333333333333d0 / z))
end function
public static double code(double x, double y, double z, double t) {
return x + (((t / y) - y) * (0.3333333333333333 / z));
}
def code(x, y, z, t): return x + (((t / y) - y) * (0.3333333333333333 / z))
function code(x, y, z, t) return Float64(x + Float64(Float64(Float64(t / y) - y) * Float64(0.3333333333333333 / z))) end
function tmp = code(x, y, z, t) tmp = x + (((t / y) - y) * (0.3333333333333333 / z)); end
code[x_, y_, z_, t_] := N[(x + N[(N[(N[(t / y), $MachinePrecision] - y), $MachinePrecision] * N[(0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(\frac{t}{y} - y\right) \cdot \frac{0.3333333333333333}{z}
\end{array}
Initial program 96.2%
sub-neg96.2%
associate-+l+96.2%
+-commutative96.2%
remove-double-neg96.2%
distribute-frac-neg96.2%
distribute-neg-in96.2%
remove-double-neg96.2%
sub-neg96.2%
neg-mul-196.2%
times-frac96.1%
distribute-frac-neg96.1%
neg-mul-196.1%
*-commutative96.1%
associate-/l*96.0%
*-commutative96.0%
Simplified96.4%
Final simplification96.4%
(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 96.2%
sub-neg96.2%
associate-+l+96.2%
+-commutative96.2%
remove-double-neg96.2%
distribute-frac-neg96.2%
distribute-neg-in96.2%
remove-double-neg96.2%
sub-neg96.2%
neg-mul-196.2%
times-frac96.1%
distribute-frac-neg96.1%
neg-mul-196.1%
*-commutative96.1%
associate-/l*96.0%
*-commutative96.0%
Simplified96.4%
Taylor expanded in x around inf 27.1%
Final simplification27.1%
(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 2024040
(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))))