
(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 20 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 (if (or (<= z -2.15e+82) (not (<= z 5.4e+81))) (- t (* (- t x) (* (- a y) (/ -1.0 z)))) (+ x (/ (- t x) (/ (- a z) (- y z))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -2.15e+82) || !(z <= 5.4e+81)) {
tmp = t - ((t - x) * ((a - y) * (-1.0 / z)));
} else {
tmp = x + ((t - x) / ((a - z) / (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) :: tmp
if ((z <= (-2.15d+82)) .or. (.not. (z <= 5.4d+81))) then
tmp = t - ((t - x) * ((a - y) * ((-1.0d0) / z)))
else
tmp = x + ((t - x) / ((a - z) / (y - z)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -2.15e+82) || !(z <= 5.4e+81)) {
tmp = t - ((t - x) * ((a - y) * (-1.0 / z)));
} else {
tmp = x + ((t - x) / ((a - z) / (y - z)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -2.15e+82) or not (z <= 5.4e+81): tmp = t - ((t - x) * ((a - y) * (-1.0 / z))) else: tmp = x + ((t - x) / ((a - z) / (y - z))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -2.15e+82) || !(z <= 5.4e+81)) tmp = Float64(t - Float64(Float64(t - x) * Float64(Float64(a - y) * Float64(-1.0 / z)))); else tmp = Float64(x + Float64(Float64(t - x) / Float64(Float64(a - z) / Float64(y - z)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -2.15e+82) || ~((z <= 5.4e+81))) tmp = t - ((t - x) * ((a - y) * (-1.0 / z))); else tmp = x + ((t - x) / ((a - z) / (y - z))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -2.15e+82], N[Not[LessEqual[z, 5.4e+81]], $MachinePrecision]], N[(t - N[(N[(t - x), $MachinePrecision] * N[(N[(a - y), $MachinePrecision] * N[(-1.0 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(t - x), $MachinePrecision] / N[(N[(a - z), $MachinePrecision] / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.15 \cdot 10^{+82} \lor \neg \left(z \leq 5.4 \cdot 10^{+81}\right):\\
\;\;\;\;t - \left(t - x\right) \cdot \left(\left(a - y\right) \cdot \frac{-1}{z}\right)\\
\mathbf{else}:\\
\;\;\;\;x + \frac{t - x}{\frac{a - z}{y - z}}\\
\end{array}
\end{array}
if z < -2.15000000000000007e82 or 5.3999999999999999e81 < z Initial program 26.2%
+-commutative26.2%
*-commutative26.2%
associate-/l*59.7%
fma-define59.8%
Simplified59.8%
Taylor expanded in z around inf 60.6%
associate--l+60.6%
associate-*r/60.6%
associate-*r/60.6%
mul-1-neg60.6%
div-sub60.6%
mul-1-neg60.6%
distribute-lft-out--60.6%
associate-*r/60.6%
mul-1-neg60.6%
unsub-neg60.6%
distribute-rgt-out--63.3%
Simplified63.3%
div-inv63.2%
Applied egg-rr63.2%
associate-*l*84.7%
Simplified84.7%
if -2.15000000000000007e82 < z < 5.3999999999999999e81Initial program 84.8%
associate-/l*91.2%
Simplified91.2%
Taylor expanded in y around 0 88.3%
mul-1-neg88.3%
associate-/l*88.7%
distribute-lft-neg-out88.7%
+-commutative88.7%
div-sub88.7%
distribute-rgt-out91.2%
sub-neg91.2%
associate-/r/92.6%
Simplified92.6%
Final simplification90.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ (* (- t x) (- y z)) (- a z)))))
(if (or (<= t_1 -5e-297) (not (<= t_1 0.0)))
(+ x (/ (- t x) (/ (- a z) (- y z))))
(+ t (/ (* (- t x) (- a y)) z)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (((t - x) * (y - z)) / (a - z));
double tmp;
if ((t_1 <= -5e-297) || !(t_1 <= 0.0)) {
tmp = x + ((t - x) / ((a - z) / (y - z)));
} else {
tmp = t + (((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 + (((t - x) * (y - z)) / (a - z))
if ((t_1 <= (-5d-297)) .or. (.not. (t_1 <= 0.0d0))) then
tmp = x + ((t - x) / ((a - z) / (y - z)))
else
tmp = t + (((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 + (((t - x) * (y - z)) / (a - z));
double tmp;
if ((t_1 <= -5e-297) || !(t_1 <= 0.0)) {
tmp = x + ((t - x) / ((a - z) / (y - z)));
} else {
tmp = t + (((t - x) * (a - y)) / z);
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (((t - x) * (y - z)) / (a - z)) tmp = 0 if (t_1 <= -5e-297) or not (t_1 <= 0.0): tmp = x + ((t - x) / ((a - z) / (y - z))) else: tmp = t + (((t - x) * (a - y)) / z) return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(Float64(t - x) * Float64(y - z)) / Float64(a - z))) tmp = 0.0 if ((t_1 <= -5e-297) || !(t_1 <= 0.0)) tmp = Float64(x + Float64(Float64(t - x) / Float64(Float64(a - z) / Float64(y - z)))); else tmp = Float64(t + Float64(Float64(Float64(t - x) * Float64(a - y)) / z)); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (((t - x) * (y - z)) / (a - z)); tmp = 0.0; if ((t_1 <= -5e-297) || ~((t_1 <= 0.0))) tmp = x + ((t - x) / ((a - z) / (y - z))); else tmp = t + (((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[(t - x), $MachinePrecision] * N[(y - z), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, -5e-297], N[Not[LessEqual[t$95$1, 0.0]], $MachinePrecision]], N[(x + N[(N[(t - x), $MachinePrecision] / N[(N[(a - z), $MachinePrecision] / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(N[(N[(t - x), $MachinePrecision] * N[(a - y), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{\left(t - x\right) \cdot \left(y - z\right)}{a - z}\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{-297} \lor \neg \left(t\_1 \leq 0\right):\\
\;\;\;\;x + \frac{t - x}{\frac{a - z}{y - z}}\\
\mathbf{else}:\\
\;\;\;\;t + \frac{\left(t - x\right) \cdot \left(a - y\right)}{z}\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -5e-297 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) Initial program 71.0%
associate-/l*86.3%
Simplified86.3%
Taylor expanded in y around 0 73.9%
mul-1-neg73.9%
associate-/l*84.5%
distribute-lft-neg-out84.5%
+-commutative84.5%
div-sub84.5%
distribute-rgt-out86.3%
sub-neg86.3%
associate-/r/88.5%
Simplified88.5%
if -5e-297 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 0.0Initial program 4.4%
+-commutative4.4%
*-commutative4.4%
associate-/l*4.4%
fma-define4.4%
Simplified4.4%
Taylor expanded in z around inf 99.8%
associate--l+99.8%
associate-*r/99.8%
associate-*r/99.8%
mul-1-neg99.8%
div-sub99.9%
mul-1-neg99.9%
distribute-lft-out--99.9%
associate-*r/99.9%
mul-1-neg99.9%
unsub-neg99.9%
distribute-rgt-out--99.9%
Simplified99.9%
Final simplification89.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ (* (- t x) (- y z)) (- a z)))))
(if (or (<= t_1 -5e-297) (not (<= t_1 0.0)))
(+ x (* (- y z) (/ (- t x) (- a z))))
(+ t (/ (* (- t x) (- a y)) z)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (((t - x) * (y - z)) / (a - z));
double tmp;
if ((t_1 <= -5e-297) || !(t_1 <= 0.0)) {
tmp = x + ((y - z) * ((t - x) / (a - z)));
} else {
tmp = t + (((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 + (((t - x) * (y - z)) / (a - z))
if ((t_1 <= (-5d-297)) .or. (.not. (t_1 <= 0.0d0))) then
tmp = x + ((y - z) * ((t - x) / (a - z)))
else
tmp = t + (((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 + (((t - x) * (y - z)) / (a - z));
double tmp;
if ((t_1 <= -5e-297) || !(t_1 <= 0.0)) {
tmp = x + ((y - z) * ((t - x) / (a - z)));
} else {
tmp = t + (((t - x) * (a - y)) / z);
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (((t - x) * (y - z)) / (a - z)) tmp = 0 if (t_1 <= -5e-297) or not (t_1 <= 0.0): tmp = x + ((y - z) * ((t - x) / (a - z))) else: tmp = t + (((t - x) * (a - y)) / z) return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(Float64(t - x) * Float64(y - z)) / Float64(a - z))) tmp = 0.0 if ((t_1 <= -5e-297) || !(t_1 <= 0.0)) tmp = Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / Float64(a - z)))); else tmp = Float64(t + Float64(Float64(Float64(t - x) * Float64(a - y)) / z)); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (((t - x) * (y - z)) / (a - z)); tmp = 0.0; if ((t_1 <= -5e-297) || ~((t_1 <= 0.0))) tmp = x + ((y - z) * ((t - x) / (a - z))); else tmp = t + (((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[(t - x), $MachinePrecision] * N[(y - z), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, -5e-297], N[Not[LessEqual[t$95$1, 0.0]], $MachinePrecision]], N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(N[(N[(t - x), $MachinePrecision] * N[(a - y), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{\left(t - x\right) \cdot \left(y - z\right)}{a - z}\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{-297} \lor \neg \left(t\_1 \leq 0\right):\\
\;\;\;\;x + \left(y - z\right) \cdot \frac{t - x}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t + \frac{\left(t - x\right) \cdot \left(a - y\right)}{z}\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -5e-297 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) Initial program 71.0%
associate-/l*86.3%
Simplified86.3%
if -5e-297 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 0.0Initial program 4.4%
+-commutative4.4%
*-commutative4.4%
associate-/l*4.4%
fma-define4.4%
Simplified4.4%
Taylor expanded in z around inf 99.8%
associate--l+99.8%
associate-*r/99.8%
associate-*r/99.8%
mul-1-neg99.8%
div-sub99.9%
mul-1-neg99.9%
distribute-lft-out--99.9%
associate-*r/99.9%
mul-1-neg99.9%
unsub-neg99.9%
distribute-rgt-out--99.9%
Simplified99.9%
Final simplification87.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ (- y z) (- a z)))))
(if (<= a -2.2e+158)
(+ x (* t (/ y a)))
(if (<= a -9.5e+108)
t_1
(if (<= a -0.001633)
(- x (/ (* x y) a))
(if (<= a -1.1e-298)
t_1
(if (<= a 8.2e+108)
(* y (/ (- t x) (- a z)))
(+ x (* y (/ t a))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double tmp;
if (a <= -2.2e+158) {
tmp = x + (t * (y / a));
} else if (a <= -9.5e+108) {
tmp = t_1;
} else if (a <= -0.001633) {
tmp = x - ((x * y) / a);
} else if (a <= -1.1e-298) {
tmp = t_1;
} else if (a <= 8.2e+108) {
tmp = y * ((t - x) / (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) :: t_1
real(8) :: tmp
t_1 = t * ((y - z) / (a - z))
if (a <= (-2.2d+158)) then
tmp = x + (t * (y / a))
else if (a <= (-9.5d+108)) then
tmp = t_1
else if (a <= (-0.001633d0)) then
tmp = x - ((x * y) / a)
else if (a <= (-1.1d-298)) then
tmp = t_1
else if (a <= 8.2d+108) then
tmp = y * ((t - x) / (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 t_1 = t * ((y - z) / (a - z));
double tmp;
if (a <= -2.2e+158) {
tmp = x + (t * (y / a));
} else if (a <= -9.5e+108) {
tmp = t_1;
} else if (a <= -0.001633) {
tmp = x - ((x * y) / a);
} else if (a <= -1.1e-298) {
tmp = t_1;
} else if (a <= 8.2e+108) {
tmp = y * ((t - x) / (a - z));
} else {
tmp = x + (y * (t / a));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * ((y - z) / (a - z)) tmp = 0 if a <= -2.2e+158: tmp = x + (t * (y / a)) elif a <= -9.5e+108: tmp = t_1 elif a <= -0.001633: tmp = x - ((x * y) / a) elif a <= -1.1e-298: tmp = t_1 elif a <= 8.2e+108: tmp = y * ((t - x) / (a - z)) else: tmp = x + (y * (t / a)) return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(Float64(y - z) / Float64(a - z))) tmp = 0.0 if (a <= -2.2e+158) tmp = Float64(x + Float64(t * Float64(y / a))); elseif (a <= -9.5e+108) tmp = t_1; elseif (a <= -0.001633) tmp = Float64(x - Float64(Float64(x * y) / a)); elseif (a <= -1.1e-298) tmp = t_1; elseif (a <= 8.2e+108) tmp = Float64(y * Float64(Float64(t - x) / 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) t_1 = t * ((y - z) / (a - z)); tmp = 0.0; if (a <= -2.2e+158) tmp = x + (t * (y / a)); elseif (a <= -9.5e+108) tmp = t_1; elseif (a <= -0.001633) tmp = x - ((x * y) / a); elseif (a <= -1.1e-298) tmp = t_1; elseif (a <= 8.2e+108) tmp = y * ((t - x) / (a - z)); else tmp = x + (y * (t / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -2.2e+158], N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -9.5e+108], t$95$1, If[LessEqual[a, -0.001633], N[(x - N[(N[(x * y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -1.1e-298], t$95$1, If[LessEqual[a, 8.2e+108], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(y * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y - z}{a - z}\\
\mathbf{if}\;a \leq -2.2 \cdot 10^{+158}:\\
\;\;\;\;x + t \cdot \frac{y}{a}\\
\mathbf{elif}\;a \leq -9.5 \cdot 10^{+108}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq -0.001633:\\
\;\;\;\;x - \frac{x \cdot y}{a}\\
\mathbf{elif}\;a \leq -1.1 \cdot 10^{-298}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 8.2 \cdot 10^{+108}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{else}:\\
\;\;\;\;x + y \cdot \frac{t}{a}\\
\end{array}
\end{array}
if a < -2.2000000000000001e158Initial program 64.8%
associate-/l*96.2%
Simplified96.2%
Taylor expanded in t around inf 74.1%
associate-/l*91.4%
Simplified91.4%
Taylor expanded in z around 0 71.1%
associate-/l*88.4%
Simplified88.4%
if -2.2000000000000001e158 < a < -9.50000000000000097e108 or -0.0016329999999999999 < a < -1.1e-298Initial program 63.9%
associate-/l*74.4%
Simplified74.4%
Taylor expanded in y around 0 58.0%
mul-1-neg58.0%
associate-/l*72.7%
distribute-lft-neg-out72.7%
+-commutative72.7%
div-sub72.7%
distribute-rgt-out74.4%
sub-neg74.4%
associate-/r/77.3%
Simplified77.3%
clear-num77.3%
associate-/r*63.9%
add-cube-cbrt63.1%
pow363.1%
+-commutative63.1%
associate-/r*76.3%
clear-num76.3%
div-inv76.3%
clear-num76.3%
fma-define76.3%
Applied egg-rr76.3%
Taylor expanded in t around inf 71.6%
div-sub71.6%
Simplified71.6%
if -9.50000000000000097e108 < a < -0.0016329999999999999Initial program 72.8%
associate-/l*72.9%
Simplified72.9%
Taylor expanded in z around 0 65.3%
Taylor expanded in t around 0 64.9%
neg-mul-164.9%
Simplified64.9%
if -1.1e-298 < a < 8.1999999999999998e108Initial program 64.2%
associate-/l*74.3%
Simplified74.3%
Taylor expanded in y around 0 63.7%
mul-1-neg63.7%
associate-/l*70.7%
distribute-lft-neg-out70.7%
+-commutative70.7%
div-sub70.7%
distribute-rgt-out74.3%
sub-neg74.3%
associate-/r/76.0%
Simplified76.0%
clear-num75.9%
associate-/r*64.1%
add-cube-cbrt63.5%
pow363.5%
+-commutative63.5%
associate-/r*75.1%
clear-num75.1%
div-inv74.4%
clear-num74.5%
fma-define74.5%
Applied egg-rr74.5%
Taylor expanded in y around inf 57.9%
div-sub57.9%
Simplified57.9%
if 8.1999999999999998e108 < a Initial program 68.9%
associate-/l*92.6%
Simplified92.6%
Taylor expanded in z around 0 59.0%
Taylor expanded in t around inf 61.1%
*-commutative61.1%
*-lft-identity61.1%
times-frac71.5%
/-rgt-identity71.5%
Simplified71.5%
Final simplification68.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ (- y z) (- a z)))))
(if (<= a -1.45e+158)
(+ x (* t (/ y a)))
(if (<= a -9.2e+108)
t_1
(if (<= a -0.001633)
(- x (/ (* x y) a))
(if (<= a 5e+75) t_1 (+ x (* y (/ t a)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double tmp;
if (a <= -1.45e+158) {
tmp = x + (t * (y / a));
} else if (a <= -9.2e+108) {
tmp = t_1;
} else if (a <= -0.001633) {
tmp = x - ((x * y) / a);
} else if (a <= 5e+75) {
tmp = t_1;
} 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) :: t_1
real(8) :: tmp
t_1 = t * ((y - z) / (a - z))
if (a <= (-1.45d+158)) then
tmp = x + (t * (y / a))
else if (a <= (-9.2d+108)) then
tmp = t_1
else if (a <= (-0.001633d0)) then
tmp = x - ((x * y) / a)
else if (a <= 5d+75) then
tmp = t_1
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 t_1 = t * ((y - z) / (a - z));
double tmp;
if (a <= -1.45e+158) {
tmp = x + (t * (y / a));
} else if (a <= -9.2e+108) {
tmp = t_1;
} else if (a <= -0.001633) {
tmp = x - ((x * y) / a);
} else if (a <= 5e+75) {
tmp = t_1;
} else {
tmp = x + (y * (t / a));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * ((y - z) / (a - z)) tmp = 0 if a <= -1.45e+158: tmp = x + (t * (y / a)) elif a <= -9.2e+108: tmp = t_1 elif a <= -0.001633: tmp = x - ((x * y) / a) elif a <= 5e+75: tmp = t_1 else: tmp = x + (y * (t / a)) return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(Float64(y - z) / Float64(a - z))) tmp = 0.0 if (a <= -1.45e+158) tmp = Float64(x + Float64(t * Float64(y / a))); elseif (a <= -9.2e+108) tmp = t_1; elseif (a <= -0.001633) tmp = Float64(x - Float64(Float64(x * y) / a)); elseif (a <= 5e+75) tmp = t_1; else tmp = Float64(x + Float64(y * Float64(t / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * ((y - z) / (a - z)); tmp = 0.0; if (a <= -1.45e+158) tmp = x + (t * (y / a)); elseif (a <= -9.2e+108) tmp = t_1; elseif (a <= -0.001633) tmp = x - ((x * y) / a); elseif (a <= 5e+75) tmp = t_1; else tmp = x + (y * (t / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.45e+158], N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -9.2e+108], t$95$1, If[LessEqual[a, -0.001633], N[(x - N[(N[(x * y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 5e+75], t$95$1, N[(x + N[(y * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y - z}{a - z}\\
\mathbf{if}\;a \leq -1.45 \cdot 10^{+158}:\\
\;\;\;\;x + t \cdot \frac{y}{a}\\
\mathbf{elif}\;a \leq -9.2 \cdot 10^{+108}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq -0.001633:\\
\;\;\;\;x - \frac{x \cdot y}{a}\\
\mathbf{elif}\;a \leq 5 \cdot 10^{+75}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x + y \cdot \frac{t}{a}\\
\end{array}
\end{array}
if a < -1.45000000000000012e158Initial program 64.8%
associate-/l*96.2%
Simplified96.2%
Taylor expanded in t around inf 74.1%
associate-/l*91.4%
Simplified91.4%
Taylor expanded in z around 0 71.1%
associate-/l*88.4%
Simplified88.4%
if -1.45000000000000012e158 < a < -9.1999999999999996e108 or -0.0016329999999999999 < a < 5.0000000000000002e75Initial program 63.4%
associate-/l*73.6%
Simplified73.6%
Taylor expanded in y around 0 60.5%
mul-1-neg60.5%
associate-/l*70.7%
distribute-lft-neg-out70.7%
+-commutative70.7%
div-sub70.7%
distribute-rgt-out73.6%
sub-neg73.6%
associate-/r/76.0%
Simplified76.0%
clear-num75.9%
associate-/r*63.3%
add-cube-cbrt62.7%
pow362.7%
+-commutative62.7%
associate-/r*75.0%
clear-num75.0%
div-inv74.6%
clear-num74.6%
fma-define74.6%
Applied egg-rr74.6%
Taylor expanded in t around inf 59.2%
div-sub59.2%
Simplified59.2%
if -9.1999999999999996e108 < a < -0.0016329999999999999Initial program 72.8%
associate-/l*72.9%
Simplified72.9%
Taylor expanded in z around 0 65.3%
Taylor expanded in t around 0 64.9%
neg-mul-164.9%
Simplified64.9%
if 5.0000000000000002e75 < a Initial program 70.2%
associate-/l*91.8%
Simplified91.8%
Taylor expanded in z around 0 59.7%
Taylor expanded in t around inf 58.2%
*-commutative58.2%
*-lft-identity58.2%
times-frac66.9%
/-rgt-identity66.9%
Simplified66.9%
Final simplification65.0%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -2.15e+82) (not (<= z 2.55e+79))) (- t (* y (/ (- t x) z))) (+ x (/ (- t x) (/ (- a z) y)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -2.15e+82) || !(z <= 2.55e+79)) {
tmp = t - (y * ((t - x) / z));
} else {
tmp = x + ((t - x) / ((a - z) / y));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((z <= (-2.15d+82)) .or. (.not. (z <= 2.55d+79))) then
tmp = t - (y * ((t - x) / z))
else
tmp = x + ((t - x) / ((a - z) / y))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -2.15e+82) || !(z <= 2.55e+79)) {
tmp = t - (y * ((t - x) / z));
} else {
tmp = x + ((t - x) / ((a - z) / y));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -2.15e+82) or not (z <= 2.55e+79): tmp = t - (y * ((t - x) / z)) else: tmp = x + ((t - x) / ((a - z) / y)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -2.15e+82) || !(z <= 2.55e+79)) tmp = Float64(t - Float64(y * Float64(Float64(t - x) / z))); else tmp = Float64(x + Float64(Float64(t - x) / Float64(Float64(a - z) / y))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -2.15e+82) || ~((z <= 2.55e+79))) tmp = t - (y * ((t - x) / z)); else tmp = x + ((t - x) / ((a - z) / y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -2.15e+82], N[Not[LessEqual[z, 2.55e+79]], $MachinePrecision]], N[(t - N[(y * N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(t - x), $MachinePrecision] / N[(N[(a - z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.15 \cdot 10^{+82} \lor \neg \left(z \leq 2.55 \cdot 10^{+79}\right):\\
\;\;\;\;t - y \cdot \frac{t - x}{z}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{t - x}{\frac{a - z}{y}}\\
\end{array}
\end{array}
if z < -2.15000000000000007e82 or 2.5500000000000001e79 < z Initial program 26.2%
+-commutative26.2%
*-commutative26.2%
associate-/l*59.7%
fma-define59.8%
Simplified59.8%
Taylor expanded in z around inf 60.6%
associate--l+60.6%
associate-*r/60.6%
associate-*r/60.6%
mul-1-neg60.6%
div-sub60.6%
mul-1-neg60.6%
distribute-lft-out--60.6%
associate-*r/60.6%
mul-1-neg60.6%
unsub-neg60.6%
distribute-rgt-out--63.3%
Simplified63.3%
Taylor expanded in y around inf 61.2%
associate-/l*72.7%
Simplified72.7%
if -2.15000000000000007e82 < z < 2.5500000000000001e79Initial program 84.8%
associate-/l*91.2%
Simplified91.2%
Taylor expanded in y around 0 88.3%
mul-1-neg88.3%
associate-/l*88.7%
distribute-lft-neg-out88.7%
+-commutative88.7%
div-sub88.7%
distribute-rgt-out91.2%
sub-neg91.2%
associate-/r/92.6%
Simplified92.6%
Taylor expanded in y around inf 84.7%
Final simplification80.8%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -1.48e+82) (not (<= z 2.15e+79))) (- t (* y (/ (- t x) z))) (+ x (* y (/ (- t x) (- a z))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -1.48e+82) || !(z <= 2.15e+79)) {
tmp = t - (y * ((t - x) / z));
} else {
tmp = x + (y * ((t - x) / (a - z)));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((z <= (-1.48d+82)) .or. (.not. (z <= 2.15d+79))) then
tmp = t - (y * ((t - x) / z))
else
tmp = x + (y * ((t - x) / (a - z)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -1.48e+82) || !(z <= 2.15e+79)) {
tmp = t - (y * ((t - x) / z));
} else {
tmp = x + (y * ((t - x) / (a - z)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -1.48e+82) or not (z <= 2.15e+79): tmp = t - (y * ((t - x) / z)) else: tmp = x + (y * ((t - x) / (a - z))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -1.48e+82) || !(z <= 2.15e+79)) tmp = Float64(t - Float64(y * Float64(Float64(t - x) / z))); else tmp = Float64(x + Float64(y * Float64(Float64(t - x) / Float64(a - z)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -1.48e+82) || ~((z <= 2.15e+79))) tmp = t - (y * ((t - x) / z)); else tmp = x + (y * ((t - x) / (a - z))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -1.48e+82], N[Not[LessEqual[z, 2.15e+79]], $MachinePrecision]], N[(t - N[(y * N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.48 \cdot 10^{+82} \lor \neg \left(z \leq 2.15 \cdot 10^{+79}\right):\\
\;\;\;\;t - y \cdot \frac{t - x}{z}\\
\mathbf{else}:\\
\;\;\;\;x + y \cdot \frac{t - x}{a - z}\\
\end{array}
\end{array}
if z < -1.48e82 or 2.1500000000000002e79 < z Initial program 26.2%
+-commutative26.2%
*-commutative26.2%
associate-/l*59.7%
fma-define59.8%
Simplified59.8%
Taylor expanded in z around inf 60.6%
associate--l+60.6%
associate-*r/60.6%
associate-*r/60.6%
mul-1-neg60.6%
div-sub60.6%
mul-1-neg60.6%
distribute-lft-out--60.6%
associate-*r/60.6%
mul-1-neg60.6%
unsub-neg60.6%
distribute-rgt-out--63.3%
Simplified63.3%
Taylor expanded in y around inf 61.2%
associate-/l*72.7%
Simplified72.7%
if -1.48e82 < z < 2.1500000000000002e79Initial program 84.8%
associate-/l*91.2%
Simplified91.2%
Taylor expanded in y around inf 78.1%
associate-*r/83.8%
Simplified83.8%
Final simplification80.2%
(FPCore (x y z t a) :precision binary64 (if (or (<= a -7e-67) (not (<= a 4.4e-40))) (+ x (* t (/ (- y z) (- a z)))) (- t (* y (/ (- t x) z)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -7e-67) || !(a <= 4.4e-40)) {
tmp = x + (t * ((y - z) / (a - z)));
} else {
tmp = t - (y * ((t - x) / z));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((a <= (-7d-67)) .or. (.not. (a <= 4.4d-40))) then
tmp = x + (t * ((y - z) / (a - z)))
else
tmp = t - (y * ((t - x) / z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -7e-67) || !(a <= 4.4e-40)) {
tmp = x + (t * ((y - z) / (a - z)));
} else {
tmp = t - (y * ((t - x) / z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (a <= -7e-67) or not (a <= 4.4e-40): tmp = x + (t * ((y - z) / (a - z))) else: tmp = t - (y * ((t - x) / z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((a <= -7e-67) || !(a <= 4.4e-40)) tmp = Float64(x + Float64(t * Float64(Float64(y - z) / Float64(a - z)))); else tmp = Float64(t - Float64(y * Float64(Float64(t - x) / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((a <= -7e-67) || ~((a <= 4.4e-40))) tmp = x + (t * ((y - z) / (a - z))); else tmp = t - (y * ((t - x) / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[a, -7e-67], N[Not[LessEqual[a, 4.4e-40]], $MachinePrecision]], N[(x + N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t - N[(y * N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -7 \cdot 10^{-67} \lor \neg \left(a \leq 4.4 \cdot 10^{-40}\right):\\
\;\;\;\;x + t \cdot \frac{y - z}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t - y \cdot \frac{t - x}{z}\\
\end{array}
\end{array}
if a < -7.0000000000000001e-67 or 4.40000000000000018e-40 < a Initial program 68.0%
associate-/l*86.2%
Simplified86.2%
Taylor expanded in t around inf 60.9%
associate-/l*73.9%
Simplified73.9%
if -7.0000000000000001e-67 < a < 4.40000000000000018e-40Initial program 62.7%
+-commutative62.7%
*-commutative62.7%
associate-/l*72.8%
fma-define72.8%
Simplified72.8%
Taylor expanded in z around inf 73.9%
associate--l+73.9%
associate-*r/73.9%
associate-*r/73.9%
mul-1-neg73.9%
div-sub73.9%
mul-1-neg73.9%
distribute-lft-out--73.9%
associate-*r/73.9%
mul-1-neg73.9%
unsub-neg73.9%
distribute-rgt-out--73.9%
Simplified73.9%
Taylor expanded in y around inf 71.4%
associate-/l*75.8%
Simplified75.8%
Final simplification74.7%
(FPCore (x y z t a) :precision binary64 (if (<= a -7e-67) x (if (<= a -1.75e-298) t (if (<= a 5.2e-57) (* x (/ y z)) x))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -7e-67) {
tmp = x;
} else if (a <= -1.75e-298) {
tmp = t;
} else if (a <= 5.2e-57) {
tmp = x * (y / z);
} 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) :: tmp
if (a <= (-7d-67)) then
tmp = x
else if (a <= (-1.75d-298)) then
tmp = t
else if (a <= 5.2d-57) then
tmp = x * (y / z)
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -7e-67) {
tmp = x;
} else if (a <= -1.75e-298) {
tmp = t;
} else if (a <= 5.2e-57) {
tmp = x * (y / z);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -7e-67: tmp = x elif a <= -1.75e-298: tmp = t elif a <= 5.2e-57: tmp = x * (y / z) else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -7e-67) tmp = x; elseif (a <= -1.75e-298) tmp = t; elseif (a <= 5.2e-57) tmp = Float64(x * Float64(y / z)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -7e-67) tmp = x; elseif (a <= -1.75e-298) tmp = t; elseif (a <= 5.2e-57) tmp = x * (y / z); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -7e-67], x, If[LessEqual[a, -1.75e-298], t, If[LessEqual[a, 5.2e-57], N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision], x]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -7 \cdot 10^{-67}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -1.75 \cdot 10^{-298}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq 5.2 \cdot 10^{-57}:\\
\;\;\;\;x \cdot \frac{y}{z}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -7.0000000000000001e-67 or 5.19999999999999971e-57 < a Initial program 67.4%
+-commutative67.4%
*-commutative67.4%
associate-/l*87.5%
fma-define87.6%
Simplified87.6%
Taylor expanded in a around inf 41.1%
if -7.0000000000000001e-67 < a < -1.7499999999999999e-298Initial program 63.6%
associate-/l*69.1%
Simplified69.1%
Taylor expanded in y around 0 54.7%
mul-1-neg54.7%
associate-/l*66.6%
distribute-lft-neg-out66.6%
+-commutative66.6%
div-sub66.6%
distribute-rgt-out69.1%
sub-neg69.1%
associate-/r/71.6%
Simplified71.6%
clear-num71.6%
associate-/r*63.5%
add-cube-cbrt62.9%
pow362.9%
+-commutative62.9%
associate-/r*70.9%
clear-num70.8%
div-inv70.8%
clear-num70.8%
fma-define70.7%
Applied egg-rr70.7%
Taylor expanded in z around inf 49.2%
if -1.7499999999999999e-298 < a < 5.19999999999999971e-57Initial program 63.1%
+-commutative63.1%
*-commutative63.1%
associate-/l*74.2%
fma-define74.2%
Simplified74.2%
Taylor expanded in z around inf 75.8%
associate--l+75.8%
associate-*r/75.8%
associate-*r/75.8%
mul-1-neg75.8%
div-sub75.8%
mul-1-neg75.8%
distribute-lft-out--75.8%
associate-*r/75.8%
mul-1-neg75.8%
unsub-neg75.8%
distribute-rgt-out--75.8%
Simplified75.8%
Taylor expanded in t around 0 42.3%
associate-/l*46.6%
Simplified46.6%
Taylor expanded in y around inf 39.0%
associate-/l*43.3%
Simplified43.3%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -5.3e-20) (not (<= z 1.6e+16))) (* t (/ (- y z) (- a z))) (+ x (/ (- t x) (/ a y)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -5.3e-20) || !(z <= 1.6e+16)) {
tmp = t * ((y - z) / (a - z));
} else {
tmp = x + ((t - x) / (a / y));
}
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.3d-20)) .or. (.not. (z <= 1.6d+16))) then
tmp = t * ((y - z) / (a - z))
else
tmp = x + ((t - x) / (a / y))
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.3e-20) || !(z <= 1.6e+16)) {
tmp = t * ((y - z) / (a - z));
} else {
tmp = x + ((t - x) / (a / y));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -5.3e-20) or not (z <= 1.6e+16): tmp = t * ((y - z) / (a - z)) else: tmp = x + ((t - x) / (a / y)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -5.3e-20) || !(z <= 1.6e+16)) tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z))); else tmp = Float64(x + Float64(Float64(t - x) / Float64(a / y))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -5.3e-20) || ~((z <= 1.6e+16))) tmp = t * ((y - z) / (a - z)); else tmp = x + ((t - x) / (a / y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -5.3e-20], N[Not[LessEqual[z, 1.6e+16]], $MachinePrecision]], N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(t - x), $MachinePrecision] / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -5.3 \cdot 10^{-20} \lor \neg \left(z \leq 1.6 \cdot 10^{+16}\right):\\
\;\;\;\;t \cdot \frac{y - z}{a - z}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{t - x}{\frac{a}{y}}\\
\end{array}
\end{array}
if z < -5.3000000000000002e-20 or 1.6e16 < z Initial program 40.8%
associate-/l*67.1%
Simplified67.1%
Taylor expanded in y around 0 44.3%
mul-1-neg44.3%
associate-/l*67.1%
distribute-lft-neg-out67.1%
+-commutative67.1%
div-sub67.1%
distribute-rgt-out67.1%
sub-neg67.1%
associate-/r/69.5%
Simplified69.5%
clear-num69.4%
associate-/r*40.7%
add-cube-cbrt40.3%
pow340.3%
+-commutative40.3%
associate-/r*68.5%
clear-num68.4%
div-inv68.4%
clear-num68.4%
fma-define68.4%
Applied egg-rr68.4%
Taylor expanded in t around inf 59.7%
div-sub59.7%
Simplified59.7%
if -5.3000000000000002e-20 < z < 1.6e16Initial program 88.9%
associate-/l*91.6%
Simplified91.6%
Taylor expanded in y around 0 90.8%
mul-1-neg90.8%
associate-/l*88.4%
distribute-lft-neg-out88.4%
+-commutative88.4%
div-sub88.4%
distribute-rgt-out91.6%
sub-neg91.6%
associate-/r/93.4%
Simplified93.4%
Taylor expanded in z around 0 76.0%
Final simplification68.2%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -2.1e-20) (not (<= z 2.5e+16))) (* t (/ (- y z) (- a z))) (+ x (* y (/ (- t x) a)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -2.1e-20) || !(z <= 2.5e+16)) {
tmp = t * ((y - z) / (a - z));
} else {
tmp = x + (y * ((t - x) / 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 ((z <= (-2.1d-20)) .or. (.not. (z <= 2.5d+16))) then
tmp = t * ((y - z) / (a - z))
else
tmp = x + (y * ((t - x) / a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -2.1e-20) || !(z <= 2.5e+16)) {
tmp = t * ((y - z) / (a - z));
} else {
tmp = x + (y * ((t - x) / a));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -2.1e-20) or not (z <= 2.5e+16): tmp = t * ((y - z) / (a - z)) else: tmp = x + (y * ((t - x) / a)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -2.1e-20) || !(z <= 2.5e+16)) tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z))); else tmp = Float64(x + Float64(y * Float64(Float64(t - x) / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -2.1e-20) || ~((z <= 2.5e+16))) tmp = t * ((y - z) / (a - z)); else tmp = x + (y * ((t - x) / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -2.1e-20], N[Not[LessEqual[z, 2.5e+16]], $MachinePrecision]], N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.1 \cdot 10^{-20} \lor \neg \left(z \leq 2.5 \cdot 10^{+16}\right):\\
\;\;\;\;t \cdot \frac{y - z}{a - z}\\
\mathbf{else}:\\
\;\;\;\;x + y \cdot \frac{t - x}{a}\\
\end{array}
\end{array}
if z < -2.0999999999999999e-20 or 2.5e16 < z Initial program 40.8%
associate-/l*67.1%
Simplified67.1%
Taylor expanded in y around 0 44.3%
mul-1-neg44.3%
associate-/l*67.1%
distribute-lft-neg-out67.1%
+-commutative67.1%
div-sub67.1%
distribute-rgt-out67.1%
sub-neg67.1%
associate-/r/69.5%
Simplified69.5%
clear-num69.4%
associate-/r*40.7%
add-cube-cbrt40.3%
pow340.3%
+-commutative40.3%
associate-/r*68.5%
clear-num68.4%
div-inv68.4%
clear-num68.4%
fma-define68.4%
Applied egg-rr68.4%
Taylor expanded in t around inf 59.7%
div-sub59.7%
Simplified59.7%
if -2.0999999999999999e-20 < z < 2.5e16Initial program 88.9%
associate-/l*91.6%
Simplified91.6%
Taylor expanded in z around 0 72.1%
associate-/l*75.6%
Simplified75.6%
Final simplification68.0%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -5.3e-20) (not (<= z 3e+16))) (* t (/ (- y z) (- a z))) (+ x (* t (/ y (- a z))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -5.3e-20) || !(z <= 3e+16)) {
tmp = t * ((y - z) / (a - z));
} else {
tmp = x + (t * (y / (a - z)));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((z <= (-5.3d-20)) .or. (.not. (z <= 3d+16))) then
tmp = t * ((y - z) / (a - z))
else
tmp = x + (t * (y / (a - z)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -5.3e-20) || !(z <= 3e+16)) {
tmp = t * ((y - z) / (a - z));
} else {
tmp = x + (t * (y / (a - z)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -5.3e-20) or not (z <= 3e+16): tmp = t * ((y - z) / (a - z)) else: tmp = x + (t * (y / (a - z))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -5.3e-20) || !(z <= 3e+16)) tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z))); else tmp = Float64(x + Float64(t * Float64(y / Float64(a - z)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -5.3e-20) || ~((z <= 3e+16))) tmp = t * ((y - z) / (a - z)); else tmp = x + (t * (y / (a - z))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -5.3e-20], N[Not[LessEqual[z, 3e+16]], $MachinePrecision]], N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -5.3 \cdot 10^{-20} \lor \neg \left(z \leq 3 \cdot 10^{+16}\right):\\
\;\;\;\;t \cdot \frac{y - z}{a - z}\\
\mathbf{else}:\\
\;\;\;\;x + t \cdot \frac{y}{a - z}\\
\end{array}
\end{array}
if z < -5.3000000000000002e-20 or 3e16 < z Initial program 40.8%
associate-/l*67.1%
Simplified67.1%
Taylor expanded in y around 0 44.3%
mul-1-neg44.3%
associate-/l*67.1%
distribute-lft-neg-out67.1%
+-commutative67.1%
div-sub67.1%
distribute-rgt-out67.1%
sub-neg67.1%
associate-/r/69.5%
Simplified69.5%
clear-num69.4%
associate-/r*40.7%
add-cube-cbrt40.3%
pow340.3%
+-commutative40.3%
associate-/r*68.5%
clear-num68.4%
div-inv68.4%
clear-num68.4%
fma-define68.4%
Applied egg-rr68.4%
Taylor expanded in t around inf 59.7%
div-sub59.7%
Simplified59.7%
if -5.3000000000000002e-20 < z < 3e16Initial program 88.9%
associate-/l*91.6%
Simplified91.6%
Taylor expanded in t around inf 67.7%
associate-/l*71.5%
Simplified71.5%
Taylor expanded in y around inf 65.5%
associate-/l*69.4%
Simplified69.4%
Final simplification64.7%
(FPCore (x y z t a) :precision binary64 (if (<= a -0.001633) (+ x (/ (- t x) (/ a y))) (if (<= a 1.02e-53) (- t (* y (/ (- t x) z))) (+ x (* y (/ (- t x) a))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -0.001633) {
tmp = x + ((t - x) / (a / y));
} else if (a <= 1.02e-53) {
tmp = t - (y * ((t - x) / z));
} else {
tmp = x + (y * ((t - x) / 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 <= (-0.001633d0)) then
tmp = x + ((t - x) / (a / y))
else if (a <= 1.02d-53) then
tmp = t - (y * ((t - x) / z))
else
tmp = x + (y * ((t - x) / 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 <= -0.001633) {
tmp = x + ((t - x) / (a / y));
} else if (a <= 1.02e-53) {
tmp = t - (y * ((t - x) / z));
} else {
tmp = x + (y * ((t - x) / a));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -0.001633: tmp = x + ((t - x) / (a / y)) elif a <= 1.02e-53: tmp = t - (y * ((t - x) / z)) else: tmp = x + (y * ((t - x) / a)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -0.001633) tmp = Float64(x + Float64(Float64(t - x) / Float64(a / y))); elseif (a <= 1.02e-53) tmp = Float64(t - Float64(y * Float64(Float64(t - x) / z))); else tmp = Float64(x + Float64(y * Float64(Float64(t - x) / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -0.001633) tmp = x + ((t - x) / (a / y)); elseif (a <= 1.02e-53) tmp = t - (y * ((t - x) / z)); else tmp = x + (y * ((t - x) / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -0.001633], N[(x + N[(N[(t - x), $MachinePrecision] / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.02e-53], N[(t - N[(y * N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -0.001633:\\
\;\;\;\;x + \frac{t - x}{\frac{a}{y}}\\
\mathbf{elif}\;a \leq 1.02 \cdot 10^{-53}:\\
\;\;\;\;t - y \cdot \frac{t - x}{z}\\
\mathbf{else}:\\
\;\;\;\;x + y \cdot \frac{t - x}{a}\\
\end{array}
\end{array}
if a < -0.0016329999999999999Initial program 63.6%
associate-/l*84.9%
Simplified84.9%
Taylor expanded in y around 0 72.5%
mul-1-neg72.5%
associate-/l*84.9%
distribute-lft-neg-out84.9%
+-commutative84.9%
div-sub84.9%
distribute-rgt-out84.9%
sub-neg84.9%
associate-/r/89.0%
Simplified89.0%
Taylor expanded in z around 0 73.8%
if -0.0016329999999999999 < a < 1.02000000000000002e-53Initial program 65.9%
+-commutative65.9%
*-commutative65.9%
associate-/l*75.0%
fma-define75.0%
Simplified75.0%
Taylor expanded in z around inf 71.9%
associate--l+71.9%
associate-*r/71.9%
associate-*r/71.9%
mul-1-neg71.9%
div-sub72.7%
mul-1-neg72.7%
distribute-lft-out--72.7%
associate-*r/72.7%
mul-1-neg72.7%
unsub-neg72.7%
distribute-rgt-out--72.7%
Simplified72.7%
Taylor expanded in y around inf 70.7%
associate-/l*75.6%
Simplified75.6%
if 1.02000000000000002e-53 < a Initial program 67.7%
associate-/l*85.5%
Simplified85.5%
Taylor expanded in z around 0 56.0%
associate-/l*66.1%
Simplified66.1%
(FPCore (x y z t a) :precision binary64 (if (<= z -1.48e+82) (- t (/ (* x a) z)) (if (<= z 3.3e+99) (+ x (* t (/ y a))) (/ x (/ z (- y a))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.48e+82) {
tmp = t - ((x * a) / z);
} else if (z <= 3.3e+99) {
tmp = x + (t * (y / a));
} else {
tmp = x / (z / (y - 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 (z <= (-1.48d+82)) then
tmp = t - ((x * a) / z)
else if (z <= 3.3d+99) then
tmp = x + (t * (y / a))
else
tmp = x / (z / (y - a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.48e+82) {
tmp = t - ((x * a) / z);
} else if (z <= 3.3e+99) {
tmp = x + (t * (y / a));
} else {
tmp = x / (z / (y - a));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1.48e+82: tmp = t - ((x * a) / z) elif z <= 3.3e+99: tmp = x + (t * (y / a)) else: tmp = x / (z / (y - a)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.48e+82) tmp = Float64(t - Float64(Float64(x * a) / z)); elseif (z <= 3.3e+99) tmp = Float64(x + Float64(t * Float64(y / a))); else tmp = Float64(x / Float64(z / Float64(y - a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1.48e+82) tmp = t - ((x * a) / z); elseif (z <= 3.3e+99) tmp = x + (t * (y / a)); else tmp = x / (z / (y - a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.48e+82], N[(t - N[(N[(x * a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.3e+99], N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.48 \cdot 10^{+82}:\\
\;\;\;\;t - \frac{x \cdot a}{z}\\
\mathbf{elif}\;z \leq 3.3 \cdot 10^{+99}:\\
\;\;\;\;x + t \cdot \frac{y}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\frac{z}{y - a}}\\
\end{array}
\end{array}
if z < -1.48e82Initial program 17.8%
+-commutative17.8%
*-commutative17.8%
associate-/l*57.4%
fma-define57.4%
Simplified57.4%
Taylor expanded in z around inf 66.6%
associate--l+66.6%
associate-*r/66.6%
associate-*r/66.6%
mul-1-neg66.6%
div-sub66.6%
mul-1-neg66.6%
distribute-lft-out--66.6%
associate-*r/66.6%
mul-1-neg66.6%
unsub-neg66.6%
distribute-rgt-out--66.9%
Simplified66.9%
Taylor expanded in y around 0 57.9%
neg-mul-157.9%
Simplified57.9%
Taylor expanded in t around 0 64.9%
*-commutative64.9%
Simplified64.9%
if -1.48e82 < z < 3.2999999999999999e99Initial program 85.0%
associate-/l*91.3%
Simplified91.3%
Taylor expanded in t around inf 65.2%
associate-/l*70.8%
Simplified70.8%
Taylor expanded in z around 0 50.4%
associate-/l*55.0%
Simplified55.0%
if 3.2999999999999999e99 < z Initial program 31.8%
+-commutative31.8%
*-commutative31.8%
associate-/l*60.2%
fma-define60.4%
Simplified60.4%
Taylor expanded in z around inf 51.8%
associate--l+51.8%
associate-*r/51.8%
associate-*r/51.8%
mul-1-neg51.8%
div-sub51.8%
mul-1-neg51.8%
distribute-lft-out--51.8%
associate-*r/51.8%
mul-1-neg51.8%
unsub-neg51.8%
distribute-rgt-out--57.3%
Simplified57.3%
Taylor expanded in t around 0 24.4%
associate-/l*43.1%
Simplified43.1%
clear-num43.1%
un-div-inv43.2%
Applied egg-rr43.2%
(FPCore (x y z t a) :precision binary64 (if (<= z -1.48e+82) (- t (/ (* x a) z)) (if (<= z 1.75e+97) (+ x (* t (/ y a))) (* x (/ (- y a) z)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.48e+82) {
tmp = t - ((x * a) / z);
} else if (z <= 1.75e+97) {
tmp = x + (t * (y / a));
} else {
tmp = x * ((y - a) / z);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-1.48d+82)) then
tmp = t - ((x * a) / z)
else if (z <= 1.75d+97) then
tmp = x + (t * (y / a))
else
tmp = x * ((y - a) / z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.48e+82) {
tmp = t - ((x * a) / z);
} else if (z <= 1.75e+97) {
tmp = x + (t * (y / a));
} else {
tmp = x * ((y - a) / z);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1.48e+82: tmp = t - ((x * a) / z) elif z <= 1.75e+97: tmp = x + (t * (y / a)) else: tmp = x * ((y - a) / z) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.48e+82) tmp = Float64(t - Float64(Float64(x * a) / z)); elseif (z <= 1.75e+97) tmp = Float64(x + Float64(t * Float64(y / a))); else tmp = Float64(x * Float64(Float64(y - a) / z)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1.48e+82) tmp = t - ((x * a) / z); elseif (z <= 1.75e+97) tmp = x + (t * (y / a)); else tmp = x * ((y - a) / z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.48e+82], N[(t - N[(N[(x * a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.75e+97], N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.48 \cdot 10^{+82}:\\
\;\;\;\;t - \frac{x \cdot a}{z}\\
\mathbf{elif}\;z \leq 1.75 \cdot 10^{+97}:\\
\;\;\;\;x + t \cdot \frac{y}{a}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\end{array}
\end{array}
if z < -1.48e82Initial program 17.8%
+-commutative17.8%
*-commutative17.8%
associate-/l*57.4%
fma-define57.4%
Simplified57.4%
Taylor expanded in z around inf 66.6%
associate--l+66.6%
associate-*r/66.6%
associate-*r/66.6%
mul-1-neg66.6%
div-sub66.6%
mul-1-neg66.6%
distribute-lft-out--66.6%
associate-*r/66.6%
mul-1-neg66.6%
unsub-neg66.6%
distribute-rgt-out--66.9%
Simplified66.9%
Taylor expanded in y around 0 57.9%
neg-mul-157.9%
Simplified57.9%
Taylor expanded in t around 0 64.9%
*-commutative64.9%
Simplified64.9%
if -1.48e82 < z < 1.75e97Initial program 85.0%
associate-/l*91.3%
Simplified91.3%
Taylor expanded in t around inf 65.2%
associate-/l*70.8%
Simplified70.8%
Taylor expanded in z around 0 50.4%
associate-/l*55.0%
Simplified55.0%
if 1.75e97 < z Initial program 31.8%
+-commutative31.8%
*-commutative31.8%
associate-/l*60.2%
fma-define60.4%
Simplified60.4%
Taylor expanded in z around inf 51.8%
associate--l+51.8%
associate-*r/51.8%
associate-*r/51.8%
mul-1-neg51.8%
div-sub51.8%
mul-1-neg51.8%
distribute-lft-out--51.8%
associate-*r/51.8%
mul-1-neg51.8%
unsub-neg51.8%
distribute-rgt-out--57.3%
Simplified57.3%
Taylor expanded in t around 0 24.4%
associate-/l*43.1%
Simplified43.1%
(FPCore (x y z t a) :precision binary64 (if (<= z -2.35e+82) t (if (<= z 8.4e+99) (+ x (* t (/ y a))) (* x (/ (- y a) z)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.35e+82) {
tmp = t;
} else if (z <= 8.4e+99) {
tmp = x + (t * (y / a));
} else {
tmp = x * ((y - a) / z);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-2.35d+82)) then
tmp = t
else if (z <= 8.4d+99) then
tmp = x + (t * (y / a))
else
tmp = x * ((y - a) / z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.35e+82) {
tmp = t;
} else if (z <= 8.4e+99) {
tmp = x + (t * (y / a));
} else {
tmp = x * ((y - a) / z);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.35e+82: tmp = t elif z <= 8.4e+99: tmp = x + (t * (y / a)) else: tmp = x * ((y - a) / z) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.35e+82) tmp = t; elseif (z <= 8.4e+99) tmp = Float64(x + Float64(t * Float64(y / a))); else tmp = Float64(x * Float64(Float64(y - a) / z)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.35e+82) tmp = t; elseif (z <= 8.4e+99) tmp = x + (t * (y / a)); else tmp = x * ((y - a) / z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.35e+82], t, If[LessEqual[z, 8.4e+99], N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.35 \cdot 10^{+82}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 8.4 \cdot 10^{+99}:\\
\;\;\;\;x + t \cdot \frac{y}{a}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\end{array}
\end{array}
if z < -2.35e82Initial program 17.8%
associate-/l*55.1%
Simplified55.1%
Taylor expanded in y around 0 22.1%
mul-1-neg22.1%
associate-/l*55.1%
distribute-lft-neg-out55.1%
+-commutative55.1%
div-sub55.1%
distribute-rgt-out55.1%
sub-neg55.1%
associate-/r/57.4%
Simplified57.4%
clear-num57.3%
associate-/r*17.7%
add-cube-cbrt17.4%
pow317.3%
+-commutative17.3%
associate-/r*56.2%
clear-num56.0%
div-inv56.0%
clear-num56.0%
fma-define56.0%
Applied egg-rr56.0%
Taylor expanded in z around inf 57.3%
if -2.35e82 < z < 8.40000000000000041e99Initial program 85.0%
associate-/l*91.3%
Simplified91.3%
Taylor expanded in t around inf 65.2%
associate-/l*70.8%
Simplified70.8%
Taylor expanded in z around 0 50.4%
associate-/l*55.0%
Simplified55.0%
if 8.40000000000000041e99 < z Initial program 31.8%
+-commutative31.8%
*-commutative31.8%
associate-/l*60.2%
fma-define60.4%
Simplified60.4%
Taylor expanded in z around inf 51.8%
associate--l+51.8%
associate-*r/51.8%
associate-*r/51.8%
mul-1-neg51.8%
div-sub51.8%
mul-1-neg51.8%
distribute-lft-out--51.8%
associate-*r/51.8%
mul-1-neg51.8%
unsub-neg51.8%
distribute-rgt-out--57.3%
Simplified57.3%
Taylor expanded in t around 0 24.4%
associate-/l*43.1%
Simplified43.1%
(FPCore (x y z t a) :precision binary64 (if (<= z -2.4e+82) t (if (<= z 8.2e+93) (* x (- 1.0 (/ y a))) (* x (/ (- y a) z)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.4e+82) {
tmp = t;
} else if (z <= 8.2e+93) {
tmp = x * (1.0 - (y / a));
} else {
tmp = x * ((y - a) / z);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-2.4d+82)) then
tmp = t
else if (z <= 8.2d+93) then
tmp = x * (1.0d0 - (y / a))
else
tmp = x * ((y - a) / z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.4e+82) {
tmp = t;
} else if (z <= 8.2e+93) {
tmp = x * (1.0 - (y / a));
} else {
tmp = x * ((y - a) / z);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.4e+82: tmp = t elif z <= 8.2e+93: tmp = x * (1.0 - (y / a)) else: tmp = x * ((y - a) / z) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.4e+82) tmp = t; elseif (z <= 8.2e+93) tmp = Float64(x * Float64(1.0 - Float64(y / a))); else tmp = Float64(x * Float64(Float64(y - a) / z)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.4e+82) tmp = t; elseif (z <= 8.2e+93) tmp = x * (1.0 - (y / a)); else tmp = x * ((y - a) / z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.4e+82], t, If[LessEqual[z, 8.2e+93], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.4 \cdot 10^{+82}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 8.2 \cdot 10^{+93}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\end{array}
\end{array}
if z < -2.39999999999999998e82Initial program 17.8%
associate-/l*55.1%
Simplified55.1%
Taylor expanded in y around 0 22.1%
mul-1-neg22.1%
associate-/l*55.1%
distribute-lft-neg-out55.1%
+-commutative55.1%
div-sub55.1%
distribute-rgt-out55.1%
sub-neg55.1%
associate-/r/57.4%
Simplified57.4%
clear-num57.3%
associate-/r*17.7%
add-cube-cbrt17.4%
pow317.3%
+-commutative17.3%
associate-/r*56.2%
clear-num56.0%
div-inv56.0%
clear-num56.0%
fma-define56.0%
Applied egg-rr56.0%
Taylor expanded in z around inf 57.3%
if -2.39999999999999998e82 < z < 8.2000000000000002e93Initial program 85.0%
associate-/l*91.3%
Simplified91.3%
Taylor expanded in z around 0 62.2%
Taylor expanded in x around inf 53.1%
mul-1-neg53.1%
unsub-neg53.1%
Simplified53.1%
if 8.2000000000000002e93 < z Initial program 31.8%
+-commutative31.8%
*-commutative31.8%
associate-/l*60.2%
fma-define60.4%
Simplified60.4%
Taylor expanded in z around inf 51.8%
associate--l+51.8%
associate-*r/51.8%
associate-*r/51.8%
mul-1-neg51.8%
div-sub51.8%
mul-1-neg51.8%
distribute-lft-out--51.8%
associate-*r/51.8%
mul-1-neg51.8%
unsub-neg51.8%
distribute-rgt-out--57.3%
Simplified57.3%
Taylor expanded in t around 0 24.4%
associate-/l*43.1%
Simplified43.1%
(FPCore (x y z t a) :precision binary64 (if (<= z -2.4e+82) t (if (<= z 1.4e+17) (* x (- 1.0 (/ y a))) t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.4e+82) {
tmp = t;
} else if (z <= 1.4e+17) {
tmp = x * (1.0 - (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 <= (-2.4d+82)) then
tmp = t
else if (z <= 1.4d+17) then
tmp = x * (1.0d0 - (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 <= -2.4e+82) {
tmp = t;
} else if (z <= 1.4e+17) {
tmp = x * (1.0 - (y / a));
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.4e+82: tmp = t elif z <= 1.4e+17: tmp = x * (1.0 - (y / a)) else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.4e+82) tmp = t; elseif (z <= 1.4e+17) tmp = Float64(x * Float64(1.0 - Float64(y / a))); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.4e+82) tmp = t; elseif (z <= 1.4e+17) tmp = x * (1.0 - (y / a)); else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.4e+82], t, If[LessEqual[z, 1.4e+17], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.4 \cdot 10^{+82}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 1.4 \cdot 10^{+17}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -2.39999999999999998e82 or 1.4e17 < z Initial program 33.2%
associate-/l*62.0%
Simplified62.0%
Taylor expanded in y around 0 34.8%
mul-1-neg34.8%
associate-/l*62.0%
distribute-lft-neg-out62.0%
+-commutative62.0%
div-sub62.0%
distribute-rgt-out62.0%
sub-neg62.0%
associate-/r/65.0%
Simplified65.0%
clear-num65.0%
associate-/r*33.1%
add-cube-cbrt32.7%
pow332.7%
+-commutative32.7%
associate-/r*64.0%
clear-num63.9%
div-inv63.9%
clear-num63.9%
fma-define64.0%
Applied egg-rr64.0%
Taylor expanded in z around inf 44.0%
if -2.39999999999999998e82 < z < 1.4e17Initial program 85.3%
associate-/l*90.6%
Simplified90.6%
Taylor expanded in z around 0 64.7%
Taylor expanded in x around inf 55.4%
mul-1-neg55.4%
unsub-neg55.4%
Simplified55.4%
(FPCore (x y z t a) :precision binary64 (if (<= z -1.95e+82) t (if (<= z 6.5e+16) x t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.95e+82) {
tmp = t;
} else if (z <= 6.5e+16) {
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 <= (-1.95d+82)) then
tmp = t
else if (z <= 6.5d+16) 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 <= -1.95e+82) {
tmp = t;
} else if (z <= 6.5e+16) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1.95e+82: tmp = t elif z <= 6.5e+16: tmp = x else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.95e+82) tmp = t; elseif (z <= 6.5e+16) tmp = x; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1.95e+82) tmp = t; elseif (z <= 6.5e+16) tmp = x; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.95e+82], t, If[LessEqual[z, 6.5e+16], x, t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.95 \cdot 10^{+82}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 6.5 \cdot 10^{+16}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -1.94999999999999988e82 or 6.5e16 < z Initial program 33.2%
associate-/l*62.0%
Simplified62.0%
Taylor expanded in y around 0 34.8%
mul-1-neg34.8%
associate-/l*62.0%
distribute-lft-neg-out62.0%
+-commutative62.0%
div-sub62.0%
distribute-rgt-out62.0%
sub-neg62.0%
associate-/r/65.0%
Simplified65.0%
clear-num65.0%
associate-/r*33.1%
add-cube-cbrt32.7%
pow332.7%
+-commutative32.7%
associate-/r*64.0%
clear-num63.9%
div-inv63.9%
clear-num63.9%
fma-define64.0%
Applied egg-rr64.0%
Taylor expanded in z around inf 44.0%
if -1.94999999999999988e82 < z < 6.5e16Initial program 85.3%
+-commutative85.3%
*-commutative85.3%
associate-/l*92.0%
fma-define92.0%
Simplified92.0%
Taylor expanded in a around inf 38.7%
(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 65.8%
associate-/l*79.8%
Simplified79.8%
Taylor expanded in y around 0 68.5%
mul-1-neg68.5%
associate-/l*78.2%
distribute-lft-neg-out78.2%
+-commutative78.2%
div-sub78.2%
distribute-rgt-out79.8%
sub-neg79.8%
associate-/r/81.9%
Simplified81.9%
clear-num81.9%
associate-/r*65.7%
add-cube-cbrt64.9%
pow364.9%
+-commutative64.9%
associate-/r*80.8%
clear-num80.7%
div-inv80.5%
clear-num80.7%
fma-define80.7%
Applied egg-rr80.7%
Taylor expanded in z around inf 21.7%
(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 2024170
(FPCore (x y z t a)
:name "Graphics.Rendering.Chart.Axis.Types:invLinMap from Chart-1.5.3"
:precision binary64
:alt
(! :herbie-platform default (if (< z -125361310560950360000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (- t (* (/ y z) (- t x))) (if (< z 44467023691138110000000000000000000000000000000000000000000000000) (+ x (/ (- y z) (/ (- a z) (- t x)))) (- t (* (/ y z) (- t x))))))
(+ x (/ (* (- y z) (- t x)) (- a z))))