
(FPCore (x y z t a b) :precision binary64 (+ (- (- x (* (- y 1.0) z)) (* (- t 1.0) a)) (* (- (+ y t) 2.0) b)))
double code(double x, double y, double z, double t, double a, double b) {
return ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b);
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
code = ((x - ((y - 1.0d0) * z)) - ((t - 1.0d0) * a)) + (((y + t) - 2.0d0) * b)
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b);
}
def code(x, y, z, t, a, b): return ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b)
function code(x, y, z, t, a, b) return Float64(Float64(Float64(x - Float64(Float64(y - 1.0) * z)) - Float64(Float64(t - 1.0) * a)) + Float64(Float64(Float64(y + t) - 2.0) * b)) end
function tmp = code(x, y, z, t, a, b) tmp = ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(N[(x - N[(N[(y - 1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] - N[(N[(t - 1.0), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x - \left(y - 1\right) \cdot z\right) - \left(t - 1\right) \cdot a\right) + \left(\left(y + t\right) - 2\right) \cdot b
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 23 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b) :precision binary64 (+ (- (- x (* (- y 1.0) z)) (* (- t 1.0) a)) (* (- (+ y t) 2.0) b)))
double code(double x, double y, double z, double t, double a, double b) {
return ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b);
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
code = ((x - ((y - 1.0d0) * z)) - ((t - 1.0d0) * a)) + (((y + t) - 2.0d0) * b)
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b);
}
def code(x, y, z, t, a, b): return ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b)
function code(x, y, z, t, a, b) return Float64(Float64(Float64(x - Float64(Float64(y - 1.0) * z)) - Float64(Float64(t - 1.0) * a)) + Float64(Float64(Float64(y + t) - 2.0) * b)) end
function tmp = code(x, y, z, t, a, b) tmp = ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(N[(x - N[(N[(y - 1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] - N[(N[(t - 1.0), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x - \left(y - 1\right) \cdot z\right) - \left(t - 1\right) \cdot a\right) + \left(\left(y + t\right) - 2\right) \cdot b
\end{array}
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1
(+ (- (+ x (* z (- 1.0 y))) (* a (+ t -1.0))) (* b (- (+ t y) 2.0)))))
(if (<= t_1 INFINITY) t_1 (+ x (* t (- b a))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((x + (z * (1.0 - y))) - (a * (t + -1.0))) + (b * ((t + y) - 2.0));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = x + (t * (b - a));
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((x + (z * (1.0 - y))) - (a * (t + -1.0))) + (b * ((t + y) - 2.0));
double tmp;
if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = t_1;
} else {
tmp = x + (t * (b - a));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = ((x + (z * (1.0 - y))) - (a * (t + -1.0))) + (b * ((t + y) - 2.0)) tmp = 0 if t_1 <= math.inf: tmp = t_1 else: tmp = x + (t * (b - a)) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(x + Float64(z * Float64(1.0 - y))) - Float64(a * Float64(t + -1.0))) + Float64(b * Float64(Float64(t + y) - 2.0))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(x + Float64(t * Float64(b - a))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = ((x + (z * (1.0 - y))) - (a * (t + -1.0))) + (b * ((t + y) - 2.0)); tmp = 0.0; if (t_1 <= Inf) tmp = t_1; else tmp = x + (t * (b - a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(a * N[(t + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(x + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(x + z \cdot \left(1 - y\right)\right) - a \cdot \left(t + -1\right)\right) + b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{if}\;t_1 \leq \infty:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;x + t \cdot \left(b - a\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (-.f64 x (*.f64 (-.f64 y 1) z)) (*.f64 (-.f64 t 1) a)) (*.f64 (-.f64 (+.f64 y t) 2) b)) < +inf.0Initial program 100.0%
if +inf.0 < (+.f64 (-.f64 (-.f64 x (*.f64 (-.f64 y 1) z)) (*.f64 (-.f64 t 1) a)) (*.f64 (-.f64 (+.f64 y t) 2) b)) Initial program 0.0%
associate-+l-0.0%
*-commutative0.0%
*-commutative0.0%
sub-neg0.0%
metadata-eval0.0%
remove-double-neg0.0%
remove-double-neg0.0%
sub-neg0.0%
metadata-eval0.0%
associate--l+0.0%
Simplified0.0%
Taylor expanded in t around inf 40.0%
Taylor expanded in z around 0 54.3%
Final simplification97.3%
(FPCore (x y z t a b) :precision binary64 (fma (+ t (- y 2.0)) b (- x (fma (+ y -1.0) z (* a (+ t -1.0))))))
double code(double x, double y, double z, double t, double a, double b) {
return fma((t + (y - 2.0)), b, (x - fma((y + -1.0), z, (a * (t + -1.0)))));
}
function code(x, y, z, t, a, b) return fma(Float64(t + Float64(y - 2.0)), b, Float64(x - fma(Float64(y + -1.0), z, Float64(a * Float64(t + -1.0))))) end
code[x_, y_, z_, t_, a_, b_] := N[(N[(t + N[(y - 2.0), $MachinePrecision]), $MachinePrecision] * b + N[(x - N[(N[(y + -1.0), $MachinePrecision] * z + N[(a * N[(t + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(t + \left(y - 2\right), b, x - \mathsf{fma}\left(y + -1, z, a \cdot \left(t + -1\right)\right)\right)
\end{array}
Initial program 94.1%
+-commutative94.1%
fma-def95.7%
+-commutative95.7%
associate--l+95.7%
sub-neg95.7%
associate-+l-95.7%
fma-neg96.9%
sub-neg96.9%
metadata-eval96.9%
distribute-lft-neg-in96.9%
distribute-lft-neg-in96.9%
remove-double-neg96.9%
sub-neg96.9%
metadata-eval96.9%
Simplified96.9%
Final simplification96.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ a (+ x (* (- y 2.0) b))))
(t_2 (* t (- b a)))
(t_3 (+ x (* z (- 1.0 y)))))
(if (<= t -1250.0)
(+ (+ x z) t_2)
(if (<= t 1e-123)
t_1
(if (<= t 2.1e-34)
(+ t_3 (* y b))
(if (<= t 3.6e-12) t_1 (+ t_3 t_2)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a + (x + ((y - 2.0) * b));
double t_2 = t * (b - a);
double t_3 = x + (z * (1.0 - y));
double tmp;
if (t <= -1250.0) {
tmp = (x + z) + t_2;
} else if (t <= 1e-123) {
tmp = t_1;
} else if (t <= 2.1e-34) {
tmp = t_3 + (y * b);
} else if (t <= 3.6e-12) {
tmp = t_1;
} else {
tmp = t_3 + t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = a + (x + ((y - 2.0d0) * b))
t_2 = t * (b - a)
t_3 = x + (z * (1.0d0 - y))
if (t <= (-1250.0d0)) then
tmp = (x + z) + t_2
else if (t <= 1d-123) then
tmp = t_1
else if (t <= 2.1d-34) then
tmp = t_3 + (y * b)
else if (t <= 3.6d-12) then
tmp = t_1
else
tmp = t_3 + t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a + (x + ((y - 2.0) * b));
double t_2 = t * (b - a);
double t_3 = x + (z * (1.0 - y));
double tmp;
if (t <= -1250.0) {
tmp = (x + z) + t_2;
} else if (t <= 1e-123) {
tmp = t_1;
} else if (t <= 2.1e-34) {
tmp = t_3 + (y * b);
} else if (t <= 3.6e-12) {
tmp = t_1;
} else {
tmp = t_3 + t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = a + (x + ((y - 2.0) * b)) t_2 = t * (b - a) t_3 = x + (z * (1.0 - y)) tmp = 0 if t <= -1250.0: tmp = (x + z) + t_2 elif t <= 1e-123: tmp = t_1 elif t <= 2.1e-34: tmp = t_3 + (y * b) elif t <= 3.6e-12: tmp = t_1 else: tmp = t_3 + t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(a + Float64(x + Float64(Float64(y - 2.0) * b))) t_2 = Float64(t * Float64(b - a)) t_3 = Float64(x + Float64(z * Float64(1.0 - y))) tmp = 0.0 if (t <= -1250.0) tmp = Float64(Float64(x + z) + t_2); elseif (t <= 1e-123) tmp = t_1; elseif (t <= 2.1e-34) tmp = Float64(t_3 + Float64(y * b)); elseif (t <= 3.6e-12) tmp = t_1; else tmp = Float64(t_3 + t_2); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = a + (x + ((y - 2.0) * b)); t_2 = t * (b - a); t_3 = x + (z * (1.0 - y)); tmp = 0.0; if (t <= -1250.0) tmp = (x + z) + t_2; elseif (t <= 1e-123) tmp = t_1; elseif (t <= 2.1e-34) tmp = t_3 + (y * b); elseif (t <= 3.6e-12) tmp = t_1; else tmp = t_3 + t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a + N[(x + N[(N[(y - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1250.0], N[(N[(x + z), $MachinePrecision] + t$95$2), $MachinePrecision], If[LessEqual[t, 1e-123], t$95$1, If[LessEqual[t, 2.1e-34], N[(t$95$3 + N[(y * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.6e-12], t$95$1, N[(t$95$3 + t$95$2), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a + \left(x + \left(y - 2\right) \cdot b\right)\\
t_2 := t \cdot \left(b - a\right)\\
t_3 := x + z \cdot \left(1 - y\right)\\
\mathbf{if}\;t \leq -1250:\\
\;\;\;\;\left(x + z\right) + t_2\\
\mathbf{elif}\;t \leq 10^{-123}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 2.1 \cdot 10^{-34}:\\
\;\;\;\;t_3 + y \cdot b\\
\mathbf{elif}\;t \leq 3.6 \cdot 10^{-12}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_3 + t_2\\
\end{array}
\end{array}
if t < -1250Initial program 86.3%
associate-+l-86.3%
*-commutative86.3%
*-commutative86.3%
sub-neg86.3%
metadata-eval86.3%
remove-double-neg86.3%
remove-double-neg86.3%
sub-neg86.3%
metadata-eval86.3%
associate--l+86.3%
Simplified86.3%
Taylor expanded in t around inf 85.6%
Taylor expanded in y around 0 87.8%
mul-1-neg87.8%
Simplified87.8%
if -1250 < t < 1.0000000000000001e-123 or 2.1000000000000001e-34 < t < 3.6e-12Initial program 97.5%
associate-+l-97.5%
*-commutative97.5%
*-commutative97.5%
sub-neg97.5%
metadata-eval97.5%
remove-double-neg97.5%
remove-double-neg97.5%
sub-neg97.5%
metadata-eval97.5%
associate--l+97.5%
Simplified97.5%
Taylor expanded in z around 0 77.8%
Taylor expanded in t around 0 77.7%
if 1.0000000000000001e-123 < t < 2.1000000000000001e-34Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in y around inf 76.0%
mul-1-neg76.0%
distribute-rgt-neg-in76.0%
Simplified76.0%
if 3.6e-12 < t Initial program 92.4%
associate-+l-92.4%
*-commutative92.4%
*-commutative92.4%
sub-neg92.4%
metadata-eval92.4%
remove-double-neg92.4%
remove-double-neg92.4%
sub-neg92.4%
metadata-eval92.4%
associate--l+92.4%
Simplified92.4%
Taylor expanded in t around inf 89.9%
Final simplification82.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (* z (- 1.0 y))))
(t_2 (* b (- (+ t y) 2.0)))
(t_3 (+ x (* a (- 1.0 t)))))
(if (<= b -9.0)
t_2
(if (<= b -8.8e-272)
t_1
(if (<= b 2.1e-207)
t_3
(if (<= b 2.55e-140)
t_1
(if (<= b 1.55e-28) t_3 (if (<= b 6.1e+50) t_1 t_2))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (z * (1.0 - y));
double t_2 = b * ((t + y) - 2.0);
double t_3 = x + (a * (1.0 - t));
double tmp;
if (b <= -9.0) {
tmp = t_2;
} else if (b <= -8.8e-272) {
tmp = t_1;
} else if (b <= 2.1e-207) {
tmp = t_3;
} else if (b <= 2.55e-140) {
tmp = t_1;
} else if (b <= 1.55e-28) {
tmp = t_3;
} else if (b <= 6.1e+50) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = x + (z * (1.0d0 - y))
t_2 = b * ((t + y) - 2.0d0)
t_3 = x + (a * (1.0d0 - t))
if (b <= (-9.0d0)) then
tmp = t_2
else if (b <= (-8.8d-272)) then
tmp = t_1
else if (b <= 2.1d-207) then
tmp = t_3
else if (b <= 2.55d-140) then
tmp = t_1
else if (b <= 1.55d-28) then
tmp = t_3
else if (b <= 6.1d+50) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (z * (1.0 - y));
double t_2 = b * ((t + y) - 2.0);
double t_3 = x + (a * (1.0 - t));
double tmp;
if (b <= -9.0) {
tmp = t_2;
} else if (b <= -8.8e-272) {
tmp = t_1;
} else if (b <= 2.1e-207) {
tmp = t_3;
} else if (b <= 2.55e-140) {
tmp = t_1;
} else if (b <= 1.55e-28) {
tmp = t_3;
} else if (b <= 6.1e+50) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (z * (1.0 - y)) t_2 = b * ((t + y) - 2.0) t_3 = x + (a * (1.0 - t)) tmp = 0 if b <= -9.0: tmp = t_2 elif b <= -8.8e-272: tmp = t_1 elif b <= 2.1e-207: tmp = t_3 elif b <= 2.55e-140: tmp = t_1 elif b <= 1.55e-28: tmp = t_3 elif b <= 6.1e+50: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(z * Float64(1.0 - y))) t_2 = Float64(b * Float64(Float64(t + y) - 2.0)) t_3 = Float64(x + Float64(a * Float64(1.0 - t))) tmp = 0.0 if (b <= -9.0) tmp = t_2; elseif (b <= -8.8e-272) tmp = t_1; elseif (b <= 2.1e-207) tmp = t_3; elseif (b <= 2.55e-140) tmp = t_1; elseif (b <= 1.55e-28) tmp = t_3; elseif (b <= 6.1e+50) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (z * (1.0 - y)); t_2 = b * ((t + y) - 2.0); t_3 = x + (a * (1.0 - t)); tmp = 0.0; if (b <= -9.0) tmp = t_2; elseif (b <= -8.8e-272) tmp = t_1; elseif (b <= 2.1e-207) tmp = t_3; elseif (b <= 2.55e-140) tmp = t_1; elseif (b <= 1.55e-28) tmp = t_3; elseif (b <= 6.1e+50) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(x + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -9.0], t$95$2, If[LessEqual[b, -8.8e-272], t$95$1, If[LessEqual[b, 2.1e-207], t$95$3, If[LessEqual[b, 2.55e-140], t$95$1, If[LessEqual[b, 1.55e-28], t$95$3, If[LessEqual[b, 6.1e+50], t$95$1, t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + z \cdot \left(1 - y\right)\\
t_2 := b \cdot \left(\left(t + y\right) - 2\right)\\
t_3 := x + a \cdot \left(1 - t\right)\\
\mathbf{if}\;b \leq -9:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq -8.8 \cdot 10^{-272}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq 2.1 \cdot 10^{-207}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;b \leq 2.55 \cdot 10^{-140}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq 1.55 \cdot 10^{-28}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;b \leq 6.1 \cdot 10^{+50}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if b < -9 or 6.10000000000000026e50 < b Initial program 89.1%
associate-+l-89.1%
*-commutative89.1%
*-commutative89.1%
sub-neg89.1%
metadata-eval89.1%
remove-double-neg89.1%
remove-double-neg89.1%
sub-neg89.1%
metadata-eval89.1%
associate--l+89.1%
Simplified89.1%
Taylor expanded in b around inf 75.4%
if -9 < b < -8.79999999999999952e-272 or 2.10000000000000003e-207 < b < 2.5500000000000002e-140 or 1.54999999999999996e-28 < b < 6.10000000000000026e50Initial program 98.9%
associate-+l-98.9%
*-commutative98.9%
*-commutative98.9%
sub-neg98.9%
metadata-eval98.9%
remove-double-neg98.9%
remove-double-neg98.9%
sub-neg98.9%
metadata-eval98.9%
associate--l+98.9%
Simplified98.9%
Taylor expanded in t around inf 85.1%
Taylor expanded in t around 0 65.9%
if -8.79999999999999952e-272 < b < 2.10000000000000003e-207 or 2.5500000000000002e-140 < b < 1.54999999999999996e-28Initial program 97.5%
associate-+l-97.5%
*-commutative97.5%
*-commutative97.5%
sub-neg97.5%
metadata-eval97.5%
remove-double-neg97.5%
remove-double-neg97.5%
sub-neg97.5%
metadata-eval97.5%
associate--l+97.5%
Simplified97.5%
Taylor expanded in z around 0 74.3%
Taylor expanded in b around 0 61.8%
Final simplification69.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* z (- 1.0 y))) (t_2 (* t (- b a))))
(if (<= t -1000000000.0)
(+ (+ x z) t_2)
(if (<= t 5.5e-12)
(+ a (+ (+ x (* (- y 2.0) b)) t_1))
(+ (+ x t_1) t_2)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = z * (1.0 - y);
double t_2 = t * (b - a);
double tmp;
if (t <= -1000000000.0) {
tmp = (x + z) + t_2;
} else if (t <= 5.5e-12) {
tmp = a + ((x + ((y - 2.0) * b)) + t_1);
} else {
tmp = (x + t_1) + t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = z * (1.0d0 - y)
t_2 = t * (b - a)
if (t <= (-1000000000.0d0)) then
tmp = (x + z) + t_2
else if (t <= 5.5d-12) then
tmp = a + ((x + ((y - 2.0d0) * b)) + t_1)
else
tmp = (x + t_1) + t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = z * (1.0 - y);
double t_2 = t * (b - a);
double tmp;
if (t <= -1000000000.0) {
tmp = (x + z) + t_2;
} else if (t <= 5.5e-12) {
tmp = a + ((x + ((y - 2.0) * b)) + t_1);
} else {
tmp = (x + t_1) + t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = z * (1.0 - y) t_2 = t * (b - a) tmp = 0 if t <= -1000000000.0: tmp = (x + z) + t_2 elif t <= 5.5e-12: tmp = a + ((x + ((y - 2.0) * b)) + t_1) else: tmp = (x + t_1) + t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(z * Float64(1.0 - y)) t_2 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -1000000000.0) tmp = Float64(Float64(x + z) + t_2); elseif (t <= 5.5e-12) tmp = Float64(a + Float64(Float64(x + Float64(Float64(y - 2.0) * b)) + t_1)); else tmp = Float64(Float64(x + t_1) + t_2); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = z * (1.0 - y); t_2 = t * (b - a); tmp = 0.0; if (t <= -1000000000.0) tmp = (x + z) + t_2; elseif (t <= 5.5e-12) tmp = a + ((x + ((y - 2.0) * b)) + t_1); else tmp = (x + t_1) + t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1000000000.0], N[(N[(x + z), $MachinePrecision] + t$95$2), $MachinePrecision], If[LessEqual[t, 5.5e-12], N[(a + N[(N[(x + N[(N[(y - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]), $MachinePrecision], N[(N[(x + t$95$1), $MachinePrecision] + t$95$2), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \left(1 - y\right)\\
t_2 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -1000000000:\\
\;\;\;\;\left(x + z\right) + t_2\\
\mathbf{elif}\;t \leq 5.5 \cdot 10^{-12}:\\
\;\;\;\;a + \left(\left(x + \left(y - 2\right) \cdot b\right) + t_1\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x + t_1\right) + t_2\\
\end{array}
\end{array}
if t < -1e9Initial program 86.3%
associate-+l-86.3%
*-commutative86.3%
*-commutative86.3%
sub-neg86.3%
metadata-eval86.3%
remove-double-neg86.3%
remove-double-neg86.3%
sub-neg86.3%
metadata-eval86.3%
associate--l+86.3%
Simplified86.3%
Taylor expanded in t around inf 85.6%
Taylor expanded in y around 0 87.8%
mul-1-neg87.8%
Simplified87.8%
if -1e9 < t < 5.5000000000000004e-12Initial program 97.8%
sub-neg97.8%
+-commutative97.8%
associate-+l+97.8%
*-commutative97.8%
distribute-rgt-neg-in97.8%
+-commutative97.8%
fma-def97.8%
neg-sub097.8%
associate--r-97.8%
neg-sub097.8%
+-commutative97.8%
sub-neg97.8%
fma-def98.6%
sub-neg98.6%
associate-+l+98.6%
metadata-eval98.6%
sub-neg98.6%
+-commutative98.6%
Simplified98.6%
Taylor expanded in t around 0 97.8%
if 5.5000000000000004e-12 < t Initial program 92.4%
associate-+l-92.4%
*-commutative92.4%
*-commutative92.4%
sub-neg92.4%
metadata-eval92.4%
remove-double-neg92.4%
remove-double-neg92.4%
sub-neg92.4%
metadata-eval92.4%
associate--l+92.4%
Simplified92.4%
Taylor expanded in t around inf 89.9%
Final simplification93.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ a (+ x (* (- y 2.0) b)))) (t_2 (+ (+ x z) (* t (- b a)))))
(if (<= t -42000000.0)
t_2
(if (<= t 2.3e-120)
t_1
(if (<= t 1.05e-39)
(+ (+ x (* z (- 1.0 y))) (* y b))
(if (<= t 5.5e-12) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a + (x + ((y - 2.0) * b));
double t_2 = (x + z) + (t * (b - a));
double tmp;
if (t <= -42000000.0) {
tmp = t_2;
} else if (t <= 2.3e-120) {
tmp = t_1;
} else if (t <= 1.05e-39) {
tmp = (x + (z * (1.0 - y))) + (y * b);
} else if (t <= 5.5e-12) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = a + (x + ((y - 2.0d0) * b))
t_2 = (x + z) + (t * (b - a))
if (t <= (-42000000.0d0)) then
tmp = t_2
else if (t <= 2.3d-120) then
tmp = t_1
else if (t <= 1.05d-39) then
tmp = (x + (z * (1.0d0 - y))) + (y * b)
else if (t <= 5.5d-12) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a + (x + ((y - 2.0) * b));
double t_2 = (x + z) + (t * (b - a));
double tmp;
if (t <= -42000000.0) {
tmp = t_2;
} else if (t <= 2.3e-120) {
tmp = t_1;
} else if (t <= 1.05e-39) {
tmp = (x + (z * (1.0 - y))) + (y * b);
} else if (t <= 5.5e-12) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = a + (x + ((y - 2.0) * b)) t_2 = (x + z) + (t * (b - a)) tmp = 0 if t <= -42000000.0: tmp = t_2 elif t <= 2.3e-120: tmp = t_1 elif t <= 1.05e-39: tmp = (x + (z * (1.0 - y))) + (y * b) elif t <= 5.5e-12: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(a + Float64(x + Float64(Float64(y - 2.0) * b))) t_2 = Float64(Float64(x + z) + Float64(t * Float64(b - a))) tmp = 0.0 if (t <= -42000000.0) tmp = t_2; elseif (t <= 2.3e-120) tmp = t_1; elseif (t <= 1.05e-39) tmp = Float64(Float64(x + Float64(z * Float64(1.0 - y))) + Float64(y * b)); elseif (t <= 5.5e-12) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = a + (x + ((y - 2.0) * b)); t_2 = (x + z) + (t * (b - a)); tmp = 0.0; if (t <= -42000000.0) tmp = t_2; elseif (t <= 2.3e-120) tmp = t_1; elseif (t <= 1.05e-39) tmp = (x + (z * (1.0 - y))) + (y * b); elseif (t <= 5.5e-12) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a + N[(x + N[(N[(y - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x + z), $MachinePrecision] + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -42000000.0], t$95$2, If[LessEqual[t, 2.3e-120], t$95$1, If[LessEqual[t, 1.05e-39], N[(N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(y * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.5e-12], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a + \left(x + \left(y - 2\right) \cdot b\right)\\
t_2 := \left(x + z\right) + t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -42000000:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 2.3 \cdot 10^{-120}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 1.05 \cdot 10^{-39}:\\
\;\;\;\;\left(x + z \cdot \left(1 - y\right)\right) + y \cdot b\\
\mathbf{elif}\;t \leq 5.5 \cdot 10^{-12}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -4.2e7 or 5.5000000000000004e-12 < t Initial program 89.7%
associate-+l-89.7%
*-commutative89.7%
*-commutative89.7%
sub-neg89.7%
metadata-eval89.7%
remove-double-neg89.7%
remove-double-neg89.7%
sub-neg89.7%
metadata-eval89.7%
associate--l+89.7%
Simplified89.7%
Taylor expanded in t around inf 88.1%
Taylor expanded in y around 0 86.3%
mul-1-neg86.3%
Simplified86.3%
if -4.2e7 < t < 2.29999999999999986e-120 or 1.04999999999999997e-39 < t < 5.5000000000000004e-12Initial program 97.5%
associate-+l-97.5%
*-commutative97.5%
*-commutative97.5%
sub-neg97.5%
metadata-eval97.5%
remove-double-neg97.5%
remove-double-neg97.5%
sub-neg97.5%
metadata-eval97.5%
associate--l+97.5%
Simplified97.5%
Taylor expanded in z around 0 77.8%
Taylor expanded in t around 0 77.7%
if 2.29999999999999986e-120 < t < 1.04999999999999997e-39Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in y around inf 76.0%
mul-1-neg76.0%
distribute-rgt-neg-in76.0%
Simplified76.0%
Final simplification81.5%
(FPCore (x y z t a b) :precision binary64 (if (or (<= b -1.35e+69) (not (<= b 5.8e+58))) (* b (- (+ t y) 2.0)) (+ (+ x (* z (- 1.0 y))) (- a (* t a)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((b <= -1.35e+69) || !(b <= 5.8e+58)) {
tmp = b * ((t + y) - 2.0);
} else {
tmp = (x + (z * (1.0 - y))) + (a - (t * a));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
real(8) :: tmp
if ((b <= (-1.35d+69)) .or. (.not. (b <= 5.8d+58))) then
tmp = b * ((t + y) - 2.0d0)
else
tmp = (x + (z * (1.0d0 - y))) + (a - (t * a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((b <= -1.35e+69) || !(b <= 5.8e+58)) {
tmp = b * ((t + y) - 2.0);
} else {
tmp = (x + (z * (1.0 - y))) + (a - (t * a));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (b <= -1.35e+69) or not (b <= 5.8e+58): tmp = b * ((t + y) - 2.0) else: tmp = (x + (z * (1.0 - y))) + (a - (t * a)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((b <= -1.35e+69) || !(b <= 5.8e+58)) tmp = Float64(b * Float64(Float64(t + y) - 2.0)); else tmp = Float64(Float64(x + Float64(z * Float64(1.0 - y))) + Float64(a - Float64(t * a))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((b <= -1.35e+69) || ~((b <= 5.8e+58))) tmp = b * ((t + y) - 2.0); else tmp = (x + (z * (1.0 - y))) + (a - (t * a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[b, -1.35e+69], N[Not[LessEqual[b, 5.8e+58]], $MachinePrecision]], N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(a - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.35 \cdot 10^{+69} \lor \neg \left(b \leq 5.8 \cdot 10^{+58}\right):\\
\;\;\;\;b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x + z \cdot \left(1 - y\right)\right) + \left(a - t \cdot a\right)\\
\end{array}
\end{array}
if b < -1.3499999999999999e69 or 5.80000000000000004e58 < b Initial program 88.0%
associate-+l-88.0%
*-commutative88.0%
*-commutative88.0%
sub-neg88.0%
metadata-eval88.0%
remove-double-neg88.0%
remove-double-neg88.0%
sub-neg88.0%
metadata-eval88.0%
associate--l+88.0%
Simplified88.0%
Taylor expanded in b around inf 78.4%
if -1.3499999999999999e69 < b < 5.80000000000000004e58Initial program 98.6%
associate-+l-98.6%
*-commutative98.6%
*-commutative98.6%
sub-neg98.6%
metadata-eval98.6%
remove-double-neg98.6%
remove-double-neg98.6%
sub-neg98.6%
metadata-eval98.6%
associate--l+98.6%
Simplified98.6%
Taylor expanded in a around inf 85.9%
sub-neg85.9%
metadata-eval85.9%
+-commutative85.9%
*-commutative85.9%
+-commutative85.9%
distribute-rgt-in85.9%
fma-def85.9%
mul-1-neg85.9%
fma-neg85.9%
Simplified85.9%
Final simplification82.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* a (- 1.0 t))))
(if (<= a -6e-10)
t_1
(if (<= a -1.05e-66)
(* y b)
(if (<= a 4.2e-304)
(* t b)
(if (<= a 2e-169) (* y (- z)) (if (<= a 7.5e+126) (+ x z) t_1)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a * (1.0 - t);
double tmp;
if (a <= -6e-10) {
tmp = t_1;
} else if (a <= -1.05e-66) {
tmp = y * b;
} else if (a <= 4.2e-304) {
tmp = t * b;
} else if (a <= 2e-169) {
tmp = y * -z;
} else if (a <= 7.5e+126) {
tmp = x + z;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = a * (1.0d0 - t)
if (a <= (-6d-10)) then
tmp = t_1
else if (a <= (-1.05d-66)) then
tmp = y * b
else if (a <= 4.2d-304) then
tmp = t * b
else if (a <= 2d-169) then
tmp = y * -z
else if (a <= 7.5d+126) then
tmp = x + 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 b) {
double t_1 = a * (1.0 - t);
double tmp;
if (a <= -6e-10) {
tmp = t_1;
} else if (a <= -1.05e-66) {
tmp = y * b;
} else if (a <= 4.2e-304) {
tmp = t * b;
} else if (a <= 2e-169) {
tmp = y * -z;
} else if (a <= 7.5e+126) {
tmp = x + z;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = a * (1.0 - t) tmp = 0 if a <= -6e-10: tmp = t_1 elif a <= -1.05e-66: tmp = y * b elif a <= 4.2e-304: tmp = t * b elif a <= 2e-169: tmp = y * -z elif a <= 7.5e+126: tmp = x + z else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(a * Float64(1.0 - t)) tmp = 0.0 if (a <= -6e-10) tmp = t_1; elseif (a <= -1.05e-66) tmp = Float64(y * b); elseif (a <= 4.2e-304) tmp = Float64(t * b); elseif (a <= 2e-169) tmp = Float64(y * Float64(-z)); elseif (a <= 7.5e+126) tmp = Float64(x + z); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = a * (1.0 - t); tmp = 0.0; if (a <= -6e-10) tmp = t_1; elseif (a <= -1.05e-66) tmp = y * b; elseif (a <= 4.2e-304) tmp = t * b; elseif (a <= 2e-169) tmp = y * -z; elseif (a <= 7.5e+126) tmp = x + z; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -6e-10], t$95$1, If[LessEqual[a, -1.05e-66], N[(y * b), $MachinePrecision], If[LessEqual[a, 4.2e-304], N[(t * b), $MachinePrecision], If[LessEqual[a, 2e-169], N[(y * (-z)), $MachinePrecision], If[LessEqual[a, 7.5e+126], N[(x + z), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(1 - t\right)\\
\mathbf{if}\;a \leq -6 \cdot 10^{-10}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -1.05 \cdot 10^{-66}:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;a \leq 4.2 \cdot 10^{-304}:\\
\;\;\;\;t \cdot b\\
\mathbf{elif}\;a \leq 2 \cdot 10^{-169}:\\
\;\;\;\;y \cdot \left(-z\right)\\
\mathbf{elif}\;a \leq 7.5 \cdot 10^{+126}:\\
\;\;\;\;x + z\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if a < -6e-10 or 7.5000000000000006e126 < a Initial program 89.8%
associate-+l-89.8%
*-commutative89.8%
*-commutative89.8%
sub-neg89.8%
metadata-eval89.8%
remove-double-neg89.8%
remove-double-neg89.8%
sub-neg89.8%
metadata-eval89.8%
associate--l+89.8%
Simplified89.8%
Taylor expanded in a around inf 56.6%
if -6e-10 < a < -1.05e-66Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in b around inf 65.5%
Taylor expanded in y around inf 51.5%
if -1.05e-66 < a < 4.20000000000000016e-304Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in b around inf 57.4%
Taylor expanded in t around inf 36.1%
if 4.20000000000000016e-304 < a < 2.00000000000000004e-169Initial program 91.7%
associate-+l-91.7%
*-commutative91.7%
*-commutative91.7%
sub-neg91.7%
metadata-eval91.7%
remove-double-neg91.7%
remove-double-neg91.7%
sub-neg91.7%
metadata-eval91.7%
associate--l+91.7%
Simplified91.7%
Taylor expanded in z around inf 57.0%
Taylor expanded in y around inf 45.0%
mul-1-neg45.0%
distribute-rgt-neg-in45.0%
Simplified45.0%
if 2.00000000000000004e-169 < a < 7.5000000000000006e126Initial program 97.0%
associate-+l-97.0%
*-commutative97.0%
*-commutative97.0%
sub-neg97.0%
metadata-eval97.0%
remove-double-neg97.0%
remove-double-neg97.0%
sub-neg97.0%
metadata-eval97.0%
associate--l+97.0%
Simplified97.0%
Taylor expanded in y around inf 63.1%
mul-1-neg63.1%
distribute-rgt-neg-in63.1%
Simplified63.1%
Taylor expanded in y around 0 34.3%
cancel-sign-sub-inv34.3%
metadata-eval34.3%
*-lft-identity34.3%
Simplified34.3%
Final simplification46.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (- b a))))
(if (<= t -6.9)
t_1
(if (<= t -7.5e-250)
(* y b)
(if (<= t 4.05e-277)
(+ x z)
(if (<= t 2.2e-265)
(* y b)
(if (<= t 70000000.0) (* z (- 1.0 y)) t_1)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -6.9) {
tmp = t_1;
} else if (t <= -7.5e-250) {
tmp = y * b;
} else if (t <= 4.05e-277) {
tmp = x + z;
} else if (t <= 2.2e-265) {
tmp = y * b;
} else if (t <= 70000000.0) {
tmp = z * (1.0 - y);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = t * (b - a)
if (t <= (-6.9d0)) then
tmp = t_1
else if (t <= (-7.5d-250)) then
tmp = y * b
else if (t <= 4.05d-277) then
tmp = x + z
else if (t <= 2.2d-265) then
tmp = y * b
else if (t <= 70000000.0d0) then
tmp = z * (1.0d0 - y)
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 b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -6.9) {
tmp = t_1;
} else if (t <= -7.5e-250) {
tmp = y * b;
} else if (t <= 4.05e-277) {
tmp = x + z;
} else if (t <= 2.2e-265) {
tmp = y * b;
} else if (t <= 70000000.0) {
tmp = z * (1.0 - y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = t * (b - a) tmp = 0 if t <= -6.9: tmp = t_1 elif t <= -7.5e-250: tmp = y * b elif t <= 4.05e-277: tmp = x + z elif t <= 2.2e-265: tmp = y * b elif t <= 70000000.0: tmp = z * (1.0 - y) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -6.9) tmp = t_1; elseif (t <= -7.5e-250) tmp = Float64(y * b); elseif (t <= 4.05e-277) tmp = Float64(x + z); elseif (t <= 2.2e-265) tmp = Float64(y * b); elseif (t <= 70000000.0) tmp = Float64(z * Float64(1.0 - y)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = t * (b - a); tmp = 0.0; if (t <= -6.9) tmp = t_1; elseif (t <= -7.5e-250) tmp = y * b; elseif (t <= 4.05e-277) tmp = x + z; elseif (t <= 2.2e-265) tmp = y * b; elseif (t <= 70000000.0) tmp = z * (1.0 - y); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -6.9], t$95$1, If[LessEqual[t, -7.5e-250], N[(y * b), $MachinePrecision], If[LessEqual[t, 4.05e-277], N[(x + z), $MachinePrecision], If[LessEqual[t, 2.2e-265], N[(y * b), $MachinePrecision], If[LessEqual[t, 70000000.0], N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -6.9:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -7.5 \cdot 10^{-250}:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;t \leq 4.05 \cdot 10^{-277}:\\
\;\;\;\;x + z\\
\mathbf{elif}\;t \leq 2.2 \cdot 10^{-265}:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;t \leq 70000000:\\
\;\;\;\;z \cdot \left(1 - y\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -6.9000000000000004 or 7e7 < t Initial program 90.2%
associate-+l-90.2%
*-commutative90.2%
*-commutative90.2%
sub-neg90.2%
metadata-eval90.2%
remove-double-neg90.2%
remove-double-neg90.2%
sub-neg90.2%
metadata-eval90.2%
associate--l+90.2%
Simplified90.2%
Taylor expanded in t around inf 67.5%
if -6.9000000000000004 < t < -7.50000000000000009e-250 or 4.04999999999999988e-277 < t < 2.2000000000000001e-265Initial program 96.6%
associate-+l-96.6%
*-commutative96.6%
*-commutative96.6%
sub-neg96.6%
metadata-eval96.6%
remove-double-neg96.6%
remove-double-neg96.6%
sub-neg96.6%
metadata-eval96.6%
associate--l+96.6%
Simplified96.6%
Taylor expanded in b around inf 50.9%
Taylor expanded in y around inf 41.5%
if -7.50000000000000009e-250 < t < 4.04999999999999988e-277Initial program 96.3%
associate-+l-96.3%
*-commutative96.3%
*-commutative96.3%
sub-neg96.3%
metadata-eval96.3%
remove-double-neg96.3%
remove-double-neg96.3%
sub-neg96.3%
metadata-eval96.3%
associate--l+96.3%
Simplified96.3%
Taylor expanded in y around inf 65.6%
mul-1-neg65.6%
distribute-rgt-neg-in65.6%
Simplified65.6%
Taylor expanded in y around 0 36.8%
cancel-sign-sub-inv36.8%
metadata-eval36.8%
*-lft-identity36.8%
Simplified36.8%
if 2.2000000000000001e-265 < t < 7e7Initial program 98.3%
associate-+l-98.3%
*-commutative98.3%
*-commutative98.3%
sub-neg98.3%
metadata-eval98.3%
remove-double-neg98.3%
remove-double-neg98.3%
sub-neg98.3%
metadata-eval98.3%
associate--l+98.3%
Simplified98.3%
Taylor expanded in z around inf 43.6%
Final simplification52.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (* z (- 1.0 y)))) (t_2 (* b (- (+ t y) 2.0))))
(if (<= b -310000.0)
t_2
(if (<= b -1.55e-271)
t_1
(if (<= b 8.5e-213) (* a (- 1.0 t)) (if (<= b 7.5e+52) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (z * (1.0 - y));
double t_2 = b * ((t + y) - 2.0);
double tmp;
if (b <= -310000.0) {
tmp = t_2;
} else if (b <= -1.55e-271) {
tmp = t_1;
} else if (b <= 8.5e-213) {
tmp = a * (1.0 - t);
} else if (b <= 7.5e+52) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x + (z * (1.0d0 - y))
t_2 = b * ((t + y) - 2.0d0)
if (b <= (-310000.0d0)) then
tmp = t_2
else if (b <= (-1.55d-271)) then
tmp = t_1
else if (b <= 8.5d-213) then
tmp = a * (1.0d0 - t)
else if (b <= 7.5d+52) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (z * (1.0 - y));
double t_2 = b * ((t + y) - 2.0);
double tmp;
if (b <= -310000.0) {
tmp = t_2;
} else if (b <= -1.55e-271) {
tmp = t_1;
} else if (b <= 8.5e-213) {
tmp = a * (1.0 - t);
} else if (b <= 7.5e+52) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (z * (1.0 - y)) t_2 = b * ((t + y) - 2.0) tmp = 0 if b <= -310000.0: tmp = t_2 elif b <= -1.55e-271: tmp = t_1 elif b <= 8.5e-213: tmp = a * (1.0 - t) elif b <= 7.5e+52: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(z * Float64(1.0 - y))) t_2 = Float64(b * Float64(Float64(t + y) - 2.0)) tmp = 0.0 if (b <= -310000.0) tmp = t_2; elseif (b <= -1.55e-271) tmp = t_1; elseif (b <= 8.5e-213) tmp = Float64(a * Float64(1.0 - t)); elseif (b <= 7.5e+52) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (z * (1.0 - y)); t_2 = b * ((t + y) - 2.0); tmp = 0.0; if (b <= -310000.0) tmp = t_2; elseif (b <= -1.55e-271) tmp = t_1; elseif (b <= 8.5e-213) tmp = a * (1.0 - t); elseif (b <= 7.5e+52) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -310000.0], t$95$2, If[LessEqual[b, -1.55e-271], t$95$1, If[LessEqual[b, 8.5e-213], N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 7.5e+52], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + z \cdot \left(1 - y\right)\\
t_2 := b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{if}\;b \leq -310000:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq -1.55 \cdot 10^{-271}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq 8.5 \cdot 10^{-213}:\\
\;\;\;\;a \cdot \left(1 - t\right)\\
\mathbf{elif}\;b \leq 7.5 \cdot 10^{+52}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if b < -3.1e5 or 7.49999999999999995e52 < b Initial program 89.1%
associate-+l-89.1%
*-commutative89.1%
*-commutative89.1%
sub-neg89.1%
metadata-eval89.1%
remove-double-neg89.1%
remove-double-neg89.1%
sub-neg89.1%
metadata-eval89.1%
associate--l+89.1%
Simplified89.1%
Taylor expanded in b around inf 75.4%
if -3.1e5 < b < -1.54999999999999995e-271 or 8.49999999999999994e-213 < b < 7.49999999999999995e52Initial program 99.1%
associate-+l-99.1%
*-commutative99.1%
*-commutative99.1%
sub-neg99.1%
metadata-eval99.1%
remove-double-neg99.1%
remove-double-neg99.1%
sub-neg99.1%
metadata-eval99.1%
associate--l+99.1%
Simplified99.1%
Taylor expanded in t around inf 83.4%
Taylor expanded in t around 0 60.5%
if -1.54999999999999995e-271 < b < 8.49999999999999994e-213Initial program 93.8%
associate-+l-93.8%
*-commutative93.8%
*-commutative93.8%
sub-neg93.8%
metadata-eval93.8%
remove-double-neg93.8%
remove-double-neg93.8%
sub-neg93.8%
metadata-eval93.8%
associate--l+93.8%
Simplified93.8%
Taylor expanded in a around inf 69.4%
Final simplification68.0%
(FPCore (x y z t a b)
:precision binary64
(if (<= y -4.7e+73)
(* y b)
(if (<= y 4.7e-297)
(* t b)
(if (<= y 4.4e-186)
z
(if (<= y 2.5e-159) (* t b) (if (<= y 1.15e+70) x (* y b)))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (y <= -4.7e+73) {
tmp = y * b;
} else if (y <= 4.7e-297) {
tmp = t * b;
} else if (y <= 4.4e-186) {
tmp = z;
} else if (y <= 2.5e-159) {
tmp = t * b;
} else if (y <= 1.15e+70) {
tmp = x;
} else {
tmp = y * b;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
real(8) :: tmp
if (y <= (-4.7d+73)) then
tmp = y * b
else if (y <= 4.7d-297) then
tmp = t * b
else if (y <= 4.4d-186) then
tmp = z
else if (y <= 2.5d-159) then
tmp = t * b
else if (y <= 1.15d+70) then
tmp = x
else
tmp = y * b
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (y <= -4.7e+73) {
tmp = y * b;
} else if (y <= 4.7e-297) {
tmp = t * b;
} else if (y <= 4.4e-186) {
tmp = z;
} else if (y <= 2.5e-159) {
tmp = t * b;
} else if (y <= 1.15e+70) {
tmp = x;
} else {
tmp = y * b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if y <= -4.7e+73: tmp = y * b elif y <= 4.7e-297: tmp = t * b elif y <= 4.4e-186: tmp = z elif y <= 2.5e-159: tmp = t * b elif y <= 1.15e+70: tmp = x else: tmp = y * b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (y <= -4.7e+73) tmp = Float64(y * b); elseif (y <= 4.7e-297) tmp = Float64(t * b); elseif (y <= 4.4e-186) tmp = z; elseif (y <= 2.5e-159) tmp = Float64(t * b); elseif (y <= 1.15e+70) tmp = x; else tmp = Float64(y * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (y <= -4.7e+73) tmp = y * b; elseif (y <= 4.7e-297) tmp = t * b; elseif (y <= 4.4e-186) tmp = z; elseif (y <= 2.5e-159) tmp = t * b; elseif (y <= 1.15e+70) tmp = x; else tmp = y * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, -4.7e+73], N[(y * b), $MachinePrecision], If[LessEqual[y, 4.7e-297], N[(t * b), $MachinePrecision], If[LessEqual[y, 4.4e-186], z, If[LessEqual[y, 2.5e-159], N[(t * b), $MachinePrecision], If[LessEqual[y, 1.15e+70], x, N[(y * b), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -4.7 \cdot 10^{+73}:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;y \leq 4.7 \cdot 10^{-297}:\\
\;\;\;\;t \cdot b\\
\mathbf{elif}\;y \leq 4.4 \cdot 10^{-186}:\\
\;\;\;\;z\\
\mathbf{elif}\;y \leq 2.5 \cdot 10^{-159}:\\
\;\;\;\;t \cdot b\\
\mathbf{elif}\;y \leq 1.15 \cdot 10^{+70}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;y \cdot b\\
\end{array}
\end{array}
if y < -4.7000000000000002e73 or 1.14999999999999997e70 < y Initial program 88.3%
associate-+l-88.3%
*-commutative88.3%
*-commutative88.3%
sub-neg88.3%
metadata-eval88.3%
remove-double-neg88.3%
remove-double-neg88.3%
sub-neg88.3%
metadata-eval88.3%
associate--l+88.3%
Simplified88.3%
Taylor expanded in b around inf 49.9%
Taylor expanded in y around inf 43.7%
if -4.7000000000000002e73 < y < 4.69999999999999986e-297 or 4.40000000000000026e-186 < y < 2.50000000000000016e-159Initial program 97.5%
associate-+l-97.5%
*-commutative97.5%
*-commutative97.5%
sub-neg97.5%
metadata-eval97.5%
remove-double-neg97.5%
remove-double-neg97.5%
sub-neg97.5%
metadata-eval97.5%
associate--l+97.5%
Simplified97.5%
Taylor expanded in b around inf 45.9%
Taylor expanded in t around inf 29.7%
if 4.69999999999999986e-297 < y < 4.40000000000000026e-186Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in z around inf 31.7%
Taylor expanded in y around 0 31.7%
if 2.50000000000000016e-159 < y < 1.14999999999999997e70Initial program 98.0%
associate-+l-98.0%
*-commutative98.0%
*-commutative98.0%
sub-neg98.0%
metadata-eval98.0%
remove-double-neg98.0%
remove-double-neg98.0%
sub-neg98.0%
metadata-eval98.0%
associate--l+98.0%
Simplified98.0%
Taylor expanded in x around inf 26.7%
Final simplification34.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (- b a))))
(if (<= t -6.9)
t_1
(if (<= t -2e-249)
(* y b)
(if (<= t 4e-190) (+ x z) (if (<= t 33000.0) (* y (- z)) t_1))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -6.9) {
tmp = t_1;
} else if (t <= -2e-249) {
tmp = y * b;
} else if (t <= 4e-190) {
tmp = x + z;
} else if (t <= 33000.0) {
tmp = y * -z;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = t * (b - a)
if (t <= (-6.9d0)) then
tmp = t_1
else if (t <= (-2d-249)) then
tmp = y * b
else if (t <= 4d-190) then
tmp = x + z
else if (t <= 33000.0d0) then
tmp = y * -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 b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -6.9) {
tmp = t_1;
} else if (t <= -2e-249) {
tmp = y * b;
} else if (t <= 4e-190) {
tmp = x + z;
} else if (t <= 33000.0) {
tmp = y * -z;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = t * (b - a) tmp = 0 if t <= -6.9: tmp = t_1 elif t <= -2e-249: tmp = y * b elif t <= 4e-190: tmp = x + z elif t <= 33000.0: tmp = y * -z else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -6.9) tmp = t_1; elseif (t <= -2e-249) tmp = Float64(y * b); elseif (t <= 4e-190) tmp = Float64(x + z); elseif (t <= 33000.0) tmp = Float64(y * Float64(-z)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = t * (b - a); tmp = 0.0; if (t <= -6.9) tmp = t_1; elseif (t <= -2e-249) tmp = y * b; elseif (t <= 4e-190) tmp = x + z; elseif (t <= 33000.0) tmp = y * -z; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -6.9], t$95$1, If[LessEqual[t, -2e-249], N[(y * b), $MachinePrecision], If[LessEqual[t, 4e-190], N[(x + z), $MachinePrecision], If[LessEqual[t, 33000.0], N[(y * (-z)), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -6.9:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -2 \cdot 10^{-249}:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;t \leq 4 \cdot 10^{-190}:\\
\;\;\;\;x + z\\
\mathbf{elif}\;t \leq 33000:\\
\;\;\;\;y \cdot \left(-z\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -6.9000000000000004 or 33000 < t Initial program 90.2%
associate-+l-90.2%
*-commutative90.2%
*-commutative90.2%
sub-neg90.2%
metadata-eval90.2%
remove-double-neg90.2%
remove-double-neg90.2%
sub-neg90.2%
metadata-eval90.2%
associate--l+90.2%
Simplified90.2%
Taylor expanded in t around inf 67.0%
if -6.9000000000000004 < t < -2.00000000000000011e-249Initial program 96.4%
associate-+l-96.4%
*-commutative96.4%
*-commutative96.4%
sub-neg96.4%
metadata-eval96.4%
remove-double-neg96.4%
remove-double-neg96.4%
sub-neg96.4%
metadata-eval96.4%
associate--l+96.4%
Simplified96.4%
Taylor expanded in b around inf 49.9%
Taylor expanded in y around inf 40.2%
if -2.00000000000000011e-249 < t < 4.0000000000000001e-190Initial program 97.7%
associate-+l-97.7%
*-commutative97.7%
*-commutative97.7%
sub-neg97.7%
metadata-eval97.7%
remove-double-neg97.7%
remove-double-neg97.7%
sub-neg97.7%
metadata-eval97.7%
associate--l+97.7%
Simplified97.7%
Taylor expanded in y around inf 67.2%
mul-1-neg67.2%
distribute-rgt-neg-in67.2%
Simplified67.2%
Taylor expanded in y around 0 35.7%
cancel-sign-sub-inv35.7%
metadata-eval35.7%
*-lft-identity35.7%
Simplified35.7%
if 4.0000000000000001e-190 < t < 33000Initial program 97.8%
associate-+l-97.8%
*-commutative97.8%
*-commutative97.8%
sub-neg97.8%
metadata-eval97.8%
remove-double-neg97.8%
remove-double-neg97.8%
sub-neg97.8%
metadata-eval97.8%
associate--l+97.8%
Simplified97.8%
Taylor expanded in z around inf 45.5%
Taylor expanded in y around inf 36.5%
mul-1-neg36.5%
distribute-rgt-neg-in36.5%
Simplified36.5%
Final simplification50.6%
(FPCore (x y z t a b) :precision binary64 (if (or (<= t -40000000.0) (not (<= t 34000.0))) (+ x (* t (- b a))) (- (+ x (* y b)) (* y z))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -40000000.0) || !(t <= 34000.0)) {
tmp = x + (t * (b - a));
} else {
tmp = (x + (y * b)) - (y * z);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
real(8) :: tmp
if ((t <= (-40000000.0d0)) .or. (.not. (t <= 34000.0d0))) then
tmp = x + (t * (b - a))
else
tmp = (x + (y * b)) - (y * z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -40000000.0) || !(t <= 34000.0)) {
tmp = x + (t * (b - a));
} else {
tmp = (x + (y * b)) - (y * z);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (t <= -40000000.0) or not (t <= 34000.0): tmp = x + (t * (b - a)) else: tmp = (x + (y * b)) - (y * z) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((t <= -40000000.0) || !(t <= 34000.0)) tmp = Float64(x + Float64(t * Float64(b - a))); else tmp = Float64(Float64(x + Float64(y * b)) - Float64(y * z)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((t <= -40000000.0) || ~((t <= 34000.0))) tmp = x + (t * (b - a)); else tmp = (x + (y * b)) - (y * z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[t, -40000000.0], N[Not[LessEqual[t, 34000.0]], $MachinePrecision]], N[(x + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + N[(y * b), $MachinePrecision]), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -40000000 \lor \neg \left(t \leq 34000\right):\\
\;\;\;\;x + t \cdot \left(b - a\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x + y \cdot b\right) - y \cdot z\\
\end{array}
\end{array}
if t < -4e7 or 34000 < t Initial program 90.2%
associate-+l-90.2%
*-commutative90.2%
*-commutative90.2%
sub-neg90.2%
metadata-eval90.2%
remove-double-neg90.2%
remove-double-neg90.2%
sub-neg90.2%
metadata-eval90.2%
associate--l+90.2%
Simplified90.2%
Taylor expanded in t around inf 87.5%
Taylor expanded in z around 0 75.1%
if -4e7 < t < 34000Initial program 97.2%
associate-+l-97.2%
*-commutative97.2%
*-commutative97.2%
sub-neg97.2%
metadata-eval97.2%
remove-double-neg97.2%
remove-double-neg97.2%
sub-neg97.2%
metadata-eval97.2%
associate--l+97.2%
Simplified97.2%
Taylor expanded in y around inf 67.0%
mul-1-neg67.0%
distribute-rgt-neg-in67.0%
Simplified67.0%
Taylor expanded in y around inf 59.4%
Taylor expanded in b around 0 59.4%
Final simplification66.2%
(FPCore (x y z t a b) :precision binary64 (if (or (<= t -220000.0) (not (<= t 5.5e-12))) (+ (+ x z) (* t (- b a))) (- (+ x (* y b)) (* y z))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -220000.0) || !(t <= 5.5e-12)) {
tmp = (x + z) + (t * (b - a));
} else {
tmp = (x + (y * b)) - (y * z);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
real(8) :: tmp
if ((t <= (-220000.0d0)) .or. (.not. (t <= 5.5d-12))) then
tmp = (x + z) + (t * (b - a))
else
tmp = (x + (y * b)) - (y * z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -220000.0) || !(t <= 5.5e-12)) {
tmp = (x + z) + (t * (b - a));
} else {
tmp = (x + (y * b)) - (y * z);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (t <= -220000.0) or not (t <= 5.5e-12): tmp = (x + z) + (t * (b - a)) else: tmp = (x + (y * b)) - (y * z) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((t <= -220000.0) || !(t <= 5.5e-12)) tmp = Float64(Float64(x + z) + Float64(t * Float64(b - a))); else tmp = Float64(Float64(x + Float64(y * b)) - Float64(y * z)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((t <= -220000.0) || ~((t <= 5.5e-12))) tmp = (x + z) + (t * (b - a)); else tmp = (x + (y * b)) - (y * z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[t, -220000.0], N[Not[LessEqual[t, 5.5e-12]], $MachinePrecision]], N[(N[(x + z), $MachinePrecision] + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + N[(y * b), $MachinePrecision]), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -220000 \lor \neg \left(t \leq 5.5 \cdot 10^{-12}\right):\\
\;\;\;\;\left(x + z\right) + t \cdot \left(b - a\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x + y \cdot b\right) - y \cdot z\\
\end{array}
\end{array}
if t < -2.2e5 or 5.5000000000000004e-12 < t Initial program 89.7%
associate-+l-89.7%
*-commutative89.7%
*-commutative89.7%
sub-neg89.7%
metadata-eval89.7%
remove-double-neg89.7%
remove-double-neg89.7%
sub-neg89.7%
metadata-eval89.7%
associate--l+89.7%
Simplified89.7%
Taylor expanded in t around inf 88.1%
Taylor expanded in y around 0 86.3%
mul-1-neg86.3%
Simplified86.3%
if -2.2e5 < t < 5.5000000000000004e-12Initial program 97.8%
associate-+l-97.8%
*-commutative97.8%
*-commutative97.8%
sub-neg97.8%
metadata-eval97.8%
remove-double-neg97.8%
remove-double-neg97.8%
sub-neg97.8%
metadata-eval97.8%
associate--l+97.8%
Simplified97.8%
Taylor expanded in y around inf 66.5%
mul-1-neg66.5%
distribute-rgt-neg-in66.5%
Simplified66.5%
Taylor expanded in y around inf 60.0%
Taylor expanded in b around 0 60.0%
Final simplification72.0%
(FPCore (x y z t a b) :precision binary64 (if (or (<= t -35000.0) (not (<= t 5.5e-12))) (+ (+ x z) (* t (- b a))) (+ a (+ x (* (- y 2.0) b)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -35000.0) || !(t <= 5.5e-12)) {
tmp = (x + z) + (t * (b - a));
} else {
tmp = a + (x + ((y - 2.0) * b));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
real(8) :: tmp
if ((t <= (-35000.0d0)) .or. (.not. (t <= 5.5d-12))) then
tmp = (x + z) + (t * (b - a))
else
tmp = a + (x + ((y - 2.0d0) * b))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -35000.0) || !(t <= 5.5e-12)) {
tmp = (x + z) + (t * (b - a));
} else {
tmp = a + (x + ((y - 2.0) * b));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (t <= -35000.0) or not (t <= 5.5e-12): tmp = (x + z) + (t * (b - a)) else: tmp = a + (x + ((y - 2.0) * b)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((t <= -35000.0) || !(t <= 5.5e-12)) tmp = Float64(Float64(x + z) + Float64(t * Float64(b - a))); else tmp = Float64(a + Float64(x + Float64(Float64(y - 2.0) * b))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((t <= -35000.0) || ~((t <= 5.5e-12))) tmp = (x + z) + (t * (b - a)); else tmp = a + (x + ((y - 2.0) * b)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[t, -35000.0], N[Not[LessEqual[t, 5.5e-12]], $MachinePrecision]], N[(N[(x + z), $MachinePrecision] + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(a + N[(x + N[(N[(y - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -35000 \lor \neg \left(t \leq 5.5 \cdot 10^{-12}\right):\\
\;\;\;\;\left(x + z\right) + t \cdot \left(b - a\right)\\
\mathbf{else}:\\
\;\;\;\;a + \left(x + \left(y - 2\right) \cdot b\right)\\
\end{array}
\end{array}
if t < -35000 or 5.5000000000000004e-12 < t Initial program 89.7%
associate-+l-89.7%
*-commutative89.7%
*-commutative89.7%
sub-neg89.7%
metadata-eval89.7%
remove-double-neg89.7%
remove-double-neg89.7%
sub-neg89.7%
metadata-eval89.7%
associate--l+89.7%
Simplified89.7%
Taylor expanded in t around inf 88.1%
Taylor expanded in y around 0 86.3%
mul-1-neg86.3%
Simplified86.3%
if -35000 < t < 5.5000000000000004e-12Initial program 97.8%
associate-+l-97.8%
*-commutative97.8%
*-commutative97.8%
sub-neg97.8%
metadata-eval97.8%
remove-double-neg97.8%
remove-double-neg97.8%
sub-neg97.8%
metadata-eval97.8%
associate--l+97.8%
Simplified97.8%
Taylor expanded in z around 0 74.0%
Taylor expanded in t around 0 73.9%
Final simplification79.6%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -1.3e+69)
(* t b)
(if (<= b -2.3e-264)
(+ x z)
(if (<= b 4.7e-213) a (if (<= b 3.5e+59) (+ x z) (* y b))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.3e+69) {
tmp = t * b;
} else if (b <= -2.3e-264) {
tmp = x + z;
} else if (b <= 4.7e-213) {
tmp = a;
} else if (b <= 3.5e+59) {
tmp = x + z;
} else {
tmp = y * b;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
real(8) :: tmp
if (b <= (-1.3d+69)) then
tmp = t * b
else if (b <= (-2.3d-264)) then
tmp = x + z
else if (b <= 4.7d-213) then
tmp = a
else if (b <= 3.5d+59) then
tmp = x + z
else
tmp = y * b
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.3e+69) {
tmp = t * b;
} else if (b <= -2.3e-264) {
tmp = x + z;
} else if (b <= 4.7e-213) {
tmp = a;
} else if (b <= 3.5e+59) {
tmp = x + z;
} else {
tmp = y * b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.3e+69: tmp = t * b elif b <= -2.3e-264: tmp = x + z elif b <= 4.7e-213: tmp = a elif b <= 3.5e+59: tmp = x + z else: tmp = y * b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.3e+69) tmp = Float64(t * b); elseif (b <= -2.3e-264) tmp = Float64(x + z); elseif (b <= 4.7e-213) tmp = a; elseif (b <= 3.5e+59) tmp = Float64(x + z); else tmp = Float64(y * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -1.3e+69) tmp = t * b; elseif (b <= -2.3e-264) tmp = x + z; elseif (b <= 4.7e-213) tmp = a; elseif (b <= 3.5e+59) tmp = x + z; else tmp = y * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.3e+69], N[(t * b), $MachinePrecision], If[LessEqual[b, -2.3e-264], N[(x + z), $MachinePrecision], If[LessEqual[b, 4.7e-213], a, If[LessEqual[b, 3.5e+59], N[(x + z), $MachinePrecision], N[(y * b), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.3 \cdot 10^{+69}:\\
\;\;\;\;t \cdot b\\
\mathbf{elif}\;b \leq -2.3 \cdot 10^{-264}:\\
\;\;\;\;x + z\\
\mathbf{elif}\;b \leq 4.7 \cdot 10^{-213}:\\
\;\;\;\;a\\
\mathbf{elif}\;b \leq 3.5 \cdot 10^{+59}:\\
\;\;\;\;x + z\\
\mathbf{else}:\\
\;\;\;\;y \cdot b\\
\end{array}
\end{array}
if b < -1.3000000000000001e69Initial program 89.5%
associate-+l-89.5%
*-commutative89.5%
*-commutative89.5%
sub-neg89.5%
metadata-eval89.5%
remove-double-neg89.5%
remove-double-neg89.5%
sub-neg89.5%
metadata-eval89.5%
associate--l+89.5%
Simplified89.5%
Taylor expanded in b around inf 81.1%
Taylor expanded in t around inf 40.2%
if -1.3000000000000001e69 < b < -2.30000000000000012e-264 or 4.7e-213 < b < 3.5e59Initial program 98.4%
associate-+l-98.4%
*-commutative98.4%
*-commutative98.4%
sub-neg98.4%
metadata-eval98.4%
remove-double-neg98.4%
remove-double-neg98.4%
sub-neg98.4%
metadata-eval98.4%
associate--l+98.4%
Simplified98.4%
Taylor expanded in y around inf 64.1%
mul-1-neg64.1%
distribute-rgt-neg-in64.1%
Simplified64.1%
Taylor expanded in y around 0 39.6%
cancel-sign-sub-inv39.6%
metadata-eval39.6%
*-lft-identity39.6%
Simplified39.6%
if -2.30000000000000012e-264 < b < 4.7e-213Initial program 94.4%
associate-+l-94.4%
*-commutative94.4%
*-commutative94.4%
sub-neg94.4%
metadata-eval94.4%
remove-double-neg94.4%
remove-double-neg94.4%
sub-neg94.4%
metadata-eval94.4%
associate--l+94.4%
Simplified94.4%
Taylor expanded in a around inf 67.4%
Taylor expanded in t around 0 40.7%
if 3.5e59 < b Initial program 88.0%
associate-+l-88.0%
*-commutative88.0%
*-commutative88.0%
sub-neg88.0%
metadata-eval88.0%
remove-double-neg88.0%
remove-double-neg88.0%
sub-neg88.0%
metadata-eval88.0%
associate--l+88.0%
Simplified88.0%
Taylor expanded in b around inf 76.9%
Taylor expanded in y around inf 44.3%
Final simplification40.7%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -7.5e+68)
(* t b)
(if (<= b -5.7e-271)
(+ x z)
(if (<= b 4.2e-145) (* y (- z)) (if (<= b 1.6e+61) (+ x z) (* y b))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -7.5e+68) {
tmp = t * b;
} else if (b <= -5.7e-271) {
tmp = x + z;
} else if (b <= 4.2e-145) {
tmp = y * -z;
} else if (b <= 1.6e+61) {
tmp = x + z;
} else {
tmp = y * b;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
real(8) :: tmp
if (b <= (-7.5d+68)) then
tmp = t * b
else if (b <= (-5.7d-271)) then
tmp = x + z
else if (b <= 4.2d-145) then
tmp = y * -z
else if (b <= 1.6d+61) then
tmp = x + z
else
tmp = y * b
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -7.5e+68) {
tmp = t * b;
} else if (b <= -5.7e-271) {
tmp = x + z;
} else if (b <= 4.2e-145) {
tmp = y * -z;
} else if (b <= 1.6e+61) {
tmp = x + z;
} else {
tmp = y * b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -7.5e+68: tmp = t * b elif b <= -5.7e-271: tmp = x + z elif b <= 4.2e-145: tmp = y * -z elif b <= 1.6e+61: tmp = x + z else: tmp = y * b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -7.5e+68) tmp = Float64(t * b); elseif (b <= -5.7e-271) tmp = Float64(x + z); elseif (b <= 4.2e-145) tmp = Float64(y * Float64(-z)); elseif (b <= 1.6e+61) tmp = Float64(x + z); else tmp = Float64(y * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -7.5e+68) tmp = t * b; elseif (b <= -5.7e-271) tmp = x + z; elseif (b <= 4.2e-145) tmp = y * -z; elseif (b <= 1.6e+61) tmp = x + z; else tmp = y * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -7.5e+68], N[(t * b), $MachinePrecision], If[LessEqual[b, -5.7e-271], N[(x + z), $MachinePrecision], If[LessEqual[b, 4.2e-145], N[(y * (-z)), $MachinePrecision], If[LessEqual[b, 1.6e+61], N[(x + z), $MachinePrecision], N[(y * b), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -7.5 \cdot 10^{+68}:\\
\;\;\;\;t \cdot b\\
\mathbf{elif}\;b \leq -5.7 \cdot 10^{-271}:\\
\;\;\;\;x + z\\
\mathbf{elif}\;b \leq 4.2 \cdot 10^{-145}:\\
\;\;\;\;y \cdot \left(-z\right)\\
\mathbf{elif}\;b \leq 1.6 \cdot 10^{+61}:\\
\;\;\;\;x + z\\
\mathbf{else}:\\
\;\;\;\;y \cdot b\\
\end{array}
\end{array}
if b < -7.49999999999999959e68Initial program 89.5%
associate-+l-89.5%
*-commutative89.5%
*-commutative89.5%
sub-neg89.5%
metadata-eval89.5%
remove-double-neg89.5%
remove-double-neg89.5%
sub-neg89.5%
metadata-eval89.5%
associate--l+89.5%
Simplified89.5%
Taylor expanded in b around inf 81.1%
Taylor expanded in t around inf 40.2%
if -7.49999999999999959e68 < b < -5.70000000000000041e-271 or 4.19999999999999982e-145 < b < 1.5999999999999999e61Initial program 98.3%
associate-+l-98.3%
*-commutative98.3%
*-commutative98.3%
sub-neg98.3%
metadata-eval98.3%
remove-double-neg98.3%
remove-double-neg98.3%
sub-neg98.3%
metadata-eval98.3%
associate--l+98.3%
Simplified98.3%
Taylor expanded in y around inf 62.7%
mul-1-neg62.7%
distribute-rgt-neg-in62.7%
Simplified62.7%
Taylor expanded in y around 0 40.2%
cancel-sign-sub-inv40.2%
metadata-eval40.2%
*-lft-identity40.2%
Simplified40.2%
if -5.70000000000000041e-271 < b < 4.19999999999999982e-145Initial program 96.4%
associate-+l-96.4%
*-commutative96.4%
*-commutative96.4%
sub-neg96.4%
metadata-eval96.4%
remove-double-neg96.4%
remove-double-neg96.4%
sub-neg96.4%
metadata-eval96.4%
associate--l+96.4%
Simplified96.4%
Taylor expanded in z around inf 44.8%
Taylor expanded in y around inf 39.1%
mul-1-neg39.1%
distribute-rgt-neg-in39.1%
Simplified39.1%
if 1.5999999999999999e61 < b Initial program 88.0%
associate-+l-88.0%
*-commutative88.0%
*-commutative88.0%
sub-neg88.0%
metadata-eval88.0%
remove-double-neg88.0%
remove-double-neg88.0%
sub-neg88.0%
metadata-eval88.0%
associate--l+88.0%
Simplified88.0%
Taylor expanded in b around inf 76.9%
Taylor expanded in y around inf 44.3%
Final simplification40.9%
(FPCore (x y z t a b) :precision binary64 (if (or (<= t -1850000000.0) (not (<= t 2.8e-12))) (+ x (* t (- b a))) (* y (- b z))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -1850000000.0) || !(t <= 2.8e-12)) {
tmp = x + (t * (b - a));
} else {
tmp = y * (b - z);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
real(8) :: tmp
if ((t <= (-1850000000.0d0)) .or. (.not. (t <= 2.8d-12))) then
tmp = x + (t * (b - a))
else
tmp = y * (b - z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -1850000000.0) || !(t <= 2.8e-12)) {
tmp = x + (t * (b - a));
} else {
tmp = y * (b - z);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (t <= -1850000000.0) or not (t <= 2.8e-12): tmp = x + (t * (b - a)) else: tmp = y * (b - z) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((t <= -1850000000.0) || !(t <= 2.8e-12)) tmp = Float64(x + Float64(t * Float64(b - a))); else tmp = Float64(y * Float64(b - z)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((t <= -1850000000.0) || ~((t <= 2.8e-12))) tmp = x + (t * (b - a)); else tmp = y * (b - z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[t, -1850000000.0], N[Not[LessEqual[t, 2.8e-12]], $MachinePrecision]], N[(x + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1850000000 \lor \neg \left(t \leq 2.8 \cdot 10^{-12}\right):\\
\;\;\;\;x + t \cdot \left(b - a\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(b - z\right)\\
\end{array}
\end{array}
if t < -1.85e9 or 2.8000000000000002e-12 < t Initial program 89.7%
associate-+l-89.7%
*-commutative89.7%
*-commutative89.7%
sub-neg89.7%
metadata-eval89.7%
remove-double-neg89.7%
remove-double-neg89.7%
sub-neg89.7%
metadata-eval89.7%
associate--l+89.7%
Simplified89.7%
Taylor expanded in t around inf 88.1%
Taylor expanded in z around 0 73.6%
if -1.85e9 < t < 2.8000000000000002e-12Initial program 97.8%
associate-+l-97.8%
*-commutative97.8%
*-commutative97.8%
sub-neg97.8%
metadata-eval97.8%
remove-double-neg97.8%
remove-double-neg97.8%
sub-neg97.8%
metadata-eval97.8%
associate--l+97.8%
Simplified97.8%
Taylor expanded in y around inf 48.2%
Final simplification59.8%
(FPCore (x y z t a b) :precision binary64 (if (<= x -6.7e+96) x (if (<= x 8e-215) z (if (<= x 1.5e+34) a (if (<= x 6.8e+53) z x)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (x <= -6.7e+96) {
tmp = x;
} else if (x <= 8e-215) {
tmp = z;
} else if (x <= 1.5e+34) {
tmp = a;
} else if (x <= 6.8e+53) {
tmp = z;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
real(8) :: tmp
if (x <= (-6.7d+96)) then
tmp = x
else if (x <= 8d-215) then
tmp = z
else if (x <= 1.5d+34) then
tmp = a
else if (x <= 6.8d+53) then
tmp = 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 b) {
double tmp;
if (x <= -6.7e+96) {
tmp = x;
} else if (x <= 8e-215) {
tmp = z;
} else if (x <= 1.5e+34) {
tmp = a;
} else if (x <= 6.8e+53) {
tmp = z;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if x <= -6.7e+96: tmp = x elif x <= 8e-215: tmp = z elif x <= 1.5e+34: tmp = a elif x <= 6.8e+53: tmp = z else: tmp = x return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (x <= -6.7e+96) tmp = x; elseif (x <= 8e-215) tmp = z; elseif (x <= 1.5e+34) tmp = a; elseif (x <= 6.8e+53) tmp = z; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (x <= -6.7e+96) tmp = x; elseif (x <= 8e-215) tmp = z; elseif (x <= 1.5e+34) tmp = a; elseif (x <= 6.8e+53) tmp = z; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -6.7e+96], x, If[LessEqual[x, 8e-215], z, If[LessEqual[x, 1.5e+34], a, If[LessEqual[x, 6.8e+53], z, x]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -6.7 \cdot 10^{+96}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 8 \cdot 10^{-215}:\\
\;\;\;\;z\\
\mathbf{elif}\;x \leq 1.5 \cdot 10^{+34}:\\
\;\;\;\;a\\
\mathbf{elif}\;x \leq 6.8 \cdot 10^{+53}:\\
\;\;\;\;z\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -6.70000000000000042e96 or 6.79999999999999995e53 < x Initial program 92.7%
associate-+l-92.7%
*-commutative92.7%
*-commutative92.7%
sub-neg92.7%
metadata-eval92.7%
remove-double-neg92.7%
remove-double-neg92.7%
sub-neg92.7%
metadata-eval92.7%
associate--l+92.7%
Simplified92.7%
Taylor expanded in x around inf 33.0%
if -6.70000000000000042e96 < x < 8.00000000000000033e-215 or 1.50000000000000009e34 < x < 6.79999999999999995e53Initial program 94.7%
associate-+l-94.7%
*-commutative94.7%
*-commutative94.7%
sub-neg94.7%
metadata-eval94.7%
remove-double-neg94.7%
remove-double-neg94.7%
sub-neg94.7%
metadata-eval94.7%
associate--l+94.7%
Simplified94.7%
Taylor expanded in z around inf 34.9%
Taylor expanded in y around 0 17.7%
if 8.00000000000000033e-215 < x < 1.50000000000000009e34Initial program 95.7%
associate-+l-95.7%
*-commutative95.7%
*-commutative95.7%
sub-neg95.7%
metadata-eval95.7%
remove-double-neg95.7%
remove-double-neg95.7%
sub-neg95.7%
metadata-eval95.7%
associate--l+95.7%
Simplified95.7%
Taylor expanded in a around inf 39.4%
Taylor expanded in t around 0 22.1%
Final simplification24.3%
(FPCore (x y z t a b) :precision binary64 (if (or (<= t -6600000000.0) (not (<= t 90000.0))) (* t (- b a)) (* y (- b z))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -6600000000.0) || !(t <= 90000.0)) {
tmp = t * (b - a);
} else {
tmp = y * (b - z);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
real(8) :: tmp
if ((t <= (-6600000000.0d0)) .or. (.not. (t <= 90000.0d0))) then
tmp = t * (b - a)
else
tmp = y * (b - z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -6600000000.0) || !(t <= 90000.0)) {
tmp = t * (b - a);
} else {
tmp = y * (b - z);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (t <= -6600000000.0) or not (t <= 90000.0): tmp = t * (b - a) else: tmp = y * (b - z) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((t <= -6600000000.0) || !(t <= 90000.0)) tmp = Float64(t * Float64(b - a)); else tmp = Float64(y * Float64(b - z)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((t <= -6600000000.0) || ~((t <= 90000.0))) tmp = t * (b - a); else tmp = y * (b - z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[t, -6600000000.0], N[Not[LessEqual[t, 90000.0]], $MachinePrecision]], N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -6600000000 \lor \neg \left(t \leq 90000\right):\\
\;\;\;\;t \cdot \left(b - a\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(b - z\right)\\
\end{array}
\end{array}
if t < -6.6e9 or 9e4 < t Initial program 90.2%
associate-+l-90.2%
*-commutative90.2%
*-commutative90.2%
sub-neg90.2%
metadata-eval90.2%
remove-double-neg90.2%
remove-double-neg90.2%
sub-neg90.2%
metadata-eval90.2%
associate--l+90.2%
Simplified90.2%
Taylor expanded in t around inf 67.6%
if -6.6e9 < t < 9e4Initial program 97.2%
associate-+l-97.2%
*-commutative97.2%
*-commutative97.2%
sub-neg97.2%
metadata-eval97.2%
remove-double-neg97.2%
remove-double-neg97.2%
sub-neg97.2%
metadata-eval97.2%
associate--l+97.2%
Simplified97.2%
Taylor expanded in y around inf 47.3%
Final simplification56.2%
(FPCore (x y z t a b) :precision binary64 (if (<= t -1.3e+14) (* t b) (if (<= t 4.8e-9) a (* t b))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -1.3e+14) {
tmp = t * b;
} else if (t <= 4.8e-9) {
tmp = a;
} else {
tmp = t * b;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
real(8) :: tmp
if (t <= (-1.3d+14)) then
tmp = t * b
else if (t <= 4.8d-9) then
tmp = a
else
tmp = t * b
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -1.3e+14) {
tmp = t * b;
} else if (t <= 4.8e-9) {
tmp = a;
} else {
tmp = t * b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -1.3e+14: tmp = t * b elif t <= 4.8e-9: tmp = a else: tmp = t * b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -1.3e+14) tmp = Float64(t * b); elseif (t <= 4.8e-9) tmp = a; else tmp = Float64(t * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -1.3e+14) tmp = t * b; elseif (t <= 4.8e-9) tmp = a; else tmp = t * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -1.3e+14], N[(t * b), $MachinePrecision], If[LessEqual[t, 4.8e-9], a, N[(t * b), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.3 \cdot 10^{+14}:\\
\;\;\;\;t \cdot b\\
\mathbf{elif}\;t \leq 4.8 \cdot 10^{-9}:\\
\;\;\;\;a\\
\mathbf{else}:\\
\;\;\;\;t \cdot b\\
\end{array}
\end{array}
if t < -1.3e14 or 4.8e-9 < t Initial program 89.4%
associate-+l-89.4%
*-commutative89.4%
*-commutative89.4%
sub-neg89.4%
metadata-eval89.4%
remove-double-neg89.4%
remove-double-neg89.4%
sub-neg89.4%
metadata-eval89.4%
associate--l+89.4%
Simplified89.4%
Taylor expanded in b around inf 44.4%
Taylor expanded in t around inf 35.6%
if -1.3e14 < t < 4.8e-9Initial program 97.9%
associate-+l-97.9%
*-commutative97.9%
*-commutative97.9%
sub-neg97.9%
metadata-eval97.9%
remove-double-neg97.9%
remove-double-neg97.9%
sub-neg97.9%
metadata-eval97.9%
associate--l+97.9%
Simplified97.9%
Taylor expanded in a around inf 22.1%
Taylor expanded in t around 0 20.7%
Final simplification27.3%
(FPCore (x y z t a b) :precision binary64 (if (<= x -1e+90) x (if (<= x 1.45e+149) a x)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (x <= -1e+90) {
tmp = x;
} else if (x <= 1.45e+149) {
tmp = a;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
real(8) :: tmp
if (x <= (-1d+90)) then
tmp = x
else if (x <= 1.45d+149) then
tmp = a
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (x <= -1e+90) {
tmp = x;
} else if (x <= 1.45e+149) {
tmp = a;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if x <= -1e+90: tmp = x elif x <= 1.45e+149: tmp = a else: tmp = x return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (x <= -1e+90) tmp = x; elseif (x <= 1.45e+149) tmp = a; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (x <= -1e+90) tmp = x; elseif (x <= 1.45e+149) tmp = a; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -1e+90], x, If[LessEqual[x, 1.45e+149], a, x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1 \cdot 10^{+90}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 1.45 \cdot 10^{+149}:\\
\;\;\;\;a\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -9.99999999999999966e89 or 1.4500000000000001e149 < x Initial program 91.8%
associate-+l-91.8%
*-commutative91.8%
*-commutative91.8%
sub-neg91.8%
metadata-eval91.8%
remove-double-neg91.8%
remove-double-neg91.8%
sub-neg91.8%
metadata-eval91.8%
associate--l+91.8%
Simplified91.8%
Taylor expanded in x around inf 40.0%
if -9.99999999999999966e89 < x < 1.4500000000000001e149Initial program 95.1%
associate-+l-95.1%
*-commutative95.1%
*-commutative95.1%
sub-neg95.1%
metadata-eval95.1%
remove-double-neg95.1%
remove-double-neg95.1%
sub-neg95.1%
metadata-eval95.1%
associate--l+95.1%
Simplified95.1%
Taylor expanded in a around inf 30.2%
Taylor expanded in t around 0 14.2%
Final simplification21.6%
(FPCore (x y z t a b) :precision binary64 a)
double code(double x, double y, double z, double t, double a, double b) {
return a;
}
real(8) function code(x, y, z, t, a, b)
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), intent (in) :: b
code = a
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return a;
}
def code(x, y, z, t, a, b): return a
function code(x, y, z, t, a, b) return a end
function tmp = code(x, y, z, t, a, b) tmp = a; end
code[x_, y_, z_, t_, a_, b_] := a
\begin{array}{l}
\\
a
\end{array}
Initial program 94.1%
associate-+l-94.1%
*-commutative94.1%
*-commutative94.1%
sub-neg94.1%
metadata-eval94.1%
remove-double-neg94.1%
remove-double-neg94.1%
sub-neg94.1%
metadata-eval94.1%
associate--l+94.1%
Simplified94.1%
Taylor expanded in a around inf 27.9%
Taylor expanded in t around 0 12.8%
Final simplification12.8%
herbie shell --seed 2023200
(FPCore (x y z t a b)
:name "Statistics.Distribution.Beta:$centropy from math-functions-0.1.5.2"
:precision binary64
(+ (- (- x (* (- y 1.0) z)) (* (- t 1.0) a)) (* (- (+ y t) 2.0) b)))