
(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 23 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 (<= t_1 -5e-275)
(+ x (/ (- t x) (/ (- a z) (- y z))))
(if (<= t_1 0.0)
(+ t (/ (* (- t x) (- a y)) z))
(fma (- t x) (/ (- y z) (- a z)) x)))))
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 <= -5e-275) {
tmp = x + ((t - x) / ((a - z) / (y - z)));
} else if (t_1 <= 0.0) {
tmp = t + (((t - x) * (a - y)) / z);
} else {
tmp = fma((t - x), ((y - z) / (a - z)), x);
}
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 <= -5e-275) tmp = Float64(x + Float64(Float64(t - x) / Float64(Float64(a - z) / Float64(y - z)))); elseif (t_1 <= 0.0) tmp = Float64(t + Float64(Float64(Float64(t - x) * Float64(a - y)) / z)); else tmp = fma(Float64(t - x), Float64(Float64(y - z) / Float64(a - z)), x); end return 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[LessEqual[t$95$1, -5e-275], N[(x + N[(N[(t - x), $MachinePrecision] / N[(N[(a - z), $MachinePrecision] / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 0.0], N[(t + N[(N[(N[(t - x), $MachinePrecision] * N[(a - y), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], N[(N[(t - x), $MachinePrecision] * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision] + x), $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 -5 \cdot 10^{-275}:\\
\;\;\;\;x + \frac{t - x}{\frac{a - z}{y - z}}\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;t + \frac{\left(t - x\right) \cdot \left(a - y\right)}{z}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(t - x, \frac{y - z}{a - z}, x\right)\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -4.99999999999999983e-275Initial program 79.6%
associate-/l*90.2%
Simplified90.2%
Taylor expanded in y around 0 80.2%
mul-1-neg80.2%
associate-/l*85.1%
distribute-lft-neg-out85.1%
+-commutative85.1%
div-sub85.1%
distribute-rgt-out90.2%
sub-neg90.2%
associate-/r/94.5%
Simplified94.5%
if -4.99999999999999983e-275 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 0.0Initial program 3.9%
+-commutative3.9%
*-commutative3.9%
associate-/l*3.9%
fma-define3.9%
Simplified3.9%
Taylor expanded in z around inf 99.5%
associate--l+99.5%
associate-*r/99.5%
associate-*r/99.5%
mul-1-neg99.5%
div-sub99.5%
mul-1-neg99.5%
distribute-lft-out--99.5%
associate-*r/99.5%
mul-1-neg99.5%
unsub-neg99.5%
distribute-rgt-out--99.6%
Simplified99.6%
if 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) Initial program 69.3%
+-commutative69.3%
*-commutative69.3%
associate-/l*90.9%
fma-define91.0%
Simplified91.0%
Final simplification93.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* (- y z) (/ (- t x) (- a z)))))
(t_2 (+ x (/ (* (- y z) (- t x)) (- a z)))))
(if (<= t_2 -5e+278)
t_1
(if (<= t_2 -5e-275)
t_2
(if (<= t_2 0.0)
(+ t (/ (* (- t x) (- a y)) z))
(if (<= t_2 4e+304) t_2 t_1))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((y - z) * ((t - x) / (a - z)));
double t_2 = x + (((y - z) * (t - x)) / (a - z));
double tmp;
if (t_2 <= -5e+278) {
tmp = t_1;
} else if (t_2 <= -5e-275) {
tmp = t_2;
} else if (t_2 <= 0.0) {
tmp = t + (((t - x) * (a - y)) / z);
} else if (t_2 <= 4e+304) {
tmp = t_2;
} 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) :: t_2
real(8) :: tmp
t_1 = x + ((y - z) * ((t - x) / (a - z)))
t_2 = x + (((y - z) * (t - x)) / (a - z))
if (t_2 <= (-5d+278)) then
tmp = t_1
else if (t_2 <= (-5d-275)) then
tmp = t_2
else if (t_2 <= 0.0d0) then
tmp = t + (((t - x) * (a - y)) / z)
else if (t_2 <= 4d+304) then
tmp = t_2
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((y - z) * ((t - x) / (a - z)));
double t_2 = x + (((y - z) * (t - x)) / (a - z));
double tmp;
if (t_2 <= -5e+278) {
tmp = t_1;
} else if (t_2 <= -5e-275) {
tmp = t_2;
} else if (t_2 <= 0.0) {
tmp = t + (((t - x) * (a - y)) / z);
} else if (t_2 <= 4e+304) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + ((y - z) * ((t - x) / (a - z))) t_2 = x + (((y - z) * (t - x)) / (a - z)) tmp = 0 if t_2 <= -5e+278: tmp = t_1 elif t_2 <= -5e-275: tmp = t_2 elif t_2 <= 0.0: tmp = t + (((t - x) * (a - y)) / z) elif t_2 <= 4e+304: tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / Float64(a - z)))) t_2 = Float64(x + Float64(Float64(Float64(y - z) * Float64(t - x)) / Float64(a - z))) tmp = 0.0 if (t_2 <= -5e+278) tmp = t_1; elseif (t_2 <= -5e-275) tmp = t_2; elseif (t_2 <= 0.0) tmp = Float64(t + Float64(Float64(Float64(t - x) * Float64(a - y)) / z)); elseif (t_2 <= 4e+304) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + ((y - z) * ((t - x) / (a - z))); t_2 = x + (((y - z) * (t - x)) / (a - z)); tmp = 0.0; if (t_2 <= -5e+278) tmp = t_1; elseif (t_2 <= -5e-275) tmp = t_2; elseif (t_2 <= 0.0) tmp = t + (((t - x) * (a - y)) / z); elseif (t_2 <= 4e+304) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -5e+278], t$95$1, If[LessEqual[t$95$2, -5e-275], t$95$2, If[LessEqual[t$95$2, 0.0], N[(t + N[(N[(N[(t - x), $MachinePrecision] * N[(a - y), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 4e+304], t$95$2, t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(y - z\right) \cdot \frac{t - x}{a - z}\\
t_2 := x + \frac{\left(y - z\right) \cdot \left(t - x\right)}{a - z}\\
\mathbf{if}\;t\_2 \leq -5 \cdot 10^{+278}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq -5 \cdot 10^{-275}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_2 \leq 0:\\
\;\;\;\;t + \frac{\left(t - x\right) \cdot \left(a - y\right)}{z}\\
\mathbf{elif}\;t\_2 \leq 4 \cdot 10^{+304}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -5.00000000000000029e278 or 3.9999999999999998e304 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) Initial program 48.1%
associate-/l*89.6%
Simplified89.6%
if -5.00000000000000029e278 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -4.99999999999999983e-275 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 3.9999999999999998e304Initial program 95.1%
if -4.99999999999999983e-275 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 0.0Initial program 3.9%
+-commutative3.9%
*-commutative3.9%
associate-/l*3.9%
fma-define3.9%
Simplified3.9%
Taylor expanded in z around inf 99.5%
associate--l+99.5%
associate-*r/99.5%
associate-*r/99.5%
mul-1-neg99.5%
div-sub99.5%
mul-1-neg99.5%
distribute-lft-out--99.5%
associate-*r/99.5%
mul-1-neg99.5%
unsub-neg99.5%
distribute-rgt-out--99.6%
Simplified99.6%
Final simplification93.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ (* (- y z) (- t x)) (- a z)))))
(if (or (<= t_1 -5e-275) (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 + (((y - z) * (t - x)) / (a - z));
double tmp;
if ((t_1 <= -5e-275) || !(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 + (((y - z) * (t - x)) / (a - z))
if ((t_1 <= (-5d-275)) .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 + (((y - z) * (t - x)) / (a - z));
double tmp;
if ((t_1 <= -5e-275) || !(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 + (((y - z) * (t - x)) / (a - z)) tmp = 0 if (t_1 <= -5e-275) 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(y - z) * Float64(t - x)) / Float64(a - z))) tmp = 0.0 if ((t_1 <= -5e-275) || !(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 + (((y - z) * (t - x)) / (a - z)); tmp = 0.0; if ((t_1 <= -5e-275) || ~((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[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, -5e-275], 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(y - z\right) \cdot \left(t - x\right)}{a - z}\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{-275} \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))) < -4.99999999999999983e-275 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) Initial program 74.3%
associate-/l*87.8%
Simplified87.8%
Taylor expanded in y around 0 75.7%
mul-1-neg75.7%
associate-/l*83.6%
distribute-lft-neg-out83.6%
+-commutative83.6%
div-sub83.6%
distribute-rgt-out87.8%
sub-neg87.8%
associate-/r/92.7%
Simplified92.7%
if -4.99999999999999983e-275 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 0.0Initial program 3.9%
+-commutative3.9%
*-commutative3.9%
associate-/l*3.9%
fma-define3.9%
Simplified3.9%
Taylor expanded in z around inf 99.5%
associate--l+99.5%
associate-*r/99.5%
associate-*r/99.5%
mul-1-neg99.5%
div-sub99.5%
mul-1-neg99.5%
distribute-lft-out--99.5%
associate-*r/99.5%
mul-1-neg99.5%
unsub-neg99.5%
distribute-rgt-out--99.6%
Simplified99.6%
Final simplification93.1%
(FPCore (x y z t a)
:precision binary64
(if (<= z -2.05e+130)
(+ t (/ (* (- t x) a) z))
(if (<= z -2.35e-88)
(+ x (* t (/ y (- a z))))
(if (<= z -3.05e-167)
(* x (- 1.0 (/ y a)))
(if (<= z 3.55e+143)
(+ x (* t (/ (- y z) a)))
(+ t (* a (/ (- t x) z))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.05e+130) {
tmp = t + (((t - x) * a) / z);
} else if (z <= -2.35e-88) {
tmp = x + (t * (y / (a - z)));
} else if (z <= -3.05e-167) {
tmp = x * (1.0 - (y / a));
} else if (z <= 3.55e+143) {
tmp = x + (t * ((y - z) / a));
} else {
tmp = t + (a * ((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 (z <= (-2.05d+130)) then
tmp = t + (((t - x) * a) / z)
else if (z <= (-2.35d-88)) then
tmp = x + (t * (y / (a - z)))
else if (z <= (-3.05d-167)) then
tmp = x * (1.0d0 - (y / a))
else if (z <= 3.55d+143) then
tmp = x + (t * ((y - z) / a))
else
tmp = t + (a * ((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 (z <= -2.05e+130) {
tmp = t + (((t - x) * a) / z);
} else if (z <= -2.35e-88) {
tmp = x + (t * (y / (a - z)));
} else if (z <= -3.05e-167) {
tmp = x * (1.0 - (y / a));
} else if (z <= 3.55e+143) {
tmp = x + (t * ((y - z) / a));
} else {
tmp = t + (a * ((t - x) / z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.05e+130: tmp = t + (((t - x) * a) / z) elif z <= -2.35e-88: tmp = x + (t * (y / (a - z))) elif z <= -3.05e-167: tmp = x * (1.0 - (y / a)) elif z <= 3.55e+143: tmp = x + (t * ((y - z) / a)) else: tmp = t + (a * ((t - x) / z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.05e+130) tmp = Float64(t + Float64(Float64(Float64(t - x) * a) / z)); elseif (z <= -2.35e-88) tmp = Float64(x + Float64(t * Float64(y / Float64(a - z)))); elseif (z <= -3.05e-167) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (z <= 3.55e+143) tmp = Float64(x + Float64(t * Float64(Float64(y - z) / a))); else tmp = Float64(t + Float64(a * Float64(Float64(t - x) / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.05e+130) tmp = t + (((t - x) * a) / z); elseif (z <= -2.35e-88) tmp = x + (t * (y / (a - z))); elseif (z <= -3.05e-167) tmp = x * (1.0 - (y / a)); elseif (z <= 3.55e+143) tmp = x + (t * ((y - z) / a)); else tmp = t + (a * ((t - x) / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.05e+130], N[(t + N[(N[(N[(t - x), $MachinePrecision] * a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2.35e-88], N[(x + N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.05e-167], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.55e+143], N[(x + N[(t * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(a * N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.05 \cdot 10^{+130}:\\
\;\;\;\;t + \frac{\left(t - x\right) \cdot a}{z}\\
\mathbf{elif}\;z \leq -2.35 \cdot 10^{-88}:\\
\;\;\;\;x + t \cdot \frac{y}{a - z}\\
\mathbf{elif}\;z \leq -3.05 \cdot 10^{-167}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;z \leq 3.55 \cdot 10^{+143}:\\
\;\;\;\;x + t \cdot \frac{y - z}{a}\\
\mathbf{else}:\\
\;\;\;\;t + a \cdot \frac{t - x}{z}\\
\end{array}
\end{array}
if z < -2.04999999999999989e130Initial program 32.9%
+-commutative32.9%
*-commutative32.9%
associate-/l*62.7%
fma-define62.9%
Simplified62.9%
Taylor expanded in y around 0 30.1%
mul-1-neg30.1%
associate-/l*36.7%
distribute-lft-neg-out36.7%
+-commutative36.7%
*-commutative36.7%
fma-define36.6%
Simplified36.6%
Taylor expanded in z around inf 66.9%
if -2.04999999999999989e130 < z < -2.35e-88Initial program 71.9%
Taylor expanded in y around inf 57.8%
*-commutative57.8%
Simplified57.8%
Taylor expanded in t around inf 46.0%
associate-/l*51.9%
Simplified51.9%
if -2.35e-88 < z < -3.0499999999999999e-167Initial program 75.9%
associate-/l*82.4%
Simplified82.4%
Taylor expanded in y around 0 83.0%
mul-1-neg83.0%
associate-/l*82.4%
distribute-lft-neg-out82.4%
+-commutative82.4%
div-sub82.4%
distribute-rgt-out82.4%
sub-neg82.4%
associate-/r/89.5%
Simplified89.5%
Taylor expanded in t around inf 85.3%
mul-1-neg85.3%
unsub-neg85.3%
Simplified85.3%
Taylor expanded in z around 0 63.5%
Taylor expanded in x around inf 73.0%
mul-1-neg73.0%
unsub-neg73.0%
Simplified73.0%
if -3.0499999999999999e-167 < z < 3.55000000000000021e143Initial program 88.8%
associate-/l*93.3%
Simplified93.3%
Taylor expanded in t around inf 71.2%
Taylor expanded in a around inf 60.3%
associate-/l*68.2%
Simplified68.2%
if 3.55000000000000021e143 < z Initial program 37.1%
+-commutative37.1%
*-commutative37.1%
associate-/l*82.7%
fma-define82.8%
Simplified82.8%
Taylor expanded in y around 0 36.4%
mul-1-neg36.4%
associate-/l*63.5%
distribute-lft-neg-out63.5%
+-commutative63.5%
*-commutative63.5%
fma-define63.7%
Simplified63.7%
Taylor expanded in z around inf 51.6%
associate-/l*68.2%
Simplified68.2%
Final simplification65.4%
(FPCore (x y z t a)
:precision binary64
(if (<= z -1.22e+109)
(+ t (/ (* (- t x) a) z))
(if (<= z -1.12e-167)
(* x (- 1.0 (/ y a)))
(if (<= z 1.7e-33)
(+ x (/ t (/ a y)))
(if (<= z 3.55e+143) (* y (/ (- x t) z)) (+ t (* a (/ (- t x) z))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.22e+109) {
tmp = t + (((t - x) * a) / z);
} else if (z <= -1.12e-167) {
tmp = x * (1.0 - (y / a));
} else if (z <= 1.7e-33) {
tmp = x + (t / (a / y));
} else if (z <= 3.55e+143) {
tmp = y * ((x - t) / z);
} else {
tmp = t + (a * ((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 (z <= (-1.22d+109)) then
tmp = t + (((t - x) * a) / z)
else if (z <= (-1.12d-167)) then
tmp = x * (1.0d0 - (y / a))
else if (z <= 1.7d-33) then
tmp = x + (t / (a / y))
else if (z <= 3.55d+143) then
tmp = y * ((x - t) / z)
else
tmp = t + (a * ((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 (z <= -1.22e+109) {
tmp = t + (((t - x) * a) / z);
} else if (z <= -1.12e-167) {
tmp = x * (1.0 - (y / a));
} else if (z <= 1.7e-33) {
tmp = x + (t / (a / y));
} else if (z <= 3.55e+143) {
tmp = y * ((x - t) / z);
} else {
tmp = t + (a * ((t - x) / z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1.22e+109: tmp = t + (((t - x) * a) / z) elif z <= -1.12e-167: tmp = x * (1.0 - (y / a)) elif z <= 1.7e-33: tmp = x + (t / (a / y)) elif z <= 3.55e+143: tmp = y * ((x - t) / z) else: tmp = t + (a * ((t - x) / z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.22e+109) tmp = Float64(t + Float64(Float64(Float64(t - x) * a) / z)); elseif (z <= -1.12e-167) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (z <= 1.7e-33) tmp = Float64(x + Float64(t / Float64(a / y))); elseif (z <= 3.55e+143) tmp = Float64(y * Float64(Float64(x - t) / z)); else tmp = Float64(t + Float64(a * Float64(Float64(t - x) / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1.22e+109) tmp = t + (((t - x) * a) / z); elseif (z <= -1.12e-167) tmp = x * (1.0 - (y / a)); elseif (z <= 1.7e-33) tmp = x + (t / (a / y)); elseif (z <= 3.55e+143) tmp = y * ((x - t) / z); else tmp = t + (a * ((t - x) / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.22e+109], N[(t + N[(N[(N[(t - x), $MachinePrecision] * a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.12e-167], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.7e-33], N[(x + N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.55e+143], N[(y * N[(N[(x - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], N[(t + N[(a * N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.22 \cdot 10^{+109}:\\
\;\;\;\;t + \frac{\left(t - x\right) \cdot a}{z}\\
\mathbf{elif}\;z \leq -1.12 \cdot 10^{-167}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;z \leq 1.7 \cdot 10^{-33}:\\
\;\;\;\;x + \frac{t}{\frac{a}{y}}\\
\mathbf{elif}\;z \leq 3.55 \cdot 10^{+143}:\\
\;\;\;\;y \cdot \frac{x - t}{z}\\
\mathbf{else}:\\
\;\;\;\;t + a \cdot \frac{t - x}{z}\\
\end{array}
\end{array}
if z < -1.2200000000000001e109Initial program 34.7%
+-commutative34.7%
*-commutative34.7%
associate-/l*63.8%
fma-define63.9%
Simplified63.9%
Taylor expanded in y around 0 29.3%
mul-1-neg29.3%
associate-/l*35.8%
distribute-lft-neg-out35.8%
+-commutative35.8%
*-commutative35.8%
fma-define35.6%
Simplified35.6%
Taylor expanded in z around inf 65.1%
if -1.2200000000000001e109 < z < -1.1200000000000001e-167Initial program 72.8%
associate-/l*83.0%
Simplified83.0%
Taylor expanded in y around 0 74.5%
mul-1-neg74.5%
associate-/l*82.9%
distribute-lft-neg-out82.9%
+-commutative82.9%
div-sub82.9%
distribute-rgt-out83.0%
sub-neg83.0%
associate-/r/88.0%
Simplified88.0%
Taylor expanded in t around inf 85.4%
mul-1-neg85.4%
unsub-neg85.4%
Simplified85.4%
Taylor expanded in z around 0 50.6%
Taylor expanded in x around inf 50.6%
mul-1-neg50.6%
unsub-neg50.6%
Simplified50.6%
if -1.1200000000000001e-167 < z < 1.7e-33Initial program 90.3%
associate-/l*95.2%
Simplified95.2%
Taylor expanded in y around 0 93.0%
mul-1-neg93.0%
associate-/l*83.9%
distribute-lft-neg-out83.9%
+-commutative83.9%
div-sub83.9%
distribute-rgt-out95.2%
sub-neg95.2%
associate-/r/96.4%
Simplified96.4%
Taylor expanded in t around inf 90.1%
mul-1-neg90.1%
unsub-neg90.1%
Simplified90.1%
Taylor expanded in z around 0 76.1%
Taylor expanded in t around inf 72.1%
if 1.7e-33 < z < 3.55000000000000021e143Initial program 84.2%
+-commutative84.2%
*-commutative84.2%
associate-/l*90.8%
fma-define90.9%
Simplified90.9%
Taylor expanded in y around inf 57.3%
Taylor expanded in a around 0 43.9%
associate-*r/43.9%
associate-*r/43.9%
div-sub43.9%
cancel-sign-sub-inv43.9%
neg-mul-143.9%
metadata-eval43.9%
*-commutative43.9%
*-rgt-identity43.9%
Simplified43.9%
if 3.55000000000000021e143 < z Initial program 37.1%
+-commutative37.1%
*-commutative37.1%
associate-/l*82.7%
fma-define82.8%
Simplified82.8%
Taylor expanded in y around 0 36.4%
mul-1-neg36.4%
associate-/l*63.5%
distribute-lft-neg-out63.5%
+-commutative63.5%
*-commutative63.5%
fma-define63.7%
Simplified63.7%
Taylor expanded in z around inf 51.6%
associate-/l*68.2%
Simplified68.2%
Final simplification61.8%
(FPCore (x y z t a)
:precision binary64
(if (<= z -2.45e+70)
(* x (- (/ t x) (/ a z)))
(if (<= z -1.5e-168)
(* x (- 1.0 (/ y a)))
(if (<= z 3.2e-30)
(+ x (/ t (/ a y)))
(if (<= z 3.55e+143) (* y (/ (- x t) z)) (+ t (* a (/ (- t x) z))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.45e+70) {
tmp = x * ((t / x) - (a / z));
} else if (z <= -1.5e-168) {
tmp = x * (1.0 - (y / a));
} else if (z <= 3.2e-30) {
tmp = x + (t / (a / y));
} else if (z <= 3.55e+143) {
tmp = y * ((x - t) / z);
} else {
tmp = t + (a * ((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 (z <= (-2.45d+70)) then
tmp = x * ((t / x) - (a / z))
else if (z <= (-1.5d-168)) then
tmp = x * (1.0d0 - (y / a))
else if (z <= 3.2d-30) then
tmp = x + (t / (a / y))
else if (z <= 3.55d+143) then
tmp = y * ((x - t) / z)
else
tmp = t + (a * ((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 (z <= -2.45e+70) {
tmp = x * ((t / x) - (a / z));
} else if (z <= -1.5e-168) {
tmp = x * (1.0 - (y / a));
} else if (z <= 3.2e-30) {
tmp = x + (t / (a / y));
} else if (z <= 3.55e+143) {
tmp = y * ((x - t) / z);
} else {
tmp = t + (a * ((t - x) / z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.45e+70: tmp = x * ((t / x) - (a / z)) elif z <= -1.5e-168: tmp = x * (1.0 - (y / a)) elif z <= 3.2e-30: tmp = x + (t / (a / y)) elif z <= 3.55e+143: tmp = y * ((x - t) / z) else: tmp = t + (a * ((t - x) / z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.45e+70) tmp = Float64(x * Float64(Float64(t / x) - Float64(a / z))); elseif (z <= -1.5e-168) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (z <= 3.2e-30) tmp = Float64(x + Float64(t / Float64(a / y))); elseif (z <= 3.55e+143) tmp = Float64(y * Float64(Float64(x - t) / z)); else tmp = Float64(t + Float64(a * Float64(Float64(t - x) / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.45e+70) tmp = x * ((t / x) - (a / z)); elseif (z <= -1.5e-168) tmp = x * (1.0 - (y / a)); elseif (z <= 3.2e-30) tmp = x + (t / (a / y)); elseif (z <= 3.55e+143) tmp = y * ((x - t) / z); else tmp = t + (a * ((t - x) / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.45e+70], N[(x * N[(N[(t / x), $MachinePrecision] - N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.5e-168], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.2e-30], N[(x + N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.55e+143], N[(y * N[(N[(x - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], N[(t + N[(a * N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.45 \cdot 10^{+70}:\\
\;\;\;\;x \cdot \left(\frac{t}{x} - \frac{a}{z}\right)\\
\mathbf{elif}\;z \leq -1.5 \cdot 10^{-168}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;z \leq 3.2 \cdot 10^{-30}:\\
\;\;\;\;x + \frac{t}{\frac{a}{y}}\\
\mathbf{elif}\;z \leq 3.55 \cdot 10^{+143}:\\
\;\;\;\;y \cdot \frac{x - t}{z}\\
\mathbf{else}:\\
\;\;\;\;t + a \cdot \frac{t - x}{z}\\
\end{array}
\end{array}
if z < -2.45000000000000014e70Initial program 38.7%
+-commutative38.7%
*-commutative38.7%
associate-/l*65.4%
fma-define65.5%
Simplified65.5%
Taylor expanded in y around 0 30.0%
mul-1-neg30.0%
associate-/l*31.1%
distribute-lft-neg-out31.1%
+-commutative31.1%
*-commutative31.1%
fma-define31.1%
Simplified31.1%
Taylor expanded in z around inf 57.9%
associate-/l*57.2%
Simplified57.2%
Taylor expanded in t around 0 57.8%
mul-1-neg57.8%
associate-/l*56.9%
distribute-rgt-neg-in56.9%
mul-1-neg56.9%
associate-*r/56.9%
mul-1-neg56.9%
Simplified56.9%
Taylor expanded in x around inf 57.8%
+-commutative57.8%
mul-1-neg57.8%
unsub-neg57.8%
Simplified57.8%
if -2.45000000000000014e70 < z < -1.49999999999999996e-168Initial program 76.2%
associate-/l*86.8%
Simplified86.8%
Taylor expanded in y around 0 76.7%
mul-1-neg76.7%
associate-/l*86.6%
distribute-lft-neg-out86.6%
+-commutative86.6%
div-sub86.6%
distribute-rgt-out86.8%
sub-neg86.8%
associate-/r/90.9%
Simplified90.9%
Taylor expanded in t around inf 87.8%
mul-1-neg87.8%
unsub-neg87.8%
Simplified87.8%
Taylor expanded in z around 0 52.0%
Taylor expanded in x around inf 53.6%
mul-1-neg53.6%
unsub-neg53.6%
Simplified53.6%
if -1.49999999999999996e-168 < z < 3.2e-30Initial program 90.3%
associate-/l*95.2%
Simplified95.2%
Taylor expanded in y around 0 93.0%
mul-1-neg93.0%
associate-/l*83.9%
distribute-lft-neg-out83.9%
+-commutative83.9%
div-sub83.9%
distribute-rgt-out95.2%
sub-neg95.2%
associate-/r/96.4%
Simplified96.4%
Taylor expanded in t around inf 90.1%
mul-1-neg90.1%
unsub-neg90.1%
Simplified90.1%
Taylor expanded in z around 0 76.1%
Taylor expanded in t around inf 72.1%
if 3.2e-30 < z < 3.55000000000000021e143Initial program 84.2%
+-commutative84.2%
*-commutative84.2%
associate-/l*90.8%
fma-define90.9%
Simplified90.9%
Taylor expanded in y around inf 57.3%
Taylor expanded in a around 0 43.9%
associate-*r/43.9%
associate-*r/43.9%
div-sub43.9%
cancel-sign-sub-inv43.9%
neg-mul-143.9%
metadata-eval43.9%
*-commutative43.9%
*-rgt-identity43.9%
Simplified43.9%
if 3.55000000000000021e143 < z Initial program 37.1%
+-commutative37.1%
*-commutative37.1%
associate-/l*82.7%
fma-define82.8%
Simplified82.8%
Taylor expanded in y around 0 36.4%
mul-1-neg36.4%
associate-/l*63.5%
distribute-lft-neg-out63.5%
+-commutative63.5%
*-commutative63.5%
fma-define63.7%
Simplified63.7%
Taylor expanded in z around inf 51.6%
associate-/l*68.2%
Simplified68.2%
Final simplification61.7%
(FPCore (x y z t a)
:precision binary64
(if (<= z -5.4e+70)
(* x (- (/ t x) (/ a z)))
(if (<= z -2.95e-167)
(* x (- 1.0 (/ y a)))
(if (<= z 8e-30)
(+ x (/ t (/ a y)))
(if (<= z 3.55e+143) (* y (/ (- x t) z)) (- t (* a (/ x z))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -5.4e+70) {
tmp = x * ((t / x) - (a / z));
} else if (z <= -2.95e-167) {
tmp = x * (1.0 - (y / a));
} else if (z <= 8e-30) {
tmp = x + (t / (a / y));
} else if (z <= 3.55e+143) {
tmp = y * ((x - t) / z);
} else {
tmp = t - (a * (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 (z <= (-5.4d+70)) then
tmp = x * ((t / x) - (a / z))
else if (z <= (-2.95d-167)) then
tmp = x * (1.0d0 - (y / a))
else if (z <= 8d-30) then
tmp = x + (t / (a / y))
else if (z <= 3.55d+143) then
tmp = y * ((x - t) / z)
else
tmp = t - (a * (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 (z <= -5.4e+70) {
tmp = x * ((t / x) - (a / z));
} else if (z <= -2.95e-167) {
tmp = x * (1.0 - (y / a));
} else if (z <= 8e-30) {
tmp = x + (t / (a / y));
} else if (z <= 3.55e+143) {
tmp = y * ((x - t) / z);
} else {
tmp = t - (a * (x / z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -5.4e+70: tmp = x * ((t / x) - (a / z)) elif z <= -2.95e-167: tmp = x * (1.0 - (y / a)) elif z <= 8e-30: tmp = x + (t / (a / y)) elif z <= 3.55e+143: tmp = y * ((x - t) / z) else: tmp = t - (a * (x / z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -5.4e+70) tmp = Float64(x * Float64(Float64(t / x) - Float64(a / z))); elseif (z <= -2.95e-167) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (z <= 8e-30) tmp = Float64(x + Float64(t / Float64(a / y))); elseif (z <= 3.55e+143) tmp = Float64(y * Float64(Float64(x - t) / z)); else tmp = Float64(t - Float64(a * Float64(x / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -5.4e+70) tmp = x * ((t / x) - (a / z)); elseif (z <= -2.95e-167) tmp = x * (1.0 - (y / a)); elseif (z <= 8e-30) tmp = x + (t / (a / y)); elseif (z <= 3.55e+143) tmp = y * ((x - t) / z); else tmp = t - (a * (x / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -5.4e+70], N[(x * N[(N[(t / x), $MachinePrecision] - N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2.95e-167], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 8e-30], N[(x + N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.55e+143], N[(y * N[(N[(x - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], N[(t - N[(a * N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -5.4 \cdot 10^{+70}:\\
\;\;\;\;x \cdot \left(\frac{t}{x} - \frac{a}{z}\right)\\
\mathbf{elif}\;z \leq -2.95 \cdot 10^{-167}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;z \leq 8 \cdot 10^{-30}:\\
\;\;\;\;x + \frac{t}{\frac{a}{y}}\\
\mathbf{elif}\;z \leq 3.55 \cdot 10^{+143}:\\
\;\;\;\;y \cdot \frac{x - t}{z}\\
\mathbf{else}:\\
\;\;\;\;t - a \cdot \frac{x}{z}\\
\end{array}
\end{array}
if z < -5.3999999999999999e70Initial program 38.7%
+-commutative38.7%
*-commutative38.7%
associate-/l*65.4%
fma-define65.5%
Simplified65.5%
Taylor expanded in y around 0 30.0%
mul-1-neg30.0%
associate-/l*31.1%
distribute-lft-neg-out31.1%
+-commutative31.1%
*-commutative31.1%
fma-define31.1%
Simplified31.1%
Taylor expanded in z around inf 57.9%
associate-/l*57.2%
Simplified57.2%
Taylor expanded in t around 0 57.8%
mul-1-neg57.8%
associate-/l*56.9%
distribute-rgt-neg-in56.9%
mul-1-neg56.9%
associate-*r/56.9%
mul-1-neg56.9%
Simplified56.9%
Taylor expanded in x around inf 57.8%
+-commutative57.8%
mul-1-neg57.8%
unsub-neg57.8%
Simplified57.8%
if -5.3999999999999999e70 < z < -2.95000000000000011e-167Initial program 76.2%
associate-/l*86.8%
Simplified86.8%
Taylor expanded in y around 0 76.7%
mul-1-neg76.7%
associate-/l*86.6%
distribute-lft-neg-out86.6%
+-commutative86.6%
div-sub86.6%
distribute-rgt-out86.8%
sub-neg86.8%
associate-/r/90.9%
Simplified90.9%
Taylor expanded in t around inf 87.8%
mul-1-neg87.8%
unsub-neg87.8%
Simplified87.8%
Taylor expanded in z around 0 52.0%
Taylor expanded in x around inf 53.6%
mul-1-neg53.6%
unsub-neg53.6%
Simplified53.6%
if -2.95000000000000011e-167 < z < 8.000000000000001e-30Initial program 90.3%
associate-/l*95.2%
Simplified95.2%
Taylor expanded in y around 0 93.0%
mul-1-neg93.0%
associate-/l*83.9%
distribute-lft-neg-out83.9%
+-commutative83.9%
div-sub83.9%
distribute-rgt-out95.2%
sub-neg95.2%
associate-/r/96.4%
Simplified96.4%
Taylor expanded in t around inf 90.1%
mul-1-neg90.1%
unsub-neg90.1%
Simplified90.1%
Taylor expanded in z around 0 76.1%
Taylor expanded in t around inf 72.1%
if 8.000000000000001e-30 < z < 3.55000000000000021e143Initial program 84.2%
+-commutative84.2%
*-commutative84.2%
associate-/l*90.8%
fma-define90.9%
Simplified90.9%
Taylor expanded in y around inf 57.3%
Taylor expanded in a around 0 43.9%
associate-*r/43.9%
associate-*r/43.9%
div-sub43.9%
cancel-sign-sub-inv43.9%
neg-mul-143.9%
metadata-eval43.9%
*-commutative43.9%
*-rgt-identity43.9%
Simplified43.9%
if 3.55000000000000021e143 < z Initial program 37.1%
+-commutative37.1%
*-commutative37.1%
associate-/l*82.7%
fma-define82.8%
Simplified82.8%
Taylor expanded in y around 0 36.4%
mul-1-neg36.4%
associate-/l*63.5%
distribute-lft-neg-out63.5%
+-commutative63.5%
*-commutative63.5%
fma-define63.7%
Simplified63.7%
Taylor expanded in z around inf 51.6%
associate-/l*68.2%
Simplified68.2%
Taylor expanded in t around 0 65.1%
mul-1-neg65.1%
associate-/l*68.1%
distribute-rgt-neg-in68.1%
mul-1-neg68.1%
associate-*r/68.1%
mul-1-neg68.1%
Simplified68.1%
Taylor expanded in t around 0 65.1%
mul-1-neg65.1%
associate-*r/68.1%
sub-neg68.1%
Simplified68.1%
Final simplification61.7%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- t (* a (/ x z)))))
(if (<= z -1.02e+114)
t_1
(if (<= z -3.8e-168)
(* x (- 1.0 (/ y a)))
(if (<= z 8e-31)
(+ x (/ t (/ a y)))
(if (<= z 3.55e+143) (* y (/ (- x t) z)) t_1))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t - (a * (x / z));
double tmp;
if (z <= -1.02e+114) {
tmp = t_1;
} else if (z <= -3.8e-168) {
tmp = x * (1.0 - (y / a));
} else if (z <= 8e-31) {
tmp = x + (t / (a / y));
} else if (z <= 3.55e+143) {
tmp = y * ((x - t) / z);
} 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 - (a * (x / z))
if (z <= (-1.02d+114)) then
tmp = t_1
else if (z <= (-3.8d-168)) then
tmp = x * (1.0d0 - (y / a))
else if (z <= 8d-31) then
tmp = x + (t / (a / y))
else if (z <= 3.55d+143) then
tmp = y * ((x - t) / z)
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 - (a * (x / z));
double tmp;
if (z <= -1.02e+114) {
tmp = t_1;
} else if (z <= -3.8e-168) {
tmp = x * (1.0 - (y / a));
} else if (z <= 8e-31) {
tmp = x + (t / (a / y));
} else if (z <= 3.55e+143) {
tmp = y * ((x - t) / z);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t - (a * (x / z)) tmp = 0 if z <= -1.02e+114: tmp = t_1 elif z <= -3.8e-168: tmp = x * (1.0 - (y / a)) elif z <= 8e-31: tmp = x + (t / (a / y)) elif z <= 3.55e+143: tmp = y * ((x - t) / z) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t - Float64(a * Float64(x / z))) tmp = 0.0 if (z <= -1.02e+114) tmp = t_1; elseif (z <= -3.8e-168) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (z <= 8e-31) tmp = Float64(x + Float64(t / Float64(a / y))); elseif (z <= 3.55e+143) tmp = Float64(y * Float64(Float64(x - t) / z)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t - (a * (x / z)); tmp = 0.0; if (z <= -1.02e+114) tmp = t_1; elseif (z <= -3.8e-168) tmp = x * (1.0 - (y / a)); elseif (z <= 8e-31) tmp = x + (t / (a / y)); elseif (z <= 3.55e+143) tmp = y * ((x - t) / z); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t - N[(a * N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.02e+114], t$95$1, If[LessEqual[z, -3.8e-168], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 8e-31], N[(x + N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.55e+143], N[(y * N[(N[(x - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t - a \cdot \frac{x}{z}\\
\mathbf{if}\;z \leq -1.02 \cdot 10^{+114}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -3.8 \cdot 10^{-168}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;z \leq 8 \cdot 10^{-31}:\\
\;\;\;\;x + \frac{t}{\frac{a}{y}}\\
\mathbf{elif}\;z \leq 3.55 \cdot 10^{+143}:\\
\;\;\;\;y \cdot \frac{x - t}{z}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.01999999999999999e114 or 3.55000000000000021e143 < z Initial program 35.9%
+-commutative35.9%
*-commutative35.9%
associate-/l*73.1%
fma-define73.2%
Simplified73.2%
Taylor expanded in y around 0 32.8%
mul-1-neg32.8%
associate-/l*49.5%
distribute-lft-neg-out49.5%
+-commutative49.5%
*-commutative49.5%
fma-define49.5%
Simplified49.5%
Taylor expanded in z around inf 58.5%
associate-/l*66.2%
Simplified66.2%
Taylor expanded in t around 0 64.9%
mul-1-neg64.9%
associate-/l*65.8%
distribute-rgt-neg-in65.8%
mul-1-neg65.8%
associate-*r/65.8%
mul-1-neg65.8%
Simplified65.8%
Taylor expanded in t around 0 64.9%
mul-1-neg64.9%
associate-*r/65.8%
sub-neg65.8%
Simplified65.8%
if -1.01999999999999999e114 < z < -3.8e-168Initial program 72.8%
associate-/l*83.0%
Simplified83.0%
Taylor expanded in y around 0 74.5%
mul-1-neg74.5%
associate-/l*82.9%
distribute-lft-neg-out82.9%
+-commutative82.9%
div-sub82.9%
distribute-rgt-out83.0%
sub-neg83.0%
associate-/r/88.0%
Simplified88.0%
Taylor expanded in t around inf 85.4%
mul-1-neg85.4%
unsub-neg85.4%
Simplified85.4%
Taylor expanded in z around 0 50.6%
Taylor expanded in x around inf 50.6%
mul-1-neg50.6%
unsub-neg50.6%
Simplified50.6%
if -3.8e-168 < z < 8.000000000000001e-31Initial program 90.3%
associate-/l*95.2%
Simplified95.2%
Taylor expanded in y around 0 93.0%
mul-1-neg93.0%
associate-/l*83.9%
distribute-lft-neg-out83.9%
+-commutative83.9%
div-sub83.9%
distribute-rgt-out95.2%
sub-neg95.2%
associate-/r/96.4%
Simplified96.4%
Taylor expanded in t around inf 90.1%
mul-1-neg90.1%
unsub-neg90.1%
Simplified90.1%
Taylor expanded in z around 0 76.1%
Taylor expanded in t around inf 72.1%
if 8.000000000000001e-31 < z < 3.55000000000000021e143Initial program 84.2%
+-commutative84.2%
*-commutative84.2%
associate-/l*90.8%
fma-define90.9%
Simplified90.9%
Taylor expanded in y around inf 57.3%
Taylor expanded in a around 0 43.9%
associate-*r/43.9%
associate-*r/43.9%
div-sub43.9%
cancel-sign-sub-inv43.9%
neg-mul-143.9%
metadata-eval43.9%
*-commutative43.9%
*-rgt-identity43.9%
Simplified43.9%
Final simplification61.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- t (* a (/ x z)))))
(if (<= z -5.5e+108)
t_1
(if (<= z -3e-167)
(* x (- 1.0 (/ y a)))
(if (<= z 3.55e+143) (+ x (* t (/ y a))) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t - (a * (x / z));
double tmp;
if (z <= -5.5e+108) {
tmp = t_1;
} else if (z <= -3e-167) {
tmp = x * (1.0 - (y / a));
} else if (z <= 3.55e+143) {
tmp = x + (t * (y / a));
} 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 - (a * (x / z))
if (z <= (-5.5d+108)) then
tmp = t_1
else if (z <= (-3d-167)) then
tmp = x * (1.0d0 - (y / a))
else if (z <= 3.55d+143) then
tmp = x + (t * (y / a))
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 - (a * (x / z));
double tmp;
if (z <= -5.5e+108) {
tmp = t_1;
} else if (z <= -3e-167) {
tmp = x * (1.0 - (y / a));
} else if (z <= 3.55e+143) {
tmp = x + (t * (y / a));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t - (a * (x / z)) tmp = 0 if z <= -5.5e+108: tmp = t_1 elif z <= -3e-167: tmp = x * (1.0 - (y / a)) elif z <= 3.55e+143: tmp = x + (t * (y / a)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t - Float64(a * Float64(x / z))) tmp = 0.0 if (z <= -5.5e+108) tmp = t_1; elseif (z <= -3e-167) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (z <= 3.55e+143) tmp = Float64(x + Float64(t * Float64(y / a))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t - (a * (x / z)); tmp = 0.0; if (z <= -5.5e+108) tmp = t_1; elseif (z <= -3e-167) tmp = x * (1.0 - (y / a)); elseif (z <= 3.55e+143) tmp = x + (t * (y / a)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t - N[(a * N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5.5e+108], t$95$1, If[LessEqual[z, -3e-167], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.55e+143], N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t - a \cdot \frac{x}{z}\\
\mathbf{if}\;z \leq -5.5 \cdot 10^{+108}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -3 \cdot 10^{-167}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;z \leq 3.55 \cdot 10^{+143}:\\
\;\;\;\;x + t \cdot \frac{y}{a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -5.4999999999999998e108 or 3.55000000000000021e143 < z Initial program 35.9%
+-commutative35.9%
*-commutative35.9%
associate-/l*73.1%
fma-define73.2%
Simplified73.2%
Taylor expanded in y around 0 32.8%
mul-1-neg32.8%
associate-/l*49.5%
distribute-lft-neg-out49.5%
+-commutative49.5%
*-commutative49.5%
fma-define49.5%
Simplified49.5%
Taylor expanded in z around inf 58.5%
associate-/l*66.2%
Simplified66.2%
Taylor expanded in t around 0 64.9%
mul-1-neg64.9%
associate-/l*65.8%
distribute-rgt-neg-in65.8%
mul-1-neg65.8%
associate-*r/65.8%
mul-1-neg65.8%
Simplified65.8%
Taylor expanded in t around 0 64.9%
mul-1-neg64.9%
associate-*r/65.8%
sub-neg65.8%
Simplified65.8%
if -5.4999999999999998e108 < z < -2.9999999999999998e-167Initial program 72.8%
associate-/l*83.0%
Simplified83.0%
Taylor expanded in y around 0 74.5%
mul-1-neg74.5%
associate-/l*82.9%
distribute-lft-neg-out82.9%
+-commutative82.9%
div-sub82.9%
distribute-rgt-out83.0%
sub-neg83.0%
associate-/r/88.0%
Simplified88.0%
Taylor expanded in t around inf 85.4%
mul-1-neg85.4%
unsub-neg85.4%
Simplified85.4%
Taylor expanded in z around 0 50.6%
Taylor expanded in x around inf 50.6%
mul-1-neg50.6%
unsub-neg50.6%
Simplified50.6%
if -2.9999999999999998e-167 < z < 3.55000000000000021e143Initial program 88.8%
associate-/l*93.3%
Simplified93.3%
Taylor expanded in t around inf 71.2%
Taylor expanded in z around 0 54.7%
associate-/l*61.8%
Simplified61.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ t (* a (/ t z)))))
(if (<= z -3.7e+99)
t_1
(if (<= z -1.55e-168)
(* x (- 1.0 (/ y a)))
(if (<= z 3.55e+143) (+ x (* t (/ y a))) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t + (a * (t / z));
double tmp;
if (z <= -3.7e+99) {
tmp = t_1;
} else if (z <= -1.55e-168) {
tmp = x * (1.0 - (y / a));
} else if (z <= 3.55e+143) {
tmp = x + (t * (y / a));
} 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 + (a * (t / z))
if (z <= (-3.7d+99)) then
tmp = t_1
else if (z <= (-1.55d-168)) then
tmp = x * (1.0d0 - (y / a))
else if (z <= 3.55d+143) then
tmp = x + (t * (y / a))
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 + (a * (t / z));
double tmp;
if (z <= -3.7e+99) {
tmp = t_1;
} else if (z <= -1.55e-168) {
tmp = x * (1.0 - (y / a));
} else if (z <= 3.55e+143) {
tmp = x + (t * (y / a));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t + (a * (t / z)) tmp = 0 if z <= -3.7e+99: tmp = t_1 elif z <= -1.55e-168: tmp = x * (1.0 - (y / a)) elif z <= 3.55e+143: tmp = x + (t * (y / a)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t + Float64(a * Float64(t / z))) tmp = 0.0 if (z <= -3.7e+99) tmp = t_1; elseif (z <= -1.55e-168) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (z <= 3.55e+143) tmp = Float64(x + Float64(t * Float64(y / a))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t + (a * (t / z)); tmp = 0.0; if (z <= -3.7e+99) tmp = t_1; elseif (z <= -1.55e-168) tmp = x * (1.0 - (y / a)); elseif (z <= 3.55e+143) tmp = x + (t * (y / a)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t + N[(a * N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -3.7e+99], t$95$1, If[LessEqual[z, -1.55e-168], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.55e+143], N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + a \cdot \frac{t}{z}\\
\mathbf{if}\;z \leq -3.7 \cdot 10^{+99}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -1.55 \cdot 10^{-168}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;z \leq 3.55 \cdot 10^{+143}:\\
\;\;\;\;x + t \cdot \frac{y}{a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -3.7000000000000001e99 or 3.55000000000000021e143 < z Initial program 37.2%
+-commutative37.2%
*-commutative37.2%
associate-/l*72.9%
fma-define73.0%
Simplified73.0%
Taylor expanded in y around 0 32.9%
mul-1-neg32.9%
associate-/l*47.6%
distribute-lft-neg-out47.6%
+-commutative47.6%
*-commutative47.6%
fma-define47.7%
Simplified47.7%
Taylor expanded in z around inf 57.5%
associate-/l*64.9%
Simplified64.9%
Taylor expanded in t around inf 53.4%
associate-/l*61.7%
Simplified61.7%
if -3.7000000000000001e99 < z < -1.55e-168Initial program 73.0%
associate-/l*85.2%
Simplified85.2%
Taylor expanded in y around 0 74.8%
mul-1-neg74.8%
associate-/l*85.1%
distribute-lft-neg-out85.1%
+-commutative85.1%
div-sub85.1%
distribute-rgt-out85.2%
sub-neg85.2%
associate-/r/88.9%
Simplified88.9%
Taylor expanded in t around inf 86.2%
mul-1-neg86.2%
unsub-neg86.2%
Simplified86.2%
Taylor expanded in z around 0 51.3%
Taylor expanded in x around inf 51.2%
mul-1-neg51.2%
unsub-neg51.2%
Simplified51.2%
if -1.55e-168 < z < 3.55000000000000021e143Initial program 88.8%
associate-/l*93.3%
Simplified93.3%
Taylor expanded in t around inf 71.2%
Taylor expanded in z around 0 54.7%
associate-/l*61.8%
Simplified61.8%
(FPCore (x y z t a) :precision binary64 (if (or (<= y -4.8e+136) (not (<= y 1.5e+53))) (+ x (/ y (/ (- a z) (- t x)))) (+ x (/ t (/ (- a z) (- y z))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((y <= -4.8e+136) || !(y <= 1.5e+53)) {
tmp = x + (y / ((a - z) / (t - x)));
} else {
tmp = x + (t / ((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 ((y <= (-4.8d+136)) .or. (.not. (y <= 1.5d+53))) then
tmp = x + (y / ((a - z) / (t - x)))
else
tmp = x + (t / ((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 ((y <= -4.8e+136) || !(y <= 1.5e+53)) {
tmp = x + (y / ((a - z) / (t - x)));
} else {
tmp = x + (t / ((a - z) / (y - z)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (y <= -4.8e+136) or not (y <= 1.5e+53): tmp = x + (y / ((a - z) / (t - x))) else: tmp = x + (t / ((a - z) / (y - z))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((y <= -4.8e+136) || !(y <= 1.5e+53)) tmp = Float64(x + Float64(y / Float64(Float64(a - z) / Float64(t - x)))); else tmp = Float64(x + Float64(t / Float64(Float64(a - z) / Float64(y - z)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((y <= -4.8e+136) || ~((y <= 1.5e+53))) tmp = x + (y / ((a - z) / (t - x))); else tmp = x + (t / ((a - z) / (y - z))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[y, -4.8e+136], N[Not[LessEqual[y, 1.5e+53]], $MachinePrecision]], N[(x + N[(y / N[(N[(a - z), $MachinePrecision] / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(t / N[(N[(a - z), $MachinePrecision] / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -4.8 \cdot 10^{+136} \lor \neg \left(y \leq 1.5 \cdot 10^{+53}\right):\\
\;\;\;\;x + \frac{y}{\frac{a - z}{t - x}}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{t}{\frac{a - z}{y - z}}\\
\end{array}
\end{array}
if y < -4.8000000000000001e136 or 1.49999999999999999e53 < y Initial program 73.5%
associate-/l*92.9%
Simplified92.9%
clear-num92.2%
un-div-inv92.3%
Applied egg-rr92.3%
Taylor expanded in y around inf 87.8%
if -4.8000000000000001e136 < y < 1.49999999999999999e53Initial program 67.9%
associate-/l*76.5%
Simplified76.5%
Taylor expanded in y around 0 66.6%
mul-1-neg66.6%
associate-/l*73.3%
distribute-lft-neg-out73.3%
+-commutative73.3%
div-sub73.3%
distribute-rgt-out76.5%
sub-neg76.5%
associate-/r/81.9%
Simplified81.9%
Taylor expanded in t around inf 72.1%
Final simplification77.9%
(FPCore (x y z t a) :precision binary64 (if (or (<= x -1.86e+143) (not (<= x 7e+70))) (* x (+ (/ (- y z) (- z a)) 1.0)) (+ x (/ t (/ (- a z) (- y z))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x <= -1.86e+143) || !(x <= 7e+70)) {
tmp = x * (((y - z) / (z - a)) + 1.0);
} else {
tmp = x + (t / ((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 ((x <= (-1.86d+143)) .or. (.not. (x <= 7d+70))) then
tmp = x * (((y - z) / (z - a)) + 1.0d0)
else
tmp = x + (t / ((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 ((x <= -1.86e+143) || !(x <= 7e+70)) {
tmp = x * (((y - z) / (z - a)) + 1.0);
} else {
tmp = x + (t / ((a - z) / (y - z)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (x <= -1.86e+143) or not (x <= 7e+70): tmp = x * (((y - z) / (z - a)) + 1.0) else: tmp = x + (t / ((a - z) / (y - z))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((x <= -1.86e+143) || !(x <= 7e+70)) tmp = Float64(x * Float64(Float64(Float64(y - z) / Float64(z - a)) + 1.0)); else tmp = Float64(x + Float64(t / Float64(Float64(a - z) / Float64(y - z)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((x <= -1.86e+143) || ~((x <= 7e+70))) tmp = x * (((y - z) / (z - a)) + 1.0); else tmp = x + (t / ((a - z) / (y - z))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[x, -1.86e+143], N[Not[LessEqual[x, 7e+70]], $MachinePrecision]], N[(x * N[(N[(N[(y - z), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(x + N[(t / N[(N[(a - z), $MachinePrecision] / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.86 \cdot 10^{+143} \lor \neg \left(x \leq 7 \cdot 10^{+70}\right):\\
\;\;\;\;x \cdot \left(\frac{y - z}{z - a} + 1\right)\\
\mathbf{else}:\\
\;\;\;\;x + \frac{t}{\frac{a - z}{y - z}}\\
\end{array}
\end{array}
if x < -1.8599999999999999e143 or 7.00000000000000005e70 < x Initial program 63.3%
+-commutative63.3%
*-commutative63.3%
associate-/l*81.9%
fma-define82.0%
Simplified82.0%
Taylor expanded in t around 0 58.6%
*-rgt-identity58.6%
mul-1-neg58.6%
associate-/l*71.5%
distribute-rgt-neg-in71.5%
mul-1-neg71.5%
distribute-lft-in71.6%
mul-1-neg71.6%
unsub-neg71.6%
Simplified71.6%
if -1.8599999999999999e143 < x < 7.00000000000000005e70Initial program 73.6%
associate-/l*84.5%
Simplified84.5%
Taylor expanded in y around 0 75.7%
mul-1-neg75.7%
associate-/l*82.1%
distribute-lft-neg-out82.1%
+-commutative82.1%
div-sub82.1%
distribute-rgt-out84.5%
sub-neg84.5%
associate-/r/90.0%
Simplified90.0%
Taylor expanded in t around inf 79.4%
Final simplification76.6%
(FPCore (x y z t a) :precision binary64 (if (or (<= x -1.45e+143) (not (<= x 4e+70))) (* x (+ (/ (- y z) (- z a)) 1.0)) (+ x (* t (/ (- y z) (- a z))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x <= -1.45e+143) || !(x <= 4e+70)) {
tmp = x * (((y - z) / (z - a)) + 1.0);
} else {
tmp = x + (t * ((y - z) / (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 ((x <= (-1.45d+143)) .or. (.not. (x <= 4d+70))) then
tmp = x * (((y - z) / (z - a)) + 1.0d0)
else
tmp = x + (t * ((y - z) / (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 ((x <= -1.45e+143) || !(x <= 4e+70)) {
tmp = x * (((y - z) / (z - a)) + 1.0);
} else {
tmp = x + (t * ((y - z) / (a - z)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (x <= -1.45e+143) or not (x <= 4e+70): tmp = x * (((y - z) / (z - a)) + 1.0) else: tmp = x + (t * ((y - z) / (a - z))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((x <= -1.45e+143) || !(x <= 4e+70)) tmp = Float64(x * Float64(Float64(Float64(y - z) / Float64(z - a)) + 1.0)); else tmp = Float64(x + Float64(t * Float64(Float64(y - z) / Float64(a - z)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((x <= -1.45e+143) || ~((x <= 4e+70))) tmp = x * (((y - z) / (z - a)) + 1.0); else tmp = x + (t * ((y - z) / (a - z))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[x, -1.45e+143], N[Not[LessEqual[x, 4e+70]], $MachinePrecision]], N[(x * N[(N[(N[(y - z), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(x + N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.45 \cdot 10^{+143} \lor \neg \left(x \leq 4 \cdot 10^{+70}\right):\\
\;\;\;\;x \cdot \left(\frac{y - z}{z - a} + 1\right)\\
\mathbf{else}:\\
\;\;\;\;x + t \cdot \frac{y - z}{a - z}\\
\end{array}
\end{array}
if x < -1.4499999999999999e143 or 4.00000000000000029e70 < x Initial program 63.3%
+-commutative63.3%
*-commutative63.3%
associate-/l*81.9%
fma-define82.0%
Simplified82.0%
Taylor expanded in t around 0 58.6%
*-rgt-identity58.6%
mul-1-neg58.6%
associate-/l*71.5%
distribute-rgt-neg-in71.5%
mul-1-neg71.5%
distribute-lft-in71.6%
mul-1-neg71.6%
unsub-neg71.6%
Simplified71.6%
if -1.4499999999999999e143 < x < 4.00000000000000029e70Initial program 73.6%
associate-/l*84.5%
Simplified84.5%
Taylor expanded in t around inf 63.2%
associate-/l*78.9%
Simplified78.9%
Final simplification76.3%
(FPCore (x y z t a)
:precision binary64
(if (<= a -3.2e-87)
(+ x (* t (/ (- y z) (- a z))))
(if (<= a 1.85e-140)
(+ t (/ (* (- t x) (- a y)) z))
(+ x (/ t (/ (- a z) (- y z)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -3.2e-87) {
tmp = x + (t * ((y - z) / (a - z)));
} else if (a <= 1.85e-140) {
tmp = t + (((t - x) * (a - y)) / z);
} else {
tmp = x + (t / ((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 (a <= (-3.2d-87)) then
tmp = x + (t * ((y - z) / (a - z)))
else if (a <= 1.85d-140) then
tmp = t + (((t - x) * (a - y)) / z)
else
tmp = x + (t / ((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 (a <= -3.2e-87) {
tmp = x + (t * ((y - z) / (a - z)));
} else if (a <= 1.85e-140) {
tmp = t + (((t - x) * (a - y)) / z);
} else {
tmp = x + (t / ((a - z) / (y - z)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -3.2e-87: tmp = x + (t * ((y - z) / (a - z))) elif a <= 1.85e-140: tmp = t + (((t - x) * (a - y)) / z) else: tmp = x + (t / ((a - z) / (y - z))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -3.2e-87) tmp = Float64(x + Float64(t * Float64(Float64(y - z) / Float64(a - z)))); elseif (a <= 1.85e-140) tmp = Float64(t + Float64(Float64(Float64(t - x) * Float64(a - y)) / z)); else tmp = Float64(x + Float64(t / Float64(Float64(a - z) / Float64(y - z)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -3.2e-87) tmp = x + (t * ((y - z) / (a - z))); elseif (a <= 1.85e-140) tmp = t + (((t - x) * (a - y)) / z); else tmp = x + (t / ((a - z) / (y - z))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -3.2e-87], N[(x + N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.85e-140], N[(t + N[(N[(N[(t - x), $MachinePrecision] * N[(a - y), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], N[(x + N[(t / N[(N[(a - z), $MachinePrecision] / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -3.2 \cdot 10^{-87}:\\
\;\;\;\;x + t \cdot \frac{y - z}{a - z}\\
\mathbf{elif}\;a \leq 1.85 \cdot 10^{-140}:\\
\;\;\;\;t + \frac{\left(t - x\right) \cdot \left(a - y\right)}{z}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{t}{\frac{a - z}{y - z}}\\
\end{array}
\end{array}
if a < -3.19999999999999979e-87Initial program 69.1%
associate-/l*85.6%
Simplified85.6%
Taylor expanded in t around inf 63.3%
associate-/l*75.3%
Simplified75.3%
if -3.19999999999999979e-87 < a < 1.84999999999999989e-140Initial program 64.8%
+-commutative64.8%
*-commutative64.8%
associate-/l*74.1%
fma-define74.2%
Simplified74.2%
Taylor expanded in z around inf 84.6%
associate--l+84.6%
associate-*r/84.6%
associate-*r/84.6%
mul-1-neg84.6%
div-sub84.7%
mul-1-neg84.7%
distribute-lft-out--84.7%
associate-*r/84.7%
mul-1-neg84.7%
unsub-neg84.7%
distribute-rgt-out--84.7%
Simplified84.7%
if 1.84999999999999989e-140 < a Initial program 75.2%
associate-/l*91.2%
Simplified91.2%
Taylor expanded in y around 0 80.2%
mul-1-neg80.2%
associate-/l*91.2%
distribute-lft-neg-out91.2%
+-commutative91.2%
div-sub91.2%
distribute-rgt-out91.2%
sub-neg91.2%
associate-/r/95.2%
Simplified95.2%
Taylor expanded in t around inf 82.5%
Final simplification80.8%
(FPCore (x y z t a)
:precision binary64
(if (<= y -2.7e+132)
(+ x (/ (- t x) (/ (- a z) y)))
(if (<= y 5.5e+53)
(+ x (/ t (/ (- a z) (- y z))))
(+ x (/ y (/ (- a z) (- t x)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -2.7e+132) {
tmp = x + ((t - x) / ((a - z) / y));
} else if (y <= 5.5e+53) {
tmp = x + (t / ((a - z) / (y - z)));
} else {
tmp = x + (y / ((a - z) / (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 (y <= (-2.7d+132)) then
tmp = x + ((t - x) / ((a - z) / y))
else if (y <= 5.5d+53) then
tmp = x + (t / ((a - z) / (y - z)))
else
tmp = x + (y / ((a - z) / (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 (y <= -2.7e+132) {
tmp = x + ((t - x) / ((a - z) / y));
} else if (y <= 5.5e+53) {
tmp = x + (t / ((a - z) / (y - z)));
} else {
tmp = x + (y / ((a - z) / (t - x)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if y <= -2.7e+132: tmp = x + ((t - x) / ((a - z) / y)) elif y <= 5.5e+53: tmp = x + (t / ((a - z) / (y - z))) else: tmp = x + (y / ((a - z) / (t - x))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (y <= -2.7e+132) tmp = Float64(x + Float64(Float64(t - x) / Float64(Float64(a - z) / y))); elseif (y <= 5.5e+53) tmp = Float64(x + Float64(t / Float64(Float64(a - z) / Float64(y - z)))); else tmp = Float64(x + Float64(y / Float64(Float64(a - z) / Float64(t - x)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (y <= -2.7e+132) tmp = x + ((t - x) / ((a - z) / y)); elseif (y <= 5.5e+53) tmp = x + (t / ((a - z) / (y - z))); else tmp = x + (y / ((a - z) / (t - x))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[y, -2.7e+132], N[(x + N[(N[(t - x), $MachinePrecision] / N[(N[(a - z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.5e+53], N[(x + N[(t / N[(N[(a - z), $MachinePrecision] / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(y / N[(N[(a - z), $MachinePrecision] / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -2.7 \cdot 10^{+132}:\\
\;\;\;\;x + \frac{t - x}{\frac{a - z}{y}}\\
\mathbf{elif}\;y \leq 5.5 \cdot 10^{+53}:\\
\;\;\;\;x + \frac{t}{\frac{a - z}{y - z}}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{y}{\frac{a - z}{t - x}}\\
\end{array}
\end{array}
if y < -2.7e132Initial program 69.0%
associate-/l*88.2%
Simplified88.2%
Taylor expanded in y around 0 69.1%
mul-1-neg69.1%
associate-/l*82.8%
distribute-lft-neg-out82.8%
+-commutative82.8%
div-sub82.8%
distribute-rgt-out88.2%
sub-neg88.2%
associate-/r/96.8%
Simplified96.8%
Taylor expanded in y around inf 89.8%
if -2.7e132 < y < 5.49999999999999975e53Initial program 67.9%
associate-/l*76.5%
Simplified76.5%
Taylor expanded in y around 0 66.6%
mul-1-neg66.6%
associate-/l*73.3%
distribute-lft-neg-out73.3%
+-commutative73.3%
div-sub73.3%
distribute-rgt-out76.5%
sub-neg76.5%
associate-/r/81.9%
Simplified81.9%
Taylor expanded in t around inf 72.1%
if 5.49999999999999975e53 < y Initial program 76.3%
associate-/l*96.0%
Simplified96.0%
clear-num96.0%
un-div-inv96.0%
Applied egg-rr96.0%
Taylor expanded in y around inf 91.5%
(FPCore (x y z t a) :precision binary64 (if (<= z -1.1e+117) (+ t (/ (* (- t x) a) z)) (if (<= z 3.55e+143) (+ x (/ (- t x) (/ a y))) (+ t (* a (/ (- t x) z))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.1e+117) {
tmp = t + (((t - x) * a) / z);
} else if (z <= 3.55e+143) {
tmp = x + ((t - x) / (a / y));
} else {
tmp = t + (a * ((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 (z <= (-1.1d+117)) then
tmp = t + (((t - x) * a) / z)
else if (z <= 3.55d+143) then
tmp = x + ((t - x) / (a / y))
else
tmp = t + (a * ((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 (z <= -1.1e+117) {
tmp = t + (((t - x) * a) / z);
} else if (z <= 3.55e+143) {
tmp = x + ((t - x) / (a / y));
} else {
tmp = t + (a * ((t - x) / z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1.1e+117: tmp = t + (((t - x) * a) / z) elif z <= 3.55e+143: tmp = x + ((t - x) / (a / y)) else: tmp = t + (a * ((t - x) / z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.1e+117) tmp = Float64(t + Float64(Float64(Float64(t - x) * a) / z)); elseif (z <= 3.55e+143) tmp = Float64(x + Float64(Float64(t - x) / Float64(a / y))); else tmp = Float64(t + Float64(a * Float64(Float64(t - x) / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1.1e+117) tmp = t + (((t - x) * a) / z); elseif (z <= 3.55e+143) tmp = x + ((t - x) / (a / y)); else tmp = t + (a * ((t - x) / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.1e+117], N[(t + N[(N[(N[(t - x), $MachinePrecision] * a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.55e+143], N[(x + N[(N[(t - x), $MachinePrecision] / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(a * N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.1 \cdot 10^{+117}:\\
\;\;\;\;t + \frac{\left(t - x\right) \cdot a}{z}\\
\mathbf{elif}\;z \leq 3.55 \cdot 10^{+143}:\\
\;\;\;\;x + \frac{t - x}{\frac{a}{y}}\\
\mathbf{else}:\\
\;\;\;\;t + a \cdot \frac{t - x}{z}\\
\end{array}
\end{array}
if z < -1.10000000000000007e117Initial program 34.7%
+-commutative34.7%
*-commutative34.7%
associate-/l*63.8%
fma-define63.9%
Simplified63.9%
Taylor expanded in y around 0 29.3%
mul-1-neg29.3%
associate-/l*35.8%
distribute-lft-neg-out35.8%
+-commutative35.8%
*-commutative35.8%
fma-define35.6%
Simplified35.6%
Taylor expanded in z around inf 65.1%
if -1.10000000000000007e117 < z < 3.55000000000000021e143Initial program 83.0%
associate-/l*89.6%
Simplified89.6%
Taylor expanded in y around 0 84.3%
mul-1-neg84.3%
associate-/l*84.1%
distribute-lft-neg-out84.1%
+-commutative84.1%
div-sub84.1%
distribute-rgt-out89.6%
sub-neg89.6%
associate-/r/92.5%
Simplified92.5%
Taylor expanded in z around 0 65.0%
if 3.55000000000000021e143 < z Initial program 37.1%
+-commutative37.1%
*-commutative37.1%
associate-/l*82.7%
fma-define82.8%
Simplified82.8%
Taylor expanded in y around 0 36.4%
mul-1-neg36.4%
associate-/l*63.5%
distribute-lft-neg-out63.5%
+-commutative63.5%
*-commutative63.5%
fma-define63.7%
Simplified63.7%
Taylor expanded in z around inf 51.6%
associate-/l*68.2%
Simplified68.2%
Final simplification65.4%
(FPCore (x y z t a) :precision binary64 (if (<= z -1e+112) (+ t (/ (* (- t x) a) z)) (if (<= z 3.55e+143) (+ x (* y (/ (- t x) a))) (+ t (* a (/ (- t x) z))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1e+112) {
tmp = t + (((t - x) * a) / z);
} else if (z <= 3.55e+143) {
tmp = x + (y * ((t - x) / a));
} else {
tmp = t + (a * ((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 (z <= (-1d+112)) then
tmp = t + (((t - x) * a) / z)
else if (z <= 3.55d+143) then
tmp = x + (y * ((t - x) / a))
else
tmp = t + (a * ((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 (z <= -1e+112) {
tmp = t + (((t - x) * a) / z);
} else if (z <= 3.55e+143) {
tmp = x + (y * ((t - x) / a));
} else {
tmp = t + (a * ((t - x) / z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1e+112: tmp = t + (((t - x) * a) / z) elif z <= 3.55e+143: tmp = x + (y * ((t - x) / a)) else: tmp = t + (a * ((t - x) / z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1e+112) tmp = Float64(t + Float64(Float64(Float64(t - x) * a) / z)); elseif (z <= 3.55e+143) tmp = Float64(x + Float64(y * Float64(Float64(t - x) / a))); else tmp = Float64(t + Float64(a * Float64(Float64(t - x) / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1e+112) tmp = t + (((t - x) * a) / z); elseif (z <= 3.55e+143) tmp = x + (y * ((t - x) / a)); else tmp = t + (a * ((t - x) / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1e+112], N[(t + N[(N[(N[(t - x), $MachinePrecision] * a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.55e+143], N[(x + N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(a * N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1 \cdot 10^{+112}:\\
\;\;\;\;t + \frac{\left(t - x\right) \cdot a}{z}\\
\mathbf{elif}\;z \leq 3.55 \cdot 10^{+143}:\\
\;\;\;\;x + y \cdot \frac{t - x}{a}\\
\mathbf{else}:\\
\;\;\;\;t + a \cdot \frac{t - x}{z}\\
\end{array}
\end{array}
if z < -9.9999999999999993e111Initial program 34.7%
+-commutative34.7%
*-commutative34.7%
associate-/l*63.8%
fma-define63.9%
Simplified63.9%
Taylor expanded in y around 0 29.3%
mul-1-neg29.3%
associate-/l*35.8%
distribute-lft-neg-out35.8%
+-commutative35.8%
*-commutative35.8%
fma-define35.6%
Simplified35.6%
Taylor expanded in z around inf 65.1%
if -9.9999999999999993e111 < z < 3.55000000000000021e143Initial program 83.0%
associate-/l*89.6%
Simplified89.6%
Taylor expanded in z around 0 57.9%
associate-/l*64.4%
Simplified64.4%
if 3.55000000000000021e143 < z Initial program 37.1%
+-commutative37.1%
*-commutative37.1%
associate-/l*82.7%
fma-define82.8%
Simplified82.8%
Taylor expanded in y around 0 36.4%
mul-1-neg36.4%
associate-/l*63.5%
distribute-lft-neg-out63.5%
+-commutative63.5%
*-commutative63.5%
fma-define63.7%
Simplified63.7%
Taylor expanded in z around inf 51.6%
associate-/l*68.2%
Simplified68.2%
Final simplification65.0%
(FPCore (x y z t a) :precision binary64 (if (<= z -4.5e+130) (+ t (/ (* (- t x) a) z)) (if (<= z 3.55e+143) (+ x (* t (/ y (- a z)))) (+ t (* a (/ (- t x) z))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -4.5e+130) {
tmp = t + (((t - x) * a) / z);
} else if (z <= 3.55e+143) {
tmp = x + (t * (y / (a - z)));
} else {
tmp = t + (a * ((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 (z <= (-4.5d+130)) then
tmp = t + (((t - x) * a) / z)
else if (z <= 3.55d+143) then
tmp = x + (t * (y / (a - z)))
else
tmp = t + (a * ((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 (z <= -4.5e+130) {
tmp = t + (((t - x) * a) / z);
} else if (z <= 3.55e+143) {
tmp = x + (t * (y / (a - z)));
} else {
tmp = t + (a * ((t - x) / z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -4.5e+130: tmp = t + (((t - x) * a) / z) elif z <= 3.55e+143: tmp = x + (t * (y / (a - z))) else: tmp = t + (a * ((t - x) / z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -4.5e+130) tmp = Float64(t + Float64(Float64(Float64(t - x) * a) / z)); elseif (z <= 3.55e+143) tmp = Float64(x + Float64(t * Float64(y / Float64(a - z)))); else tmp = Float64(t + Float64(a * Float64(Float64(t - x) / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -4.5e+130) tmp = t + (((t - x) * a) / z); elseif (z <= 3.55e+143) tmp = x + (t * (y / (a - z))); else tmp = t + (a * ((t - x) / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -4.5e+130], N[(t + N[(N[(N[(t - x), $MachinePrecision] * a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.55e+143], N[(x + N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(a * N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -4.5 \cdot 10^{+130}:\\
\;\;\;\;t + \frac{\left(t - x\right) \cdot a}{z}\\
\mathbf{elif}\;z \leq 3.55 \cdot 10^{+143}:\\
\;\;\;\;x + t \cdot \frac{y}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t + a \cdot \frac{t - x}{z}\\
\end{array}
\end{array}
if z < -4.50000000000000039e130Initial program 32.9%
+-commutative32.9%
*-commutative32.9%
associate-/l*62.7%
fma-define62.9%
Simplified62.9%
Taylor expanded in y around 0 30.1%
mul-1-neg30.1%
associate-/l*36.7%
distribute-lft-neg-out36.7%
+-commutative36.7%
*-commutative36.7%
fma-define36.6%
Simplified36.6%
Taylor expanded in z around inf 66.9%
if -4.50000000000000039e130 < z < 3.55000000000000021e143Initial program 83.1%
Taylor expanded in y around inf 72.0%
*-commutative72.0%
Simplified72.0%
Taylor expanded in t around inf 52.0%
associate-/l*57.6%
Simplified57.6%
if 3.55000000000000021e143 < z Initial program 37.1%
+-commutative37.1%
*-commutative37.1%
associate-/l*82.7%
fma-define82.8%
Simplified82.8%
Taylor expanded in y around 0 36.4%
mul-1-neg36.4%
associate-/l*63.5%
distribute-lft-neg-out63.5%
+-commutative63.5%
*-commutative63.5%
fma-define63.7%
Simplified63.7%
Taylor expanded in z around inf 51.6%
associate-/l*68.2%
Simplified68.2%
Final simplification60.3%
(FPCore (x y z t a) :precision binary64 (if (<= z -2.4e+195) (+ t (/ (* (- t x) (- a y)) z)) (+ x (* (- y z) (/ (- t x) (- a z))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.4e+195) {
tmp = t + (((t - x) * (a - y)) / z);
} else {
tmp = x + ((y - z) * ((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 <= (-2.4d+195)) then
tmp = t + (((t - x) * (a - y)) / z)
else
tmp = x + ((y - z) * ((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 <= -2.4e+195) {
tmp = t + (((t - x) * (a - y)) / z);
} else {
tmp = x + ((y - z) * ((t - x) / (a - z)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.4e+195: tmp = t + (((t - x) * (a - y)) / z) else: tmp = x + ((y - z) * ((t - x) / (a - z))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.4e+195) tmp = Float64(t + Float64(Float64(Float64(t - x) * Float64(a - y)) / z)); else tmp = Float64(x + Float64(Float64(y - z) * 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 <= -2.4e+195) tmp = t + (((t - x) * (a - y)) / z); else tmp = x + ((y - z) * ((t - x) / (a - z))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.4e+195], N[(t + N[(N[(N[(t - x), $MachinePrecision] * N[(a - y), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.4 \cdot 10^{+195}:\\
\;\;\;\;t + \frac{\left(t - x\right) \cdot \left(a - y\right)}{z}\\
\mathbf{else}:\\
\;\;\;\;x + \left(y - z\right) \cdot \frac{t - x}{a - z}\\
\end{array}
\end{array}
if z < -2.4000000000000003e195Initial program 24.7%
+-commutative24.7%
*-commutative24.7%
associate-/l*51.7%
fma-define51.9%
Simplified51.9%
Taylor expanded in z around inf 78.8%
associate--l+78.8%
associate-*r/78.8%
associate-*r/78.8%
mul-1-neg78.8%
div-sub78.9%
mul-1-neg78.9%
distribute-lft-out--78.9%
associate-*r/78.9%
mul-1-neg78.9%
unsub-neg78.9%
distribute-rgt-out--78.9%
Simplified78.9%
if -2.4000000000000003e195 < z Initial program 74.8%
associate-/l*87.1%
Simplified87.1%
Final simplification86.3%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -4e+95) (not (<= z 2e+143))) (+ t (* a (/ t z))) (* x (- 1.0 (/ y a)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -4e+95) || !(z <= 2e+143)) {
tmp = t + (a * (t / z));
} else {
tmp = x * (1.0 - (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 <= (-4d+95)) .or. (.not. (z <= 2d+143))) then
tmp = t + (a * (t / z))
else
tmp = x * (1.0d0 - (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 <= -4e+95) || !(z <= 2e+143)) {
tmp = t + (a * (t / z));
} else {
tmp = x * (1.0 - (y / a));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -4e+95) or not (z <= 2e+143): tmp = t + (a * (t / z)) else: tmp = x * (1.0 - (y / a)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -4e+95) || !(z <= 2e+143)) tmp = Float64(t + Float64(a * Float64(t / z))); else tmp = Float64(x * Float64(1.0 - Float64(y / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -4e+95) || ~((z <= 2e+143))) tmp = t + (a * (t / z)); else tmp = x * (1.0 - (y / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -4e+95], N[Not[LessEqual[z, 2e+143]], $MachinePrecision]], N[(t + N[(a * N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -4 \cdot 10^{+95} \lor \neg \left(z \leq 2 \cdot 10^{+143}\right):\\
\;\;\;\;t + a \cdot \frac{t}{z}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\end{array}
\end{array}
if z < -4.00000000000000008e95 or 2e143 < z Initial program 38.0%
+-commutative38.0%
*-commutative38.0%
associate-/l*73.3%
fma-define73.4%
Simplified73.4%
Taylor expanded in y around 0 32.4%
mul-1-neg32.4%
associate-/l*47.0%
distribute-lft-neg-out47.0%
+-commutative47.0%
*-commutative47.0%
fma-define47.1%
Simplified47.1%
Taylor expanded in z around inf 56.8%
associate-/l*64.1%
Simplified64.1%
Taylor expanded in t around inf 52.7%
associate-/l*60.8%
Simplified60.8%
if -4.00000000000000008e95 < z < 2e143Initial program 83.1%
associate-/l*90.4%
Simplified90.4%
Taylor expanded in y around 0 85.1%
mul-1-neg85.1%
associate-/l*84.8%
distribute-lft-neg-out84.8%
+-commutative84.8%
div-sub84.8%
distribute-rgt-out90.4%
sub-neg90.4%
associate-/r/92.8%
Simplified92.8%
Taylor expanded in t around inf 88.8%
mul-1-neg88.8%
unsub-neg88.8%
Simplified88.8%
Taylor expanded in z around 0 61.1%
Taylor expanded in x around inf 53.0%
mul-1-neg53.0%
unsub-neg53.0%
Simplified53.0%
Final simplification55.3%
(FPCore (x y z t a) :precision binary64 (if (<= z -5.5e+117) t (if (<= z 2.4e+143) (* x (- 1.0 (/ y a))) t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -5.5e+117) {
tmp = t;
} else if (z <= 2.4e+143) {
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 <= (-5.5d+117)) then
tmp = t
else if (z <= 2.4d+143) 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 <= -5.5e+117) {
tmp = t;
} else if (z <= 2.4e+143) {
tmp = x * (1.0 - (y / a));
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -5.5e+117: tmp = t elif z <= 2.4e+143: tmp = x * (1.0 - (y / a)) else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -5.5e+117) tmp = t; elseif (z <= 2.4e+143) 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 <= -5.5e+117) tmp = t; elseif (z <= 2.4e+143) tmp = x * (1.0 - (y / a)); else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -5.5e+117], t, If[LessEqual[z, 2.4e+143], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -5.5 \cdot 10^{+117}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 2.4 \cdot 10^{+143}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -5.49999999999999965e117 or 2.3999999999999998e143 < z Initial program 36.8%
+-commutative36.8%
*-commutative36.8%
associate-/l*73.5%
fma-define73.6%
Simplified73.6%
Taylor expanded in y around 0 32.4%
mul-1-neg32.4%
associate-/l*48.8%
distribute-lft-neg-out48.8%
+-commutative48.8%
*-commutative48.8%
fma-define48.8%
Simplified48.8%
Taylor expanded in a around 0 61.3%
if -5.49999999999999965e117 < z < 2.3999999999999998e143Initial program 82.9%
associate-/l*89.5%
Simplified89.5%
Taylor expanded in y around 0 84.8%
mul-1-neg84.8%
associate-/l*84.0%
distribute-lft-neg-out84.0%
+-commutative84.0%
div-sub84.0%
distribute-rgt-out89.5%
sub-neg89.5%
associate-/r/92.4%
Simplified92.4%
Taylor expanded in t around inf 88.4%
mul-1-neg88.4%
unsub-neg88.4%
Simplified88.4%
Taylor expanded in z around 0 60.7%
Taylor expanded in x around inf 52.7%
mul-1-neg52.7%
unsub-neg52.7%
Simplified52.7%
(FPCore (x y z t a) :precision binary64 (if (<= z -3.5e+70) t (if (<= z 2.05e-22) x t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -3.5e+70) {
tmp = t;
} else if (z <= 2.05e-22) {
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 <= (-3.5d+70)) then
tmp = t
else if (z <= 2.05d-22) 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 <= -3.5e+70) {
tmp = t;
} else if (z <= 2.05e-22) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -3.5e+70: tmp = t elif z <= 2.05e-22: tmp = x else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -3.5e+70) tmp = t; elseif (z <= 2.05e-22) tmp = x; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -3.5e+70) tmp = t; elseif (z <= 2.05e-22) tmp = x; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -3.5e+70], t, If[LessEqual[z, 2.05e-22], x, t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3.5 \cdot 10^{+70}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 2.05 \cdot 10^{-22}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -3.50000000000000002e70 or 2.05e-22 < z Initial program 49.2%
+-commutative49.2%
*-commutative49.2%
associate-/l*77.2%
fma-define77.3%
Simplified77.3%
Taylor expanded in y around 0 34.8%
mul-1-neg34.8%
associate-/l*42.3%
distribute-lft-neg-out42.3%
+-commutative42.3%
*-commutative42.3%
fma-define42.3%
Simplified42.3%
Taylor expanded in a around 0 46.6%
if -3.50000000000000002e70 < z < 2.05e-22Initial program 85.0%
+-commutative85.0%
*-commutative85.0%
associate-/l*93.9%
fma-define93.9%
Simplified93.9%
Taylor expanded in a around inf 36.4%
(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 69.9%
+-commutative69.9%
*-commutative69.9%
associate-/l*86.8%
fma-define86.9%
Simplified86.9%
Taylor expanded in y around 0 40.7%
mul-1-neg40.7%
associate-/l*45.4%
distribute-lft-neg-out45.4%
+-commutative45.4%
*-commutative45.4%
fma-define45.5%
Simplified45.5%
Taylor expanded in a around 0 24.5%
(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 2024163
(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))))