
(FPCore (x y z t a) :precision binary64 (+ x (/ (* (- y z) (- t x)) (- a z))))
double code(double x, double y, double z, double t, double a) {
return x + (((y - z) * (t - x)) / (a - z));
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = x + (((y - z) * (t - x)) / (a - z))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + (((y - z) * (t - x)) / (a - z));
}
def code(x, y, z, t, a): return x + (((y - z) * (t - x)) / (a - z))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(Float64(y - z) * Float64(t - x)) / Float64(a - z))) end
function tmp = code(x, y, z, t, a) tmp = x + (((y - z) * (t - x)) / (a - z)); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{\left(y - z\right) \cdot \left(t - x\right)}{a - z}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 15 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (+ x (/ (* (- y z) (- t x)) (- a z))))
double code(double x, double y, double z, double t, double a) {
return x + (((y - z) * (t - x)) / (a - z));
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = x + (((y - z) * (t - x)) / (a - z))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + (((y - z) * (t - x)) / (a - z));
}
def code(x, y, z, t, a): return x + (((y - z) * (t - x)) / (a - z))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(Float64(y - z) * Float64(t - x)) / Float64(a - z))) end
function tmp = code(x, y, z, t, a) tmp = x + (((y - z) * (t - x)) / (a - z)); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{\left(y - z\right) \cdot \left(t - x\right)}{a - z}
\end{array}
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ (* (- y z) (- t x)) (- a z)))))
(if (or (<= t_1 -2e-296) (not (<= t_1 0.0)))
(+ x (* (- t x) (/ (- y z) (- a z))))
(- t (/ (* x (- a y)) z)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (((y - z) * (t - x)) / (a - z));
double tmp;
if ((t_1 <= -2e-296) || !(t_1 <= 0.0)) {
tmp = x + ((t - x) * ((y - z) / (a - z)));
} else {
tmp = t - ((x * (a - y)) / z);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x + (((y - z) * (t - x)) / (a - z))
if ((t_1 <= (-2d-296)) .or. (.not. (t_1 <= 0.0d0))) then
tmp = x + ((t - x) * ((y - z) / (a - z)))
else
tmp = t - ((x * (a - y)) / z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + (((y - z) * (t - x)) / (a - z));
double tmp;
if ((t_1 <= -2e-296) || !(t_1 <= 0.0)) {
tmp = x + ((t - x) * ((y - z) / (a - z)));
} else {
tmp = t - ((x * (a - y)) / z);
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (((y - z) * (t - x)) / (a - z)) tmp = 0 if (t_1 <= -2e-296) or not (t_1 <= 0.0): tmp = x + ((t - x) * ((y - z) / (a - z))) else: tmp = t - ((x * (a - y)) / z) return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(Float64(y - z) * Float64(t - x)) / Float64(a - z))) tmp = 0.0 if ((t_1 <= -2e-296) || !(t_1 <= 0.0)) tmp = Float64(x + Float64(Float64(t - x) * Float64(Float64(y - z) / Float64(a - z)))); else tmp = Float64(t - Float64(Float64(x * Float64(a - y)) / z)); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (((y - z) * (t - x)) / (a - z)); tmp = 0.0; if ((t_1 <= -2e-296) || ~((t_1 <= 0.0))) tmp = x + ((t - x) * ((y - z) / (a - z))); else tmp = t - ((x * (a - y)) / z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, -2e-296], N[Not[LessEqual[t$95$1, 0.0]], $MachinePrecision]], N[(x + N[(N[(t - x), $MachinePrecision] * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t - N[(N[(x * N[(a - y), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{\left(y - z\right) \cdot \left(t - x\right)}{a - z}\\
\mathbf{if}\;t_1 \leq -2 \cdot 10^{-296} \lor \neg \left(t_1 \leq 0\right):\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y - z}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t - \frac{x \cdot \left(a - y\right)}{z}\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -2e-296 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) Initial program 73.5%
associate-*l/90.8%
Simplified90.8%
if -2e-296 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 0.0Initial program 4.8%
associate-*l/9.1%
Simplified9.1%
Taylor expanded in z around inf 99.7%
associate--l+99.7%
associate-*r/99.7%
associate-*r/99.7%
div-sub99.7%
distribute-lft-out--99.7%
associate-*r/99.7%
mul-1-neg99.7%
unsub-neg99.7%
distribute-rgt-out--99.7%
Simplified99.7%
Taylor expanded in t around 0 99.7%
associate-*r/99.7%
mul-1-neg99.7%
distribute-rgt-neg-in99.7%
Simplified99.7%
Final simplification91.6%
(FPCore (x y z t a)
:precision binary64
(if (<= a -2.9e+127)
(+ x (/ t (/ a y)))
(if (<= a -1e+21)
(* y (/ (- t x) (- a z)))
(if (<= a -1.25e-13)
(+ x (/ (* y t) a))
(if (<= a 8e-116)
(- t (/ y (/ (- z) x)))
(if (<= a 2.35e+62)
(* t (/ (- y z) (- a z)))
(+ x (* y (/ t a)))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -2.9e+127) {
tmp = x + (t / (a / y));
} else if (a <= -1e+21) {
tmp = y * ((t - x) / (a - z));
} else if (a <= -1.25e-13) {
tmp = x + ((y * t) / a);
} else if (a <= 8e-116) {
tmp = t - (y / (-z / x));
} else if (a <= 2.35e+62) {
tmp = t * ((y - z) / (a - z));
} else {
tmp = x + (y * (t / a));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (a <= (-2.9d+127)) then
tmp = x + (t / (a / y))
else if (a <= (-1d+21)) then
tmp = y * ((t - x) / (a - z))
else if (a <= (-1.25d-13)) then
tmp = x + ((y * t) / a)
else if (a <= 8d-116) then
tmp = t - (y / (-z / x))
else if (a <= 2.35d+62) then
tmp = t * ((y - z) / (a - z))
else
tmp = x + (y * (t / a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -2.9e+127) {
tmp = x + (t / (a / y));
} else if (a <= -1e+21) {
tmp = y * ((t - x) / (a - z));
} else if (a <= -1.25e-13) {
tmp = x + ((y * t) / a);
} else if (a <= 8e-116) {
tmp = t - (y / (-z / x));
} else if (a <= 2.35e+62) {
tmp = t * ((y - z) / (a - z));
} else {
tmp = x + (y * (t / a));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -2.9e+127: tmp = x + (t / (a / y)) elif a <= -1e+21: tmp = y * ((t - x) / (a - z)) elif a <= -1.25e-13: tmp = x + ((y * t) / a) elif a <= 8e-116: tmp = t - (y / (-z / x)) elif a <= 2.35e+62: tmp = t * ((y - z) / (a - z)) else: tmp = x + (y * (t / a)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -2.9e+127) tmp = Float64(x + Float64(t / Float64(a / y))); elseif (a <= -1e+21) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); elseif (a <= -1.25e-13) tmp = Float64(x + Float64(Float64(y * t) / a)); elseif (a <= 8e-116) tmp = Float64(t - Float64(y / Float64(Float64(-z) / x))); elseif (a <= 2.35e+62) tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z))); else tmp = Float64(x + Float64(y * Float64(t / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -2.9e+127) tmp = x + (t / (a / y)); elseif (a <= -1e+21) tmp = y * ((t - x) / (a - z)); elseif (a <= -1.25e-13) tmp = x + ((y * t) / a); elseif (a <= 8e-116) tmp = t - (y / (-z / x)); elseif (a <= 2.35e+62) tmp = t * ((y - z) / (a - z)); else tmp = x + (y * (t / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -2.9e+127], N[(x + N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -1e+21], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -1.25e-13], N[(x + N[(N[(y * t), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 8e-116], N[(t - N[(y / N[((-z) / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.35e+62], N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(y * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -2.9 \cdot 10^{+127}:\\
\;\;\;\;x + \frac{t}{\frac{a}{y}}\\
\mathbf{elif}\;a \leq -1 \cdot 10^{+21}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{elif}\;a \leq -1.25 \cdot 10^{-13}:\\
\;\;\;\;x + \frac{y \cdot t}{a}\\
\mathbf{elif}\;a \leq 8 \cdot 10^{-116}:\\
\;\;\;\;t - \frac{y}{\frac{-z}{x}}\\
\mathbf{elif}\;a \leq 2.35 \cdot 10^{+62}:\\
\;\;\;\;t \cdot \frac{y - z}{a - z}\\
\mathbf{else}:\\
\;\;\;\;x + y \cdot \frac{t}{a}\\
\end{array}
\end{array}
if a < -2.9000000000000002e127Initial program 52.8%
associate-*l/95.0%
Simplified95.0%
Taylor expanded in z around 0 52.8%
Taylor expanded in t around inf 53.5%
associate-/l*67.4%
Simplified67.4%
if -2.9000000000000002e127 < a < -1e21Initial program 69.9%
associate-*l/88.2%
Simplified88.2%
Taylor expanded in y around inf 65.3%
div-sub65.3%
Simplified65.3%
if -1e21 < a < -1.24999999999999997e-13Initial program 72.1%
associate-*l/72.2%
Simplified72.2%
Taylor expanded in z around 0 72.5%
Taylor expanded in t around inf 72.5%
if -1.24999999999999997e-13 < a < 8e-116Initial program 70.6%
associate-*l/75.8%
Simplified75.8%
Taylor expanded in z around inf 78.3%
associate--l+78.3%
associate-*r/78.3%
associate-*r/78.3%
div-sub78.3%
distribute-lft-out--78.3%
associate-*r/78.3%
mul-1-neg78.3%
unsub-neg78.3%
distribute-rgt-out--78.3%
Simplified78.3%
Taylor expanded in y around inf 76.4%
associate-/l*80.1%
Simplified80.1%
Taylor expanded in t around 0 70.1%
associate-*r/70.1%
neg-mul-170.1%
Simplified70.1%
if 8e-116 < a < 2.3500000000000001e62Initial program 71.3%
associate-*l/81.0%
Simplified81.0%
Taylor expanded in x around 0 54.6%
associate-*r/63.5%
Simplified63.5%
if 2.3500000000000001e62 < a Initial program 69.1%
associate-*l/94.3%
Simplified94.3%
associate-/r/93.3%
div-inv93.3%
associate-/r*94.3%
Applied egg-rr94.3%
Taylor expanded in t around inf 77.6%
Taylor expanded in z around 0 64.0%
+-commutative64.0%
associate-/l*70.8%
associate-/r/73.0%
Simplified73.0%
Final simplification68.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ t (/ a y))))
(if (<= z -7.2e+133)
t
(if (<= z -1.2e-276)
x
(if (<= z 5.5e-282)
t_1
(if (<= z 1.1e-131)
x
(if (<= z 3e-87) t_1 (if (<= z 1.35e+104) (+ x t) t))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t / (a / y);
double tmp;
if (z <= -7.2e+133) {
tmp = t;
} else if (z <= -1.2e-276) {
tmp = x;
} else if (z <= 5.5e-282) {
tmp = t_1;
} else if (z <= 1.1e-131) {
tmp = x;
} else if (z <= 3e-87) {
tmp = t_1;
} else if (z <= 1.35e+104) {
tmp = x + t;
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = t / (a / y)
if (z <= (-7.2d+133)) then
tmp = t
else if (z <= (-1.2d-276)) then
tmp = x
else if (z <= 5.5d-282) then
tmp = t_1
else if (z <= 1.1d-131) then
tmp = x
else if (z <= 3d-87) then
tmp = t_1
else if (z <= 1.35d+104) then
tmp = x + t
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t / (a / y);
double tmp;
if (z <= -7.2e+133) {
tmp = t;
} else if (z <= -1.2e-276) {
tmp = x;
} else if (z <= 5.5e-282) {
tmp = t_1;
} else if (z <= 1.1e-131) {
tmp = x;
} else if (z <= 3e-87) {
tmp = t_1;
} else if (z <= 1.35e+104) {
tmp = x + t;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t / (a / y) tmp = 0 if z <= -7.2e+133: tmp = t elif z <= -1.2e-276: tmp = x elif z <= 5.5e-282: tmp = t_1 elif z <= 1.1e-131: tmp = x elif z <= 3e-87: tmp = t_1 elif z <= 1.35e+104: tmp = x + t else: tmp = t return tmp
function code(x, y, z, t, a) t_1 = Float64(t / Float64(a / y)) tmp = 0.0 if (z <= -7.2e+133) tmp = t; elseif (z <= -1.2e-276) tmp = x; elseif (z <= 5.5e-282) tmp = t_1; elseif (z <= 1.1e-131) tmp = x; elseif (z <= 3e-87) tmp = t_1; elseif (z <= 1.35e+104) tmp = Float64(x + t); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t / (a / y); tmp = 0.0; if (z <= -7.2e+133) tmp = t; elseif (z <= -1.2e-276) tmp = x; elseif (z <= 5.5e-282) tmp = t_1; elseif (z <= 1.1e-131) tmp = x; elseif (z <= 3e-87) tmp = t_1; elseif (z <= 1.35e+104) tmp = x + t; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -7.2e+133], t, If[LessEqual[z, -1.2e-276], x, If[LessEqual[z, 5.5e-282], t$95$1, If[LessEqual[z, 1.1e-131], x, If[LessEqual[z, 3e-87], t$95$1, If[LessEqual[z, 1.35e+104], N[(x + t), $MachinePrecision], t]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t}{\frac{a}{y}}\\
\mathbf{if}\;z \leq -7.2 \cdot 10^{+133}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -1.2 \cdot 10^{-276}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 5.5 \cdot 10^{-282}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 1.1 \cdot 10^{-131}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 3 \cdot 10^{-87}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 1.35 \cdot 10^{+104}:\\
\;\;\;\;x + t\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -7.19999999999999956e133 or 1.34999999999999992e104 < z Initial program 36.4%
associate-*l/65.6%
Simplified65.6%
Taylor expanded in z around inf 60.5%
if -7.19999999999999956e133 < z < -1.19999999999999991e-276 or 5.5000000000000001e-282 < z < 1.1e-131Initial program 77.1%
associate-*l/91.3%
Simplified91.3%
Taylor expanded in a around inf 37.6%
if -1.19999999999999991e-276 < z < 5.5000000000000001e-282 or 1.1e-131 < z < 3.00000000000000016e-87Initial program 89.7%
associate-*l/93.2%
Simplified93.2%
Taylor expanded in x around 0 41.4%
associate-*r/48.0%
Simplified48.0%
Taylor expanded in z around 0 48.3%
associate-/l*54.8%
Simplified54.8%
if 3.00000000000000016e-87 < z < 1.34999999999999992e104Initial program 81.9%
associate-*l/87.8%
Simplified87.8%
associate-/r/84.8%
div-inv84.8%
associate-/r*87.8%
Applied egg-rr87.8%
Taylor expanded in t around inf 63.2%
Taylor expanded in z around inf 41.6%
Final simplification46.4%
(FPCore (x y z t a)
:precision binary64
(if (<= z -3.8e+133)
t
(if (<= z -1.26e-282)
x
(if (<= z 1.95e-281)
(/ t (/ a y))
(if (<= z 1.15e-131)
x
(if (<= z 1.7e-87) (/ (* y t) a) (if (<= z 1.3e+104) (+ x t) t)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -3.8e+133) {
tmp = t;
} else if (z <= -1.26e-282) {
tmp = x;
} else if (z <= 1.95e-281) {
tmp = t / (a / y);
} else if (z <= 1.15e-131) {
tmp = x;
} else if (z <= 1.7e-87) {
tmp = (y * t) / a;
} else if (z <= 1.3e+104) {
tmp = x + t;
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-3.8d+133)) then
tmp = t
else if (z <= (-1.26d-282)) then
tmp = x
else if (z <= 1.95d-281) then
tmp = t / (a / y)
else if (z <= 1.15d-131) then
tmp = x
else if (z <= 1.7d-87) then
tmp = (y * t) / a
else if (z <= 1.3d+104) then
tmp = x + t
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -3.8e+133) {
tmp = t;
} else if (z <= -1.26e-282) {
tmp = x;
} else if (z <= 1.95e-281) {
tmp = t / (a / y);
} else if (z <= 1.15e-131) {
tmp = x;
} else if (z <= 1.7e-87) {
tmp = (y * t) / a;
} else if (z <= 1.3e+104) {
tmp = x + t;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -3.8e+133: tmp = t elif z <= -1.26e-282: tmp = x elif z <= 1.95e-281: tmp = t / (a / y) elif z <= 1.15e-131: tmp = x elif z <= 1.7e-87: tmp = (y * t) / a elif z <= 1.3e+104: tmp = x + t else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -3.8e+133) tmp = t; elseif (z <= -1.26e-282) tmp = x; elseif (z <= 1.95e-281) tmp = Float64(t / Float64(a / y)); elseif (z <= 1.15e-131) tmp = x; elseif (z <= 1.7e-87) tmp = Float64(Float64(y * t) / a); elseif (z <= 1.3e+104) tmp = Float64(x + t); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -3.8e+133) tmp = t; elseif (z <= -1.26e-282) tmp = x; elseif (z <= 1.95e-281) tmp = t / (a / y); elseif (z <= 1.15e-131) tmp = x; elseif (z <= 1.7e-87) tmp = (y * t) / a; elseif (z <= 1.3e+104) tmp = x + t; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -3.8e+133], t, If[LessEqual[z, -1.26e-282], x, If[LessEqual[z, 1.95e-281], N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.15e-131], x, If[LessEqual[z, 1.7e-87], N[(N[(y * t), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[z, 1.3e+104], N[(x + t), $MachinePrecision], t]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3.8 \cdot 10^{+133}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -1.26 \cdot 10^{-282}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 1.95 \cdot 10^{-281}:\\
\;\;\;\;\frac{t}{\frac{a}{y}}\\
\mathbf{elif}\;z \leq 1.15 \cdot 10^{-131}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 1.7 \cdot 10^{-87}:\\
\;\;\;\;\frac{y \cdot t}{a}\\
\mathbf{elif}\;z \leq 1.3 \cdot 10^{+104}:\\
\;\;\;\;x + t\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -3.8000000000000002e133 or 1.3e104 < z Initial program 36.4%
associate-*l/65.6%
Simplified65.6%
Taylor expanded in z around inf 60.5%
if -3.8000000000000002e133 < z < -1.26000000000000003e-282 or 1.9500000000000001e-281 < z < 1.15000000000000011e-131Initial program 77.1%
associate-*l/91.3%
Simplified91.3%
Taylor expanded in a around inf 37.6%
if -1.26000000000000003e-282 < z < 1.9500000000000001e-281Initial program 89.4%
associate-*l/99.7%
Simplified99.7%
Taylor expanded in x around 0 46.3%
associate-*r/56.6%
Simplified56.6%
Taylor expanded in z around 0 46.3%
associate-/l*56.5%
Simplified56.5%
if 1.15000000000000011e-131 < z < 1.6999999999999999e-87Initial program 90.0%
associate-*l/81.4%
Simplified81.4%
Taylor expanded in x around 0 32.4%
associate-*r/32.5%
Simplified32.5%
Taylor expanded in z around 0 51.9%
if 1.6999999999999999e-87 < z < 1.3e104Initial program 81.9%
associate-*l/87.8%
Simplified87.8%
associate-/r/84.8%
div-inv84.8%
associate-/r*87.8%
Applied egg-rr87.8%
Taylor expanded in t around inf 63.2%
Taylor expanded in z around inf 41.6%
Final simplification46.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (- 1.0 (/ y z)))))
(if (<= a -7e-12)
x
(if (<= a 1.35e-211)
t_1
(if (<= a 1.4e-167) (* x (/ y z)) (if (<= a 1.35e+84) t_1 x))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * (1.0 - (y / z));
double tmp;
if (a <= -7e-12) {
tmp = x;
} else if (a <= 1.35e-211) {
tmp = t_1;
} else if (a <= 1.4e-167) {
tmp = x * (y / z);
} else if (a <= 1.35e+84) {
tmp = t_1;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = t * (1.0d0 - (y / z))
if (a <= (-7d-12)) then
tmp = x
else if (a <= 1.35d-211) then
tmp = t_1
else if (a <= 1.4d-167) then
tmp = x * (y / z)
else if (a <= 1.35d+84) then
tmp = t_1
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * (1.0 - (y / z));
double tmp;
if (a <= -7e-12) {
tmp = x;
} else if (a <= 1.35e-211) {
tmp = t_1;
} else if (a <= 1.4e-167) {
tmp = x * (y / z);
} else if (a <= 1.35e+84) {
tmp = t_1;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * (1.0 - (y / z)) tmp = 0 if a <= -7e-12: tmp = x elif a <= 1.35e-211: tmp = t_1 elif a <= 1.4e-167: tmp = x * (y / z) elif a <= 1.35e+84: tmp = t_1 else: tmp = x return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(1.0 - Float64(y / z))) tmp = 0.0 if (a <= -7e-12) tmp = x; elseif (a <= 1.35e-211) tmp = t_1; elseif (a <= 1.4e-167) tmp = Float64(x * Float64(y / z)); elseif (a <= 1.35e+84) tmp = t_1; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * (1.0 - (y / z)); tmp = 0.0; if (a <= -7e-12) tmp = x; elseif (a <= 1.35e-211) tmp = t_1; elseif (a <= 1.4e-167) tmp = x * (y / z); elseif (a <= 1.35e+84) tmp = t_1; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -7e-12], x, If[LessEqual[a, 1.35e-211], t$95$1, If[LessEqual[a, 1.4e-167], N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.35e+84], t$95$1, x]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(1 - \frac{y}{z}\right)\\
\mathbf{if}\;a \leq -7 \cdot 10^{-12}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 1.35 \cdot 10^{-211}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 1.4 \cdot 10^{-167}:\\
\;\;\;\;x \cdot \frac{y}{z}\\
\mathbf{elif}\;a \leq 1.35 \cdot 10^{+84}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -7.0000000000000001e-12 or 1.35e84 < a Initial program 64.1%
associate-*l/91.7%
Simplified91.7%
Taylor expanded in a around inf 49.2%
if -7.0000000000000001e-12 < a < 1.35e-211 or 1.39999999999999993e-167 < a < 1.35e84Initial program 70.8%
associate-*l/78.6%
Simplified78.6%
Taylor expanded in z around inf 63.4%
associate--l+63.4%
associate-*r/63.4%
associate-*r/63.4%
div-sub64.2%
distribute-lft-out--64.2%
associate-*r/64.2%
mul-1-neg64.2%
unsub-neg64.2%
distribute-rgt-out--64.3%
Simplified64.3%
Taylor expanded in y around inf 60.5%
associate-/l*66.0%
Simplified66.0%
Taylor expanded in t around inf 50.3%
if 1.35e-211 < a < 1.39999999999999993e-167Initial program 61.4%
associate-*l/70.9%
Simplified70.9%
Taylor expanded in x around -inf 70.4%
associate-*r*70.4%
neg-mul-170.4%
Simplified70.4%
Taylor expanded in z around -inf 61.5%
associate-/l*70.8%
Simplified70.8%
clear-num70.8%
associate-/r/70.9%
clear-num70.9%
Applied egg-rr70.9%
Taylor expanded in y around inf 70.9%
Final simplification50.7%
(FPCore (x y z t a)
:precision binary64
(if (<= a -1.5e-15)
(* x (- 1.0 (/ y a)))
(if (<= a 2.9e-47)
(- t (/ y (/ (- z) x)))
(if (<= a 8.2e+60)
(/ y (/ a (- t x)))
(if (<= a 2.9e+143) (+ x t) (+ x (* y (/ t a))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -1.5e-15) {
tmp = x * (1.0 - (y / a));
} else if (a <= 2.9e-47) {
tmp = t - (y / (-z / x));
} else if (a <= 8.2e+60) {
tmp = y / (a / (t - x));
} else if (a <= 2.9e+143) {
tmp = x + t;
} else {
tmp = x + (y * (t / a));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (a <= (-1.5d-15)) then
tmp = x * (1.0d0 - (y / a))
else if (a <= 2.9d-47) then
tmp = t - (y / (-z / x))
else if (a <= 8.2d+60) then
tmp = y / (a / (t - x))
else if (a <= 2.9d+143) then
tmp = x + t
else
tmp = x + (y * (t / a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -1.5e-15) {
tmp = x * (1.0 - (y / a));
} else if (a <= 2.9e-47) {
tmp = t - (y / (-z / x));
} else if (a <= 8.2e+60) {
tmp = y / (a / (t - x));
} else if (a <= 2.9e+143) {
tmp = x + t;
} else {
tmp = x + (y * (t / a));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -1.5e-15: tmp = x * (1.0 - (y / a)) elif a <= 2.9e-47: tmp = t - (y / (-z / x)) elif a <= 8.2e+60: tmp = y / (a / (t - x)) elif a <= 2.9e+143: tmp = x + t else: tmp = x + (y * (t / a)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -1.5e-15) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (a <= 2.9e-47) tmp = Float64(t - Float64(y / Float64(Float64(-z) / x))); elseif (a <= 8.2e+60) tmp = Float64(y / Float64(a / Float64(t - x))); elseif (a <= 2.9e+143) tmp = Float64(x + t); else tmp = Float64(x + Float64(y * Float64(t / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -1.5e-15) tmp = x * (1.0 - (y / a)); elseif (a <= 2.9e-47) tmp = t - (y / (-z / x)); elseif (a <= 8.2e+60) tmp = y / (a / (t - x)); elseif (a <= 2.9e+143) tmp = x + t; else tmp = x + (y * (t / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -1.5e-15], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.9e-47], N[(t - N[(y / N[((-z) / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 8.2e+60], N[(y / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.9e+143], N[(x + t), $MachinePrecision], N[(x + N[(y * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.5 \cdot 10^{-15}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;a \leq 2.9 \cdot 10^{-47}:\\
\;\;\;\;t - \frac{y}{\frac{-z}{x}}\\
\mathbf{elif}\;a \leq 8.2 \cdot 10^{+60}:\\
\;\;\;\;\frac{y}{\frac{a}{t - x}}\\
\mathbf{elif}\;a \leq 2.9 \cdot 10^{+143}:\\
\;\;\;\;x + t\\
\mathbf{else}:\\
\;\;\;\;x + y \cdot \frac{t}{a}\\
\end{array}
\end{array}
if a < -1.5e-15Initial program 60.1%
associate-*l/90.6%
Simplified90.6%
Taylor expanded in x around -inf 64.6%
associate-*r*64.6%
neg-mul-164.6%
Simplified64.6%
Taylor expanded in z around 0 59.1%
mul-1-neg59.1%
*-commutative59.1%
distribute-rgt-neg-in59.1%
sub-neg59.1%
metadata-eval59.1%
Simplified59.1%
if -1.5e-15 < a < 2.9e-47Initial program 69.0%
associate-*l/76.2%
Simplified76.2%
Taylor expanded in z around inf 74.1%
associate--l+74.1%
associate-*r/74.1%
associate-*r/74.1%
div-sub74.1%
distribute-lft-out--74.1%
associate-*r/74.1%
mul-1-neg74.1%
unsub-neg74.1%
distribute-rgt-out--74.1%
Simplified74.1%
Taylor expanded in y around inf 71.7%
associate-/l*76.9%
Simplified76.9%
Taylor expanded in t around 0 67.7%
associate-*r/67.7%
neg-mul-167.7%
Simplified67.7%
if 2.9e-47 < a < 8.2e60Initial program 78.6%
associate-*l/81.1%
Simplified81.1%
Taylor expanded in y around -inf 53.5%
Taylor expanded in a around inf 51.1%
associate-/l*51.1%
Simplified51.1%
if 8.2e60 < a < 2.8999999999999998e143Initial program 64.7%
associate-*l/98.7%
Simplified98.7%
associate-/r/98.4%
div-inv98.4%
associate-/r*98.4%
Applied egg-rr98.4%
Taylor expanded in t around inf 82.9%
Taylor expanded in z around inf 65.9%
if 2.8999999999999998e143 < a Initial program 69.6%
associate-*l/93.1%
Simplified93.1%
associate-/r/91.9%
div-inv91.9%
associate-/r*93.1%
Applied egg-rr93.1%
Taylor expanded in t around inf 77.1%
Taylor expanded in z around 0 68.4%
+-commutative68.4%
associate-/l*77.2%
associate-/r/80.0%
Simplified80.0%
Final simplification64.8%
(FPCore (x y z t a)
:precision binary64
(if (<= a -8.5e-13)
(* x (- 1.0 (/ y a)))
(if (<= a 3.8e-114)
(- t (/ y (/ (- z) x)))
(if (<= a 3.2e+62) (* t (/ (- y z) (- a z))) (+ x (* y (/ t a)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -8.5e-13) {
tmp = x * (1.0 - (y / a));
} else if (a <= 3.8e-114) {
tmp = t - (y / (-z / x));
} else if (a <= 3.2e+62) {
tmp = t * ((y - z) / (a - z));
} else {
tmp = x + (y * (t / a));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (a <= (-8.5d-13)) then
tmp = x * (1.0d0 - (y / a))
else if (a <= 3.8d-114) then
tmp = t - (y / (-z / x))
else if (a <= 3.2d+62) then
tmp = t * ((y - z) / (a - z))
else
tmp = x + (y * (t / a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -8.5e-13) {
tmp = x * (1.0 - (y / a));
} else if (a <= 3.8e-114) {
tmp = t - (y / (-z / x));
} else if (a <= 3.2e+62) {
tmp = t * ((y - z) / (a - z));
} else {
tmp = x + (y * (t / a));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -8.5e-13: tmp = x * (1.0 - (y / a)) elif a <= 3.8e-114: tmp = t - (y / (-z / x)) elif a <= 3.2e+62: tmp = t * ((y - z) / (a - z)) else: tmp = x + (y * (t / a)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -8.5e-13) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (a <= 3.8e-114) tmp = Float64(t - Float64(y / Float64(Float64(-z) / x))); elseif (a <= 3.2e+62) tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z))); else tmp = Float64(x + Float64(y * Float64(t / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -8.5e-13) tmp = x * (1.0 - (y / a)); elseif (a <= 3.8e-114) tmp = t - (y / (-z / x)); elseif (a <= 3.2e+62) tmp = t * ((y - z) / (a - z)); else tmp = x + (y * (t / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -8.5e-13], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.8e-114], N[(t - N[(y / N[((-z) / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.2e+62], N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(y * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -8.5 \cdot 10^{-13}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;a \leq 3.8 \cdot 10^{-114}:\\
\;\;\;\;t - \frac{y}{\frac{-z}{x}}\\
\mathbf{elif}\;a \leq 3.2 \cdot 10^{+62}:\\
\;\;\;\;t \cdot \frac{y - z}{a - z}\\
\mathbf{else}:\\
\;\;\;\;x + y \cdot \frac{t}{a}\\
\end{array}
\end{array}
if a < -8.5000000000000001e-13Initial program 60.1%
associate-*l/90.6%
Simplified90.6%
Taylor expanded in x around -inf 64.6%
associate-*r*64.6%
neg-mul-164.6%
Simplified64.6%
Taylor expanded in z around 0 59.1%
mul-1-neg59.1%
*-commutative59.1%
distribute-rgt-neg-in59.1%
sub-neg59.1%
metadata-eval59.1%
Simplified59.1%
if -8.5000000000000001e-13 < a < 3.7999999999999998e-114Initial program 70.6%
associate-*l/75.8%
Simplified75.8%
Taylor expanded in z around inf 78.3%
associate--l+78.3%
associate-*r/78.3%
associate-*r/78.3%
div-sub78.3%
distribute-lft-out--78.3%
associate-*r/78.3%
mul-1-neg78.3%
unsub-neg78.3%
distribute-rgt-out--78.3%
Simplified78.3%
Taylor expanded in y around inf 76.4%
associate-/l*80.1%
Simplified80.1%
Taylor expanded in t around 0 70.1%
associate-*r/70.1%
neg-mul-170.1%
Simplified70.1%
if 3.7999999999999998e-114 < a < 3.19999999999999984e62Initial program 71.3%
associate-*l/81.0%
Simplified81.0%
Taylor expanded in x around 0 54.6%
associate-*r/63.5%
Simplified63.5%
if 3.19999999999999984e62 < a Initial program 69.1%
associate-*l/94.3%
Simplified94.3%
associate-/r/93.3%
div-inv93.3%
associate-/r*94.3%
Applied egg-rr94.3%
Taylor expanded in t around inf 77.6%
Taylor expanded in z around 0 64.0%
+-commutative64.0%
associate-/l*70.8%
associate-/r/73.0%
Simplified73.0%
Final simplification66.3%
(FPCore (x y z t a)
:precision binary64
(if (<= z -4.5e+133)
(* t (- 1.0 (/ y z)))
(if (<= z 6.5e+46)
(+ x (/ t (/ a y)))
(if (<= z 1.45e+145) (* x (/ (- y a) z)) t))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -4.5e+133) {
tmp = t * (1.0 - (y / z));
} else if (z <= 6.5e+46) {
tmp = x + (t / (a / y));
} else if (z <= 1.45e+145) {
tmp = x * ((y - a) / z);
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-4.5d+133)) then
tmp = t * (1.0d0 - (y / z))
else if (z <= 6.5d+46) then
tmp = x + (t / (a / y))
else if (z <= 1.45d+145) then
tmp = x * ((y - a) / z)
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -4.5e+133) {
tmp = t * (1.0 - (y / z));
} else if (z <= 6.5e+46) {
tmp = x + (t / (a / y));
} else if (z <= 1.45e+145) {
tmp = x * ((y - a) / z);
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -4.5e+133: tmp = t * (1.0 - (y / z)) elif z <= 6.5e+46: tmp = x + (t / (a / y)) elif z <= 1.45e+145: tmp = x * ((y - a) / z) else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -4.5e+133) tmp = Float64(t * Float64(1.0 - Float64(y / z))); elseif (z <= 6.5e+46) tmp = Float64(x + Float64(t / Float64(a / y))); elseif (z <= 1.45e+145) tmp = Float64(x * Float64(Float64(y - a) / z)); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -4.5e+133) tmp = t * (1.0 - (y / z)); elseif (z <= 6.5e+46) tmp = x + (t / (a / y)); elseif (z <= 1.45e+145) tmp = x * ((y - a) / z); else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -4.5e+133], N[(t * N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 6.5e+46], N[(x + N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.45e+145], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], t]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -4.5 \cdot 10^{+133}:\\
\;\;\;\;t \cdot \left(1 - \frac{y}{z}\right)\\
\mathbf{elif}\;z \leq 6.5 \cdot 10^{+46}:\\
\;\;\;\;x + \frac{t}{\frac{a}{y}}\\
\mathbf{elif}\;z \leq 1.45 \cdot 10^{+145}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -4.49999999999999985e133Initial program 36.5%
associate-*l/59.9%
Simplified59.9%
Taylor expanded in z around inf 68.0%
associate--l+68.0%
associate-*r/68.0%
associate-*r/68.0%
div-sub68.0%
distribute-lft-out--68.0%
associate-*r/68.0%
mul-1-neg68.0%
unsub-neg68.0%
distribute-rgt-out--68.3%
Simplified68.3%
Taylor expanded in y around inf 65.0%
associate-/l*79.3%
Simplified79.3%
Taylor expanded in t around inf 67.1%
if -4.49999999999999985e133 < z < 6.50000000000000008e46Initial program 80.9%
associate-*l/91.6%
Simplified91.6%
Taylor expanded in z around 0 65.3%
Taylor expanded in t around inf 54.6%
associate-/l*59.8%
Simplified59.8%
if 6.50000000000000008e46 < z < 1.45e145Initial program 40.3%
associate-*l/66.2%
Simplified66.2%
Taylor expanded in x around -inf 51.1%
associate-*r*51.1%
neg-mul-151.1%
Simplified51.1%
Taylor expanded in z around -inf 35.7%
associate-/l*47.9%
Simplified47.9%
clear-num47.7%
associate-/r/47.8%
clear-num47.8%
Applied egg-rr47.8%
if 1.45e145 < z Initial program 42.9%
associate-*l/78.9%
Simplified78.9%
Taylor expanded in z around inf 80.3%
Final simplification61.5%
(FPCore (x y z t a)
:precision binary64
(if (<= z -3.8e+133)
(* t (- 1.0 (/ y z)))
(if (<= z 1.5e+42)
(+ x (/ t (/ a y)))
(if (<= z 2.3e+155) (/ x (/ z (- y a))) t))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -3.8e+133) {
tmp = t * (1.0 - (y / z));
} else if (z <= 1.5e+42) {
tmp = x + (t / (a / y));
} else if (z <= 2.3e+155) {
tmp = x / (z / (y - a));
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-3.8d+133)) then
tmp = t * (1.0d0 - (y / z))
else if (z <= 1.5d+42) then
tmp = x + (t / (a / y))
else if (z <= 2.3d+155) then
tmp = x / (z / (y - a))
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -3.8e+133) {
tmp = t * (1.0 - (y / z));
} else if (z <= 1.5e+42) {
tmp = x + (t / (a / y));
} else if (z <= 2.3e+155) {
tmp = x / (z / (y - a));
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -3.8e+133: tmp = t * (1.0 - (y / z)) elif z <= 1.5e+42: tmp = x + (t / (a / y)) elif z <= 2.3e+155: tmp = x / (z / (y - a)) else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -3.8e+133) tmp = Float64(t * Float64(1.0 - Float64(y / z))); elseif (z <= 1.5e+42) tmp = Float64(x + Float64(t / Float64(a / y))); elseif (z <= 2.3e+155) tmp = Float64(x / Float64(z / Float64(y - a))); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -3.8e+133) tmp = t * (1.0 - (y / z)); elseif (z <= 1.5e+42) tmp = x + (t / (a / y)); elseif (z <= 2.3e+155) tmp = x / (z / (y - a)); else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -3.8e+133], N[(t * N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.5e+42], N[(x + N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.3e+155], N[(x / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3.8 \cdot 10^{+133}:\\
\;\;\;\;t \cdot \left(1 - \frac{y}{z}\right)\\
\mathbf{elif}\;z \leq 1.5 \cdot 10^{+42}:\\
\;\;\;\;x + \frac{t}{\frac{a}{y}}\\
\mathbf{elif}\;z \leq 2.3 \cdot 10^{+155}:\\
\;\;\;\;\frac{x}{\frac{z}{y - a}}\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -3.8000000000000002e133Initial program 36.5%
associate-*l/59.9%
Simplified59.9%
Taylor expanded in z around inf 68.0%
associate--l+68.0%
associate-*r/68.0%
associate-*r/68.0%
div-sub68.0%
distribute-lft-out--68.0%
associate-*r/68.0%
mul-1-neg68.0%
unsub-neg68.0%
distribute-rgt-out--68.3%
Simplified68.3%
Taylor expanded in y around inf 65.0%
associate-/l*79.3%
Simplified79.3%
Taylor expanded in t around inf 67.1%
if -3.8000000000000002e133 < z < 1.50000000000000014e42Initial program 80.9%
associate-*l/91.6%
Simplified91.6%
Taylor expanded in z around 0 65.3%
Taylor expanded in t around inf 54.6%
associate-/l*59.8%
Simplified59.8%
if 1.50000000000000014e42 < z < 2.29999999999999998e155Initial program 40.3%
associate-*l/66.2%
Simplified66.2%
Taylor expanded in x around -inf 51.1%
associate-*r*51.1%
neg-mul-151.1%
Simplified51.1%
Taylor expanded in z around -inf 35.7%
associate-/l*47.9%
Simplified47.9%
if 2.29999999999999998e155 < z Initial program 42.9%
associate-*l/78.9%
Simplified78.9%
Taylor expanded in z around inf 80.3%
Final simplification61.5%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -4.5e+133) (not (<= z 3.2e-57))) (- t (/ y (/ (- z) x))) (+ x (/ y (/ a (- t x))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -4.5e+133) || !(z <= 3.2e-57)) {
tmp = t - (y / (-z / x));
} else {
tmp = x + (y / (a / (t - x)));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((z <= (-4.5d+133)) .or. (.not. (z <= 3.2d-57))) then
tmp = t - (y / (-z / x))
else
tmp = x + (y / (a / (t - x)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -4.5e+133) || !(z <= 3.2e-57)) {
tmp = t - (y / (-z / x));
} else {
tmp = x + (y / (a / (t - x)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -4.5e+133) or not (z <= 3.2e-57): tmp = t - (y / (-z / x)) else: tmp = x + (y / (a / (t - x))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -4.5e+133) || !(z <= 3.2e-57)) tmp = Float64(t - Float64(y / Float64(Float64(-z) / x))); else tmp = Float64(x + Float64(y / Float64(a / Float64(t - x)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -4.5e+133) || ~((z <= 3.2e-57))) tmp = t - (y / (-z / x)); else tmp = x + (y / (a / (t - x))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -4.5e+133], N[Not[LessEqual[z, 3.2e-57]], $MachinePrecision]], N[(t - N[(y / N[((-z) / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(y / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -4.5 \cdot 10^{+133} \lor \neg \left(z \leq 3.2 \cdot 10^{-57}\right):\\
\;\;\;\;t - \frac{y}{\frac{-z}{x}}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t - x}}\\
\end{array}
\end{array}
if z < -4.49999999999999985e133 or 3.2000000000000001e-57 < z Initial program 49.1%
associate-*l/71.7%
Simplified71.7%
Taylor expanded in z around inf 62.7%
associate--l+62.7%
associate-*r/62.7%
associate-*r/62.7%
div-sub62.7%
distribute-lft-out--62.7%
associate-*r/62.7%
mul-1-neg62.7%
unsub-neg62.7%
distribute-rgt-out--63.0%
Simplified63.0%
Taylor expanded in y around inf 58.8%
associate-/l*70.1%
Simplified70.1%
Taylor expanded in t around 0 67.3%
associate-*r/67.3%
neg-mul-167.3%
Simplified67.3%
if -4.49999999999999985e133 < z < 3.2000000000000001e-57Initial program 79.7%
associate-*l/91.7%
Simplified91.7%
Taylor expanded in z around 0 67.3%
associate-/l*77.0%
Simplified77.0%
Final simplification73.2%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -5.8e+63) (not (<= z 1.2e-61))) (- t (/ y (/ z (- t x)))) (+ x (/ y (/ a (- t x))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -5.8e+63) || !(z <= 1.2e-61)) {
tmp = t - (y / (z / (t - x)));
} else {
tmp = x + (y / (a / (t - x)));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((z <= (-5.8d+63)) .or. (.not. (z <= 1.2d-61))) then
tmp = t - (y / (z / (t - x)))
else
tmp = x + (y / (a / (t - x)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -5.8e+63) || !(z <= 1.2e-61)) {
tmp = t - (y / (z / (t - x)));
} else {
tmp = x + (y / (a / (t - x)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -5.8e+63) or not (z <= 1.2e-61): tmp = t - (y / (z / (t - x))) else: tmp = x + (y / (a / (t - x))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -5.8e+63) || !(z <= 1.2e-61)) tmp = Float64(t - Float64(y / Float64(z / Float64(t - x)))); else tmp = Float64(x + Float64(y / Float64(a / Float64(t - x)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -5.8e+63) || ~((z <= 1.2e-61))) tmp = t - (y / (z / (t - x))); else tmp = x + (y / (a / (t - x))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -5.8e+63], N[Not[LessEqual[z, 1.2e-61]], $MachinePrecision]], N[(t - N[(y / N[(z / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(y / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -5.8 \cdot 10^{+63} \lor \neg \left(z \leq 1.2 \cdot 10^{-61}\right):\\
\;\;\;\;t - \frac{y}{\frac{z}{t - x}}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t - x}}\\
\end{array}
\end{array}
if z < -5.7999999999999999e63 or 1.2e-61 < z Initial program 48.5%
associate-*l/70.8%
Simplified70.8%
Taylor expanded in z around inf 61.7%
associate--l+61.7%
associate-*r/61.7%
associate-*r/61.7%
div-sub61.7%
distribute-lft-out--61.7%
associate-*r/61.7%
mul-1-neg61.7%
unsub-neg61.7%
distribute-rgt-out--61.9%
Simplified61.9%
Taylor expanded in y around inf 56.3%
associate-/l*67.0%
Simplified67.0%
if -5.7999999999999999e63 < z < 1.2e-61Initial program 83.2%
associate-*l/94.4%
Simplified94.4%
Taylor expanded in z around 0 70.2%
associate-/l*80.9%
Simplified80.9%
Final simplification74.7%
(FPCore (x y z t a)
:precision binary64
(if (<= z -2e+134)
t
(if (<= z 2.4e-124)
x
(if (<= z 6e-25) (* y (/ x z)) (if (<= z 4e+50) (+ x t) t)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2e+134) {
tmp = t;
} else if (z <= 2.4e-124) {
tmp = x;
} else if (z <= 6e-25) {
tmp = y * (x / z);
} else if (z <= 4e+50) {
tmp = x + t;
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-2d+134)) then
tmp = t
else if (z <= 2.4d-124) then
tmp = x
else if (z <= 6d-25) then
tmp = y * (x / z)
else if (z <= 4d+50) then
tmp = x + t
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2e+134) {
tmp = t;
} else if (z <= 2.4e-124) {
tmp = x;
} else if (z <= 6e-25) {
tmp = y * (x / z);
} else if (z <= 4e+50) {
tmp = x + t;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2e+134: tmp = t elif z <= 2.4e-124: tmp = x elif z <= 6e-25: tmp = y * (x / z) elif z <= 4e+50: tmp = x + t else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2e+134) tmp = t; elseif (z <= 2.4e-124) tmp = x; elseif (z <= 6e-25) tmp = Float64(y * Float64(x / z)); elseif (z <= 4e+50) tmp = Float64(x + t); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2e+134) tmp = t; elseif (z <= 2.4e-124) tmp = x; elseif (z <= 6e-25) tmp = y * (x / z); elseif (z <= 4e+50) tmp = x + t; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2e+134], t, If[LessEqual[z, 2.4e-124], x, If[LessEqual[z, 6e-25], N[(y * N[(x / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4e+50], N[(x + t), $MachinePrecision], t]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2 \cdot 10^{+134}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 2.4 \cdot 10^{-124}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 6 \cdot 10^{-25}:\\
\;\;\;\;y \cdot \frac{x}{z}\\
\mathbf{elif}\;z \leq 4 \cdot 10^{+50}:\\
\;\;\;\;x + t\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -1.99999999999999984e134 or 4.0000000000000003e50 < z Initial program 38.8%
associate-*l/67.0%
Simplified67.0%
Taylor expanded in z around inf 56.6%
if -1.99999999999999984e134 < z < 2.39999999999999992e-124Initial program 78.8%
associate-*l/92.4%
Simplified92.4%
Taylor expanded in a around inf 35.8%
if 2.39999999999999992e-124 < z < 5.9999999999999995e-25Initial program 85.1%
associate-*l/80.7%
Simplified80.7%
Taylor expanded in x around -inf 66.3%
associate-*r*66.3%
neg-mul-166.3%
Simplified66.3%
Taylor expanded in z around -inf 45.0%
associate-/l*40.4%
Simplified40.4%
Taylor expanded in y around inf 45.1%
associate-*l/40.1%
*-commutative40.1%
Simplified40.1%
if 5.9999999999999995e-25 < z < 4.0000000000000003e50Initial program 99.9%
associate-*l/99.7%
Simplified99.7%
associate-/r/99.7%
div-inv99.7%
associate-/r*99.6%
Applied egg-rr99.6%
Taylor expanded in t around inf 84.5%
Taylor expanded in z around inf 44.8%
Final simplification43.1%
(FPCore (x y z t a)
:precision binary64
(if (<= z -8.8e+133)
t
(if (<= z 2.4e-124)
x
(if (<= z 1.05e-25) (* x (/ y z)) (if (<= z 1e+51) (+ x t) t)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -8.8e+133) {
tmp = t;
} else if (z <= 2.4e-124) {
tmp = x;
} else if (z <= 1.05e-25) {
tmp = x * (y / z);
} else if (z <= 1e+51) {
tmp = x + t;
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-8.8d+133)) then
tmp = t
else if (z <= 2.4d-124) then
tmp = x
else if (z <= 1.05d-25) then
tmp = x * (y / z)
else if (z <= 1d+51) then
tmp = x + t
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -8.8e+133) {
tmp = t;
} else if (z <= 2.4e-124) {
tmp = x;
} else if (z <= 1.05e-25) {
tmp = x * (y / z);
} else if (z <= 1e+51) {
tmp = x + t;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -8.8e+133: tmp = t elif z <= 2.4e-124: tmp = x elif z <= 1.05e-25: tmp = x * (y / z) elif z <= 1e+51: tmp = x + t else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -8.8e+133) tmp = t; elseif (z <= 2.4e-124) tmp = x; elseif (z <= 1.05e-25) tmp = Float64(x * Float64(y / z)); elseif (z <= 1e+51) tmp = Float64(x + t); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -8.8e+133) tmp = t; elseif (z <= 2.4e-124) tmp = x; elseif (z <= 1.05e-25) tmp = x * (y / z); elseif (z <= 1e+51) tmp = x + t; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -8.8e+133], t, If[LessEqual[z, 2.4e-124], x, If[LessEqual[z, 1.05e-25], N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1e+51], N[(x + t), $MachinePrecision], t]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -8.8 \cdot 10^{+133}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 2.4 \cdot 10^{-124}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 1.05 \cdot 10^{-25}:\\
\;\;\;\;x \cdot \frac{y}{z}\\
\mathbf{elif}\;z \leq 10^{+51}:\\
\;\;\;\;x + t\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -8.8e133 or 1e51 < z Initial program 38.8%
associate-*l/67.0%
Simplified67.0%
Taylor expanded in z around inf 56.6%
if -8.8e133 < z < 2.39999999999999992e-124Initial program 78.8%
associate-*l/92.4%
Simplified92.4%
Taylor expanded in a around inf 35.8%
if 2.39999999999999992e-124 < z < 1.05000000000000001e-25Initial program 85.1%
associate-*l/80.7%
Simplified80.7%
Taylor expanded in x around -inf 66.3%
associate-*r*66.3%
neg-mul-166.3%
Simplified66.3%
Taylor expanded in z around -inf 45.0%
associate-/l*40.4%
Simplified40.4%
clear-num40.4%
associate-/r/40.5%
clear-num40.5%
Applied egg-rr40.5%
Taylor expanded in y around inf 40.5%
if 1.05000000000000001e-25 < z < 1e51Initial program 99.9%
associate-*l/99.7%
Simplified99.7%
associate-/r/99.7%
div-inv99.7%
associate-/r*99.6%
Applied egg-rr99.6%
Taylor expanded in t around inf 84.5%
Taylor expanded in z around inf 44.8%
Final simplification43.2%
(FPCore (x y z t a) :precision binary64 (if (<= z -8.6e+133) t (if (<= z 2.9e+48) x t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -8.6e+133) {
tmp = t;
} else if (z <= 2.9e+48) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-8.6d+133)) then
tmp = t
else if (z <= 2.9d+48) then
tmp = x
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -8.6e+133) {
tmp = t;
} else if (z <= 2.9e+48) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -8.6e+133: tmp = t elif z <= 2.9e+48: tmp = x else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -8.6e+133) tmp = t; elseif (z <= 2.9e+48) tmp = x; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -8.6e+133) tmp = t; elseif (z <= 2.9e+48) tmp = x; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -8.6e+133], t, If[LessEqual[z, 2.9e+48], x, t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -8.6 \cdot 10^{+133}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 2.9 \cdot 10^{+48}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -8.59999999999999989e133 or 2.8999999999999999e48 < z Initial program 38.8%
associate-*l/67.0%
Simplified67.0%
Taylor expanded in z around inf 56.6%
if -8.59999999999999989e133 < z < 2.8999999999999999e48Initial program 81.0%
associate-*l/91.6%
Simplified91.6%
Taylor expanded in a around inf 34.0%
Final simplification41.2%
(FPCore (x y z t a) :precision binary64 t)
double code(double x, double y, double z, double t, double a) {
return t;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = t
end function
public static double code(double x, double y, double z, double t, double a) {
return t;
}
def code(x, y, z, t, a): return t
function code(x, y, z, t, a) return t end
function tmp = code(x, y, z, t, a) tmp = t; end
code[x_, y_, z_, t_, a_] := t
\begin{array}{l}
\\
t
\end{array}
Initial program 67.6%
associate-*l/83.8%
Simplified83.8%
Taylor expanded in z around inf 25.4%
Final simplification25.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- t (* (/ y z) (- t x)))))
(if (< z -1.2536131056095036e+188)
t_1
(if (< z 4.446702369113811e+64)
(+ x (/ (- y z) (/ (- a z) (- t x))))
t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t - ((y / z) * (t - x));
double tmp;
if (z < -1.2536131056095036e+188) {
tmp = t_1;
} else if (z < 4.446702369113811e+64) {
tmp = x + ((y - z) / ((a - z) / (t - x)));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = t - ((y / z) * (t - x))
if (z < (-1.2536131056095036d+188)) then
tmp = t_1
else if (z < 4.446702369113811d+64) then
tmp = x + ((y - z) / ((a - z) / (t - x)))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t - ((y / z) * (t - x));
double tmp;
if (z < -1.2536131056095036e+188) {
tmp = t_1;
} else if (z < 4.446702369113811e+64) {
tmp = x + ((y - z) / ((a - z) / (t - x)));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t - ((y / z) * (t - x)) tmp = 0 if z < -1.2536131056095036e+188: tmp = t_1 elif z < 4.446702369113811e+64: tmp = x + ((y - z) / ((a - z) / (t - x))) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t - Float64(Float64(y / z) * Float64(t - x))) tmp = 0.0 if (z < -1.2536131056095036e+188) tmp = t_1; elseif (z < 4.446702369113811e+64) tmp = Float64(x + Float64(Float64(y - z) / Float64(Float64(a - z) / Float64(t - x)))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t - ((y / z) * (t - x)); tmp = 0.0; if (z < -1.2536131056095036e+188) tmp = t_1; elseif (z < 4.446702369113811e+64) tmp = x + ((y - z) / ((a - z) / (t - x))); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t - N[(N[(y / z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[z, -1.2536131056095036e+188], t$95$1, If[Less[z, 4.446702369113811e+64], N[(x + N[(N[(y - z), $MachinePrecision] / N[(N[(a - z), $MachinePrecision] / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t - \frac{y}{z} \cdot \left(t - x\right)\\
\mathbf{if}\;z < -1.2536131056095036 \cdot 10^{+188}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z < 4.446702369113811 \cdot 10^{+64}:\\
\;\;\;\;x + \frac{y - z}{\frac{a - z}{t - x}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
herbie shell --seed 2023279
(FPCore (x y z t a)
:name "Graphics.Rendering.Chart.Axis.Types:invLinMap from Chart-1.5.3"
:precision binary64
:herbie-target
(if (< z -1.2536131056095036e+188) (- t (* (/ y z) (- t x))) (if (< z 4.446702369113811e+64) (+ x (/ (- y z) (/ (- a z) (- t x)))) (- t (* (/ y z) (- t x)))))
(+ x (/ (* (- y z) (- t x)) (- a z))))