
(FPCore (x y z t a b) :precision binary64 (* x (exp (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b))))))
double code(double x, double y, double z, double t, double a, double b) {
return x * exp(((y * (log(z) - t)) + (a * (log((1.0 - z)) - 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 * exp(((y * (log(z) - t)) + (a * (log((1.0d0 - z)) - b))))
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x * Math.exp(((y * (Math.log(z) - t)) + (a * (Math.log((1.0 - z)) - b))));
}
def code(x, y, z, t, a, b): return x * math.exp(((y * (math.log(z) - t)) + (a * (math.log((1.0 - z)) - b))))
function code(x, y, z, t, a, b) return Float64(x * exp(Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b))))) end
function tmp = code(x, y, z, t, a, b) tmp = x * exp(((y * (log(z) - t)) + (a * (log((1.0 - z)) - b)))); end
code[x_, y_, z_, t_, a_, b_] := N[(x * N[Exp[N[(N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[Log[N[(1.0 - z), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 18 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b) :precision binary64 (* x (exp (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b))))))
double code(double x, double y, double z, double t, double a, double b) {
return x * exp(((y * (log(z) - t)) + (a * (log((1.0 - z)) - 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 * exp(((y * (log(z) - t)) + (a * (log((1.0d0 - z)) - b))))
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x * Math.exp(((y * (Math.log(z) - t)) + (a * (Math.log((1.0 - z)) - b))));
}
def code(x, y, z, t, a, b): return x * math.exp(((y * (math.log(z) - t)) + (a * (math.log((1.0 - z)) - b))))
function code(x, y, z, t, a, b) return Float64(x * exp(Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b))))) end
function tmp = code(x, y, z, t, a, b) tmp = x * exp(((y * (log(z) - t)) + (a * (log((1.0 - z)) - b)))); end
code[x_, y_, z_, t_, a_, b_] := N[(x * N[Exp[N[(N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[Log[N[(1.0 - z), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)}
\end{array}
(FPCore (x y z t a b) :precision binary64 (* x (exp (fma y (- (log z) t) (* a (- (log1p (- z)) b))))))
double code(double x, double y, double z, double t, double a, double b) {
return x * exp(fma(y, (log(z) - t), (a * (log1p(-z) - b))));
}
function code(x, y, z, t, a, b) return Float64(x * exp(fma(y, Float64(log(z) - t), Float64(a * Float64(log1p(Float64(-z)) - b))))) end
code[x_, y_, z_, t_, a_, b_] := N[(x * N[Exp[N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision] + N[(a * N[(N[Log[1 + (-z)], $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot e^{\mathsf{fma}\left(y, \log z - t, a \cdot \left(\mathsf{log1p}\left(-z\right) - b\right)\right)}
\end{array}
Initial program 96.5%
fma-define96.5%
sub-neg96.5%
log1p-define100.0%
Simplified100.0%
(FPCore (x y z t a b) :precision binary64 (* x (exp (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b))))))
double code(double x, double y, double z, double t, double a, double b) {
return x * exp(((y * (log(z) - t)) + (a * (log((1.0 - z)) - 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 * exp(((y * (log(z) - t)) + (a * (log((1.0d0 - z)) - b))))
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x * Math.exp(((y * (Math.log(z) - t)) + (a * (Math.log((1.0 - z)) - b))));
}
def code(x, y, z, t, a, b): return x * math.exp(((y * (math.log(z) - t)) + (a * (math.log((1.0 - z)) - b))))
function code(x, y, z, t, a, b) return Float64(x * exp(Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b))))) end
function tmp = code(x, y, z, t, a, b) tmp = x * exp(((y * (log(z) - t)) + (a * (log((1.0 - z)) - b)))); end
code[x_, y_, z_, t_, a_, b_] := N[(x * N[Exp[N[(N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[Log[N[(1.0 - z), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)}
\end{array}
Initial program 96.5%
(FPCore (x y z t a b) :precision binary64 (if (or (<= y -2.1e-14) (not (<= y 1.65e-26))) (* x (exp (* y (- (log z) t)))) (* x (exp (* (- a) (+ z b))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -2.1e-14) || !(y <= 1.65e-26)) {
tmp = x * exp((y * (log(z) - t)));
} else {
tmp = x * exp((-a * (z + 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 <= (-2.1d-14)) .or. (.not. (y <= 1.65d-26))) then
tmp = x * exp((y * (log(z) - t)))
else
tmp = x * exp((-a * (z + 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 <= -2.1e-14) || !(y <= 1.65e-26)) {
tmp = x * Math.exp((y * (Math.log(z) - t)));
} else {
tmp = x * Math.exp((-a * (z + b)));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (y <= -2.1e-14) or not (y <= 1.65e-26): tmp = x * math.exp((y * (math.log(z) - t))) else: tmp = x * math.exp((-a * (z + b))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((y <= -2.1e-14) || !(y <= 1.65e-26)) tmp = Float64(x * exp(Float64(y * Float64(log(z) - t)))); else tmp = Float64(x * exp(Float64(Float64(-a) * Float64(z + b)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((y <= -2.1e-14) || ~((y <= 1.65e-26))) tmp = x * exp((y * (log(z) - t))); else tmp = x * exp((-a * (z + b))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -2.1e-14], N[Not[LessEqual[y, 1.65e-26]], $MachinePrecision]], N[(x * N[Exp[N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(x * N[Exp[N[((-a) * N[(z + b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -2.1 \cdot 10^{-14} \lor \neg \left(y \leq 1.65 \cdot 10^{-26}\right):\\
\;\;\;\;x \cdot e^{y \cdot \left(\log z - t\right)}\\
\mathbf{else}:\\
\;\;\;\;x \cdot e^{\left(-a\right) \cdot \left(z + b\right)}\\
\end{array}
\end{array}
if y < -2.0999999999999999e-14 or 1.6499999999999999e-26 < y Initial program 97.2%
fma-define97.2%
sub-neg97.2%
log1p-define100.0%
Simplified100.0%
Taylor expanded in a around 0 95.1%
if -2.0999999999999999e-14 < y < 1.6499999999999999e-26Initial program 95.8%
Taylor expanded in y around 0 84.9%
sub-neg84.9%
log1p-define89.1%
Simplified89.1%
Taylor expanded in z around 0 89.1%
+-commutative89.1%
associate-*r*89.1%
associate-*r*89.1%
distribute-lft-out89.1%
mul-1-neg89.1%
Simplified89.1%
Final simplification92.4%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* x (pow z y))))
(if (<= y -0.0076)
t_1
(if (<= y 6.2e-15)
(* x (exp (* (- a) (+ z b))))
(if (or (<= y 1.85e+155) (not (<= y 2e+262)))
t_1
(* x (exp (* t (- y)))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * pow(z, y);
double tmp;
if (y <= -0.0076) {
tmp = t_1;
} else if (y <= 6.2e-15) {
tmp = x * exp((-a * (z + b)));
} else if ((y <= 1.85e+155) || !(y <= 2e+262)) {
tmp = t_1;
} else {
tmp = x * exp((t * -y));
}
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 = x * (z ** y)
if (y <= (-0.0076d0)) then
tmp = t_1
else if (y <= 6.2d-15) then
tmp = x * exp((-a * (z + b)))
else if ((y <= 1.85d+155) .or. (.not. (y <= 2d+262))) then
tmp = t_1
else
tmp = x * exp((t * -y))
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 * Math.pow(z, y);
double tmp;
if (y <= -0.0076) {
tmp = t_1;
} else if (y <= 6.2e-15) {
tmp = x * Math.exp((-a * (z + b)));
} else if ((y <= 1.85e+155) || !(y <= 2e+262)) {
tmp = t_1;
} else {
tmp = x * Math.exp((t * -y));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x * math.pow(z, y) tmp = 0 if y <= -0.0076: tmp = t_1 elif y <= 6.2e-15: tmp = x * math.exp((-a * (z + b))) elif (y <= 1.85e+155) or not (y <= 2e+262): tmp = t_1 else: tmp = x * math.exp((t * -y)) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x * (z ^ y)) tmp = 0.0 if (y <= -0.0076) tmp = t_1; elseif (y <= 6.2e-15) tmp = Float64(x * exp(Float64(Float64(-a) * Float64(z + b)))); elseif ((y <= 1.85e+155) || !(y <= 2e+262)) tmp = t_1; else tmp = Float64(x * exp(Float64(t * Float64(-y)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x * (z ^ y); tmp = 0.0; if (y <= -0.0076) tmp = t_1; elseif (y <= 6.2e-15) tmp = x * exp((-a * (z + b))); elseif ((y <= 1.85e+155) || ~((y <= 2e+262))) tmp = t_1; else tmp = x * exp((t * -y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -0.0076], t$95$1, If[LessEqual[y, 6.2e-15], N[(x * N[Exp[N[((-a) * N[(z + b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[y, 1.85e+155], N[Not[LessEqual[y, 2e+262]], $MachinePrecision]], t$95$1, N[(x * N[Exp[N[(t * (-y)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot {z}^{y}\\
\mathbf{if}\;y \leq -0.0076:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 6.2 \cdot 10^{-15}:\\
\;\;\;\;x \cdot e^{\left(-a\right) \cdot \left(z + b\right)}\\
\mathbf{elif}\;y \leq 1.85 \cdot 10^{+155} \lor \neg \left(y \leq 2 \cdot 10^{+262}\right):\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x \cdot e^{t \cdot \left(-y\right)}\\
\end{array}
\end{array}
if y < -0.00759999999999999998 or 6.1999999999999998e-15 < y < 1.8499999999999999e155 or 2e262 < y Initial program 97.4%
fma-define97.4%
sub-neg97.4%
log1p-define100.0%
Simplified100.0%
Taylor expanded in a around 0 94.9%
Taylor expanded in t around 0 76.3%
if -0.00759999999999999998 < y < 6.1999999999999998e-15Initial program 95.9%
Taylor expanded in y around 0 84.5%
sub-neg84.5%
log1p-define88.6%
Simplified88.6%
Taylor expanded in z around 0 88.6%
+-commutative88.6%
associate-*r*88.6%
associate-*r*88.6%
distribute-lft-out88.6%
mul-1-neg88.6%
Simplified88.6%
if 1.8499999999999999e155 < y < 2e262Initial program 95.5%
fma-define95.5%
sub-neg95.5%
log1p-define100.0%
Simplified100.0%
Taylor expanded in a around 0 95.5%
Taylor expanded in t around inf 73.5%
neg-mul-173.5%
Simplified73.5%
Final simplification81.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* x (exp (* t (- y))))))
(if (<= t -3.1e+22)
t_1
(if (<= t -4.8e-69)
(* x (exp (* a (- b))))
(if (<= t 2e-18) (* x (pow z y)) t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * exp((t * -y));
double tmp;
if (t <= -3.1e+22) {
tmp = t_1;
} else if (t <= -4.8e-69) {
tmp = x * exp((a * -b));
} else if (t <= 2e-18) {
tmp = x * pow(z, 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 = x * exp((t * -y))
if (t <= (-3.1d+22)) then
tmp = t_1
else if (t <= (-4.8d-69)) then
tmp = x * exp((a * -b))
else if (t <= 2d-18) then
tmp = x * (z ** 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 = x * Math.exp((t * -y));
double tmp;
if (t <= -3.1e+22) {
tmp = t_1;
} else if (t <= -4.8e-69) {
tmp = x * Math.exp((a * -b));
} else if (t <= 2e-18) {
tmp = x * Math.pow(z, y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x * math.exp((t * -y)) tmp = 0 if t <= -3.1e+22: tmp = t_1 elif t <= -4.8e-69: tmp = x * math.exp((a * -b)) elif t <= 2e-18: tmp = x * math.pow(z, y) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x * exp(Float64(t * Float64(-y)))) tmp = 0.0 if (t <= -3.1e+22) tmp = t_1; elseif (t <= -4.8e-69) tmp = Float64(x * exp(Float64(a * Float64(-b)))); elseif (t <= 2e-18) tmp = Float64(x * (z ^ y)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x * exp((t * -y)); tmp = 0.0; if (t <= -3.1e+22) tmp = t_1; elseif (t <= -4.8e-69) tmp = x * exp((a * -b)); elseif (t <= 2e-18) tmp = x * (z ^ y); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[Exp[N[(t * (-y)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -3.1e+22], t$95$1, If[LessEqual[t, -4.8e-69], N[(x * N[Exp[N[(a * (-b)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2e-18], N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot e^{t \cdot \left(-y\right)}\\
\mathbf{if}\;t \leq -3.1 \cdot 10^{+22}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq -4.8 \cdot 10^{-69}:\\
\;\;\;\;x \cdot e^{a \cdot \left(-b\right)}\\
\mathbf{elif}\;t \leq 2 \cdot 10^{-18}:\\
\;\;\;\;x \cdot {z}^{y}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -3.1000000000000002e22 or 2.0000000000000001e-18 < t Initial program 99.2%
fma-define99.2%
sub-neg99.2%
log1p-define100.0%
Simplified100.0%
Taylor expanded in a around 0 80.3%
Taylor expanded in t around inf 80.3%
neg-mul-180.3%
Simplified80.3%
if -3.1000000000000002e22 < t < -4.8000000000000002e-69Initial program 89.0%
Taylor expanded in b around inf 78.2%
mul-1-neg78.2%
distribute-rgt-neg-out78.2%
Simplified78.2%
if -4.8000000000000002e-69 < t < 2.0000000000000001e-18Initial program 94.9%
fma-define94.9%
sub-neg94.9%
log1p-define100.0%
Simplified100.0%
Taylor expanded in a around 0 76.5%
Taylor expanded in t around 0 76.5%
Final simplification78.5%
(FPCore (x y z t a b) :precision binary64 (if (or (<= y -0.82) (not (<= y 6.2e-15))) (* x (pow z y)) (* x (exp (* a (- b))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -0.82) || !(y <= 6.2e-15)) {
tmp = x * pow(z, y);
} else {
tmp = x * exp((a * -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 <= (-0.82d0)) .or. (.not. (y <= 6.2d-15))) then
tmp = x * (z ** y)
else
tmp = x * exp((a * -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 <= -0.82) || !(y <= 6.2e-15)) {
tmp = x * Math.pow(z, y);
} else {
tmp = x * Math.exp((a * -b));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (y <= -0.82) or not (y <= 6.2e-15): tmp = x * math.pow(z, y) else: tmp = x * math.exp((a * -b)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((y <= -0.82) || !(y <= 6.2e-15)) tmp = Float64(x * (z ^ y)); else tmp = Float64(x * exp(Float64(a * Float64(-b)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((y <= -0.82) || ~((y <= 6.2e-15))) tmp = x * (z ^ y); else tmp = x * exp((a * -b)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -0.82], N[Not[LessEqual[y, 6.2e-15]], $MachinePrecision]], N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision], N[(x * N[Exp[N[(a * (-b)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -0.82 \lor \neg \left(y \leq 6.2 \cdot 10^{-15}\right):\\
\;\;\;\;x \cdot {z}^{y}\\
\mathbf{else}:\\
\;\;\;\;x \cdot e^{a \cdot \left(-b\right)}\\
\end{array}
\end{array}
if y < -0.819999999999999951 or 6.1999999999999998e-15 < y Initial program 97.1%
fma-define97.1%
sub-neg97.1%
log1p-define100.0%
Simplified100.0%
Taylor expanded in a around 0 95.0%
Taylor expanded in t around 0 72.9%
if -0.819999999999999951 < y < 6.1999999999999998e-15Initial program 95.9%
Taylor expanded in b around inf 82.8%
mul-1-neg82.8%
distribute-rgt-neg-out82.8%
Simplified82.8%
Final simplification77.5%
(FPCore (x y z t a b) :precision binary64 (if (<= t -1.3e-6) (* x (- 1.0 (* y t))) (* x (pow z y))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -1.3e-6) {
tmp = x * (1.0 - (y * t));
} else {
tmp = x * pow(z, y);
}
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-6)) then
tmp = x * (1.0d0 - (y * t))
else
tmp = x * (z ** y)
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-6) {
tmp = x * (1.0 - (y * t));
} else {
tmp = x * Math.pow(z, y);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -1.3e-6: tmp = x * (1.0 - (y * t)) else: tmp = x * math.pow(z, y) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -1.3e-6) tmp = Float64(x * Float64(1.0 - Float64(y * t))); else tmp = Float64(x * (z ^ y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -1.3e-6) tmp = x * (1.0 - (y * t)); else tmp = x * (z ^ y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -1.3e-6], N[(x * N[(1.0 - N[(y * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.3 \cdot 10^{-6}:\\
\;\;\;\;x \cdot \left(1 - y \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot {z}^{y}\\
\end{array}
\end{array}
if t < -1.30000000000000005e-6Initial program 98.5%
fma-define98.5%
sub-neg98.5%
log1p-define100.0%
Simplified100.0%
Taylor expanded in a around 0 81.0%
Taylor expanded in t around inf 82.5%
neg-mul-182.5%
Simplified82.5%
Taylor expanded in y around 0 35.9%
mul-1-neg35.9%
unsub-neg35.9%
*-commutative35.9%
Simplified35.9%
if -1.30000000000000005e-6 < t Initial program 95.9%
fma-define95.9%
sub-neg95.9%
log1p-define100.0%
Simplified100.0%
Taylor expanded in a around 0 74.8%
Taylor expanded in t around 0 69.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* a (* x (- z)))))
(if (<= y -1.65e+214)
(* x (* a (- b)))
(if (<= y -2.2e+151)
(* x (- 1.0 (* y t)))
(if (<= y -4.8e+70)
t_1
(if (<= y 58.0)
(- x (* a (* x b)))
(if (<= y 1.02e+105) t_1 (* x (* t (- y))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a * (x * -z);
double tmp;
if (y <= -1.65e+214) {
tmp = x * (a * -b);
} else if (y <= -2.2e+151) {
tmp = x * (1.0 - (y * t));
} else if (y <= -4.8e+70) {
tmp = t_1;
} else if (y <= 58.0) {
tmp = x - (a * (x * b));
} else if (y <= 1.02e+105) {
tmp = t_1;
} else {
tmp = x * (t * -y);
}
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 * (x * -z)
if (y <= (-1.65d+214)) then
tmp = x * (a * -b)
else if (y <= (-2.2d+151)) then
tmp = x * (1.0d0 - (y * t))
else if (y <= (-4.8d+70)) then
tmp = t_1
else if (y <= 58.0d0) then
tmp = x - (a * (x * b))
else if (y <= 1.02d+105) then
tmp = t_1
else
tmp = x * (t * -y)
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 * -z);
double tmp;
if (y <= -1.65e+214) {
tmp = x * (a * -b);
} else if (y <= -2.2e+151) {
tmp = x * (1.0 - (y * t));
} else if (y <= -4.8e+70) {
tmp = t_1;
} else if (y <= 58.0) {
tmp = x - (a * (x * b));
} else if (y <= 1.02e+105) {
tmp = t_1;
} else {
tmp = x * (t * -y);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = a * (x * -z) tmp = 0 if y <= -1.65e+214: tmp = x * (a * -b) elif y <= -2.2e+151: tmp = x * (1.0 - (y * t)) elif y <= -4.8e+70: tmp = t_1 elif y <= 58.0: tmp = x - (a * (x * b)) elif y <= 1.02e+105: tmp = t_1 else: tmp = x * (t * -y) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(a * Float64(x * Float64(-z))) tmp = 0.0 if (y <= -1.65e+214) tmp = Float64(x * Float64(a * Float64(-b))); elseif (y <= -2.2e+151) tmp = Float64(x * Float64(1.0 - Float64(y * t))); elseif (y <= -4.8e+70) tmp = t_1; elseif (y <= 58.0) tmp = Float64(x - Float64(a * Float64(x * b))); elseif (y <= 1.02e+105) tmp = t_1; else tmp = Float64(x * Float64(t * Float64(-y))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = a * (x * -z); tmp = 0.0; if (y <= -1.65e+214) tmp = x * (a * -b); elseif (y <= -2.2e+151) tmp = x * (1.0 - (y * t)); elseif (y <= -4.8e+70) tmp = t_1; elseif (y <= 58.0) tmp = x - (a * (x * b)); elseif (y <= 1.02e+105) tmp = t_1; else tmp = x * (t * -y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a * N[(x * (-z)), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.65e+214], N[(x * N[(a * (-b)), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -2.2e+151], N[(x * N[(1.0 - N[(y * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -4.8e+70], t$95$1, If[LessEqual[y, 58.0], N[(x - N[(a * N[(x * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.02e+105], t$95$1, N[(x * N[(t * (-y)), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(x \cdot \left(-z\right)\right)\\
\mathbf{if}\;y \leq -1.65 \cdot 10^{+214}:\\
\;\;\;\;x \cdot \left(a \cdot \left(-b\right)\right)\\
\mathbf{elif}\;y \leq -2.2 \cdot 10^{+151}:\\
\;\;\;\;x \cdot \left(1 - y \cdot t\right)\\
\mathbf{elif}\;y \leq -4.8 \cdot 10^{+70}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 58:\\
\;\;\;\;x - a \cdot \left(x \cdot b\right)\\
\mathbf{elif}\;y \leq 1.02 \cdot 10^{+105}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(t \cdot \left(-y\right)\right)\\
\end{array}
\end{array}
if y < -1.65000000000000006e214Initial program 100.0%
Taylor expanded in y around 0 49.5%
sub-neg49.5%
log1p-define49.5%
Simplified49.5%
Taylor expanded in z around 0 49.5%
+-commutative49.5%
associate-*r*49.5%
associate-*r*49.5%
distribute-lft-out49.5%
mul-1-neg49.5%
Simplified49.5%
Taylor expanded in a around 0 23.2%
mul-1-neg23.2%
unsub-neg23.2%
*-commutative23.2%
*-commutative23.2%
associate-*l*23.4%
+-commutative23.4%
Simplified23.4%
Taylor expanded in b around inf 31.5%
mul-1-neg31.5%
associate-*r*42.5%
*-commutative42.5%
distribute-rgt-neg-in42.5%
*-commutative42.5%
distribute-rgt-neg-in42.5%
Simplified42.5%
if -1.65000000000000006e214 < y < -2.20000000000000007e151Initial program 100.0%
fma-define100.0%
sub-neg100.0%
log1p-define100.0%
Simplified100.0%
Taylor expanded in a around 0 100.0%
Taylor expanded in t around inf 60.9%
neg-mul-160.9%
Simplified60.9%
Taylor expanded in y around 0 35.2%
mul-1-neg35.2%
unsub-neg35.2%
*-commutative35.2%
Simplified35.2%
if -2.20000000000000007e151 < y < -4.79999999999999974e70 or 58 < y < 1.02e105Initial program 95.3%
Taylor expanded in y around 0 33.5%
sub-neg33.5%
log1p-define40.3%
Simplified40.3%
Taylor expanded in z around 0 40.3%
+-commutative40.3%
associate-*r*40.3%
associate-*r*40.3%
distribute-lft-out40.3%
mul-1-neg40.3%
Simplified40.3%
Taylor expanded in a around 0 5.7%
mul-1-neg5.7%
unsub-neg5.7%
*-commutative5.7%
*-commutative5.7%
associate-*l*5.9%
+-commutative5.9%
Simplified5.9%
Taylor expanded in z around inf 41.6%
if -4.79999999999999974e70 < y < 58Initial program 95.7%
Taylor expanded in b around inf 75.9%
mul-1-neg75.9%
distribute-rgt-neg-out75.9%
Simplified75.9%
Taylor expanded in a around 0 40.0%
mul-1-neg40.0%
unsub-neg40.0%
*-commutative40.0%
Simplified40.0%
if 1.02e105 < y Initial program 97.4%
fma-define97.4%
sub-neg97.4%
log1p-define100.0%
Simplified100.0%
Taylor expanded in a around 0 97.4%
Taylor expanded in t around inf 67.1%
neg-mul-167.1%
Simplified67.1%
Taylor expanded in y around 0 33.9%
mul-1-neg33.9%
unsub-neg33.9%
*-commutative33.9%
Simplified33.9%
Taylor expanded in y around inf 33.6%
mul-1-neg33.6%
*-commutative33.6%
distribute-rgt-neg-in33.6%
associate-*r*41.2%
Simplified41.2%
Final simplification40.4%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* x (* t (- y)))) (t_2 (* x (* a (- b)))))
(if (<= y -2.45e+216)
t_2
(if (<= y -2.25e+134)
t_1
(if (<= y -3.7e-36)
t_2
(if (<= y 9.8e-138)
x
(if (<= y 2.45e+107) (* a (* x (- z))) t_1)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * (t * -y);
double t_2 = x * (a * -b);
double tmp;
if (y <= -2.45e+216) {
tmp = t_2;
} else if (y <= -2.25e+134) {
tmp = t_1;
} else if (y <= -3.7e-36) {
tmp = t_2;
} else if (y <= 9.8e-138) {
tmp = x;
} else if (y <= 2.45e+107) {
tmp = a * (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) :: t_2
real(8) :: tmp
t_1 = x * (t * -y)
t_2 = x * (a * -b)
if (y <= (-2.45d+216)) then
tmp = t_2
else if (y <= (-2.25d+134)) then
tmp = t_1
else if (y <= (-3.7d-36)) then
tmp = t_2
else if (y <= 9.8d-138) then
tmp = x
else if (y <= 2.45d+107) then
tmp = a * (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 = x * (t * -y);
double t_2 = x * (a * -b);
double tmp;
if (y <= -2.45e+216) {
tmp = t_2;
} else if (y <= -2.25e+134) {
tmp = t_1;
} else if (y <= -3.7e-36) {
tmp = t_2;
} else if (y <= 9.8e-138) {
tmp = x;
} else if (y <= 2.45e+107) {
tmp = a * (x * -z);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x * (t * -y) t_2 = x * (a * -b) tmp = 0 if y <= -2.45e+216: tmp = t_2 elif y <= -2.25e+134: tmp = t_1 elif y <= -3.7e-36: tmp = t_2 elif y <= 9.8e-138: tmp = x elif y <= 2.45e+107: tmp = a * (x * -z) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x * Float64(t * Float64(-y))) t_2 = Float64(x * Float64(a * Float64(-b))) tmp = 0.0 if (y <= -2.45e+216) tmp = t_2; elseif (y <= -2.25e+134) tmp = t_1; elseif (y <= -3.7e-36) tmp = t_2; elseif (y <= 9.8e-138) tmp = x; elseif (y <= 2.45e+107) tmp = Float64(a * Float64(x * Float64(-z))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x * (t * -y); t_2 = x * (a * -b); tmp = 0.0; if (y <= -2.45e+216) tmp = t_2; elseif (y <= -2.25e+134) tmp = t_1; elseif (y <= -3.7e-36) tmp = t_2; elseif (y <= 9.8e-138) tmp = x; elseif (y <= 2.45e+107) tmp = a * (x * -z); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[(t * (-y)), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(a * (-b)), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.45e+216], t$95$2, If[LessEqual[y, -2.25e+134], t$95$1, If[LessEqual[y, -3.7e-36], t$95$2, If[LessEqual[y, 9.8e-138], x, If[LessEqual[y, 2.45e+107], N[(a * N[(x * (-z)), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(t \cdot \left(-y\right)\right)\\
t_2 := x \cdot \left(a \cdot \left(-b\right)\right)\\
\mathbf{if}\;y \leq -2.45 \cdot 10^{+216}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -2.25 \cdot 10^{+134}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -3.7 \cdot 10^{-36}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq 9.8 \cdot 10^{-138}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 2.45 \cdot 10^{+107}:\\
\;\;\;\;a \cdot \left(x \cdot \left(-z\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -2.45000000000000007e216 or -2.2499999999999999e134 < y < -3.70000000000000002e-36Initial program 95.4%
Taylor expanded in y around 0 45.3%
sub-neg45.3%
log1p-define51.4%
Simplified51.4%
Taylor expanded in z around 0 51.4%
+-commutative51.4%
associate-*r*51.4%
associate-*r*51.4%
distribute-lft-out51.4%
mul-1-neg51.4%
Simplified51.4%
Taylor expanded in a around 0 21.4%
mul-1-neg21.4%
unsub-neg21.4%
*-commutative21.4%
*-commutative21.4%
associate-*l*21.5%
+-commutative21.5%
Simplified21.5%
Taylor expanded in b around inf 24.6%
mul-1-neg24.6%
associate-*r*30.4%
*-commutative30.4%
distribute-rgt-neg-in30.4%
*-commutative30.4%
distribute-rgt-neg-in30.4%
Simplified30.4%
if -2.45000000000000007e216 < y < -2.2499999999999999e134 or 2.4500000000000001e107 < y Initial program 98.3%
fma-define98.3%
sub-neg98.3%
log1p-define100.0%
Simplified100.0%
Taylor expanded in a around 0 98.3%
Taylor expanded in t around inf 67.2%
neg-mul-167.2%
Simplified67.2%
Taylor expanded in y around 0 32.6%
mul-1-neg32.6%
unsub-neg32.6%
*-commutative32.6%
Simplified32.6%
Taylor expanded in y around inf 24.4%
mul-1-neg24.4%
*-commutative24.4%
distribute-rgt-neg-in24.4%
associate-*r*37.2%
Simplified37.2%
if -3.70000000000000002e-36 < y < 9.80000000000000033e-138Initial program 96.6%
Taylor expanded in b around inf 83.8%
mul-1-neg83.8%
distribute-rgt-neg-out83.8%
Simplified83.8%
Taylor expanded in a around 0 43.0%
if 9.80000000000000033e-138 < y < 2.4500000000000001e107Initial program 95.9%
Taylor expanded in y around 0 56.0%
sub-neg56.0%
log1p-define60.1%
Simplified60.1%
Taylor expanded in z around 0 60.1%
+-commutative60.1%
associate-*r*60.1%
associate-*r*60.1%
distribute-lft-out60.1%
mul-1-neg60.1%
Simplified60.1%
Taylor expanded in a around 0 20.9%
mul-1-neg20.9%
unsub-neg20.9%
*-commutative20.9%
*-commutative20.9%
associate-*l*20.2%
+-commutative20.2%
Simplified20.2%
Taylor expanded in z around inf 38.0%
Final simplification37.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* x (* t (- y)))) (t_2 (* x (* a (- b)))))
(if (<= y -4.8e+215)
t_2
(if (<= y -1.2e+131)
t_1
(if (<= y -1.5e-35)
t_2
(if (<= y 1.45e-136)
x
(if (<= y 1.65e+101) (* z (* x (- a))) t_1)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * (t * -y);
double t_2 = x * (a * -b);
double tmp;
if (y <= -4.8e+215) {
tmp = t_2;
} else if (y <= -1.2e+131) {
tmp = t_1;
} else if (y <= -1.5e-35) {
tmp = t_2;
} else if (y <= 1.45e-136) {
tmp = x;
} else if (y <= 1.65e+101) {
tmp = z * (x * -a);
} 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) :: t_2
real(8) :: tmp
t_1 = x * (t * -y)
t_2 = x * (a * -b)
if (y <= (-4.8d+215)) then
tmp = t_2
else if (y <= (-1.2d+131)) then
tmp = t_1
else if (y <= (-1.5d-35)) then
tmp = t_2
else if (y <= 1.45d-136) then
tmp = x
else if (y <= 1.65d+101) then
tmp = z * (x * -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 b) {
double t_1 = x * (t * -y);
double t_2 = x * (a * -b);
double tmp;
if (y <= -4.8e+215) {
tmp = t_2;
} else if (y <= -1.2e+131) {
tmp = t_1;
} else if (y <= -1.5e-35) {
tmp = t_2;
} else if (y <= 1.45e-136) {
tmp = x;
} else if (y <= 1.65e+101) {
tmp = z * (x * -a);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x * (t * -y) t_2 = x * (a * -b) tmp = 0 if y <= -4.8e+215: tmp = t_2 elif y <= -1.2e+131: tmp = t_1 elif y <= -1.5e-35: tmp = t_2 elif y <= 1.45e-136: tmp = x elif y <= 1.65e+101: tmp = z * (x * -a) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x * Float64(t * Float64(-y))) t_2 = Float64(x * Float64(a * Float64(-b))) tmp = 0.0 if (y <= -4.8e+215) tmp = t_2; elseif (y <= -1.2e+131) tmp = t_1; elseif (y <= -1.5e-35) tmp = t_2; elseif (y <= 1.45e-136) tmp = x; elseif (y <= 1.65e+101) tmp = Float64(z * Float64(x * Float64(-a))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x * (t * -y); t_2 = x * (a * -b); tmp = 0.0; if (y <= -4.8e+215) tmp = t_2; elseif (y <= -1.2e+131) tmp = t_1; elseif (y <= -1.5e-35) tmp = t_2; elseif (y <= 1.45e-136) tmp = x; elseif (y <= 1.65e+101) tmp = z * (x * -a); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[(t * (-y)), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(a * (-b)), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -4.8e+215], t$95$2, If[LessEqual[y, -1.2e+131], t$95$1, If[LessEqual[y, -1.5e-35], t$95$2, If[LessEqual[y, 1.45e-136], x, If[LessEqual[y, 1.65e+101], N[(z * N[(x * (-a)), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(t \cdot \left(-y\right)\right)\\
t_2 := x \cdot \left(a \cdot \left(-b\right)\right)\\
\mathbf{if}\;y \leq -4.8 \cdot 10^{+215}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -1.2 \cdot 10^{+131}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -1.5 \cdot 10^{-35}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq 1.45 \cdot 10^{-136}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 1.65 \cdot 10^{+101}:\\
\;\;\;\;z \cdot \left(x \cdot \left(-a\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -4.8000000000000002e215 or -1.2e131 < y < -1.49999999999999994e-35Initial program 95.4%
Taylor expanded in y around 0 45.3%
sub-neg45.3%
log1p-define51.4%
Simplified51.4%
Taylor expanded in z around 0 51.4%
+-commutative51.4%
associate-*r*51.4%
associate-*r*51.4%
distribute-lft-out51.4%
mul-1-neg51.4%
Simplified51.4%
Taylor expanded in a around 0 21.4%
mul-1-neg21.4%
unsub-neg21.4%
*-commutative21.4%
*-commutative21.4%
associate-*l*21.5%
+-commutative21.5%
Simplified21.5%
Taylor expanded in b around inf 24.6%
mul-1-neg24.6%
associate-*r*30.4%
*-commutative30.4%
distribute-rgt-neg-in30.4%
*-commutative30.4%
distribute-rgt-neg-in30.4%
Simplified30.4%
if -4.8000000000000002e215 < y < -1.2e131 or 1.65000000000000006e101 < y Initial program 98.3%
fma-define98.3%
sub-neg98.3%
log1p-define100.0%
Simplified100.0%
Taylor expanded in a around 0 98.3%
Taylor expanded in t around inf 67.2%
neg-mul-167.2%
Simplified67.2%
Taylor expanded in y around 0 32.6%
mul-1-neg32.6%
unsub-neg32.6%
*-commutative32.6%
Simplified32.6%
Taylor expanded in y around inf 24.4%
mul-1-neg24.4%
*-commutative24.4%
distribute-rgt-neg-in24.4%
associate-*r*37.2%
Simplified37.2%
if -1.49999999999999994e-35 < y < 1.44999999999999997e-136Initial program 95.5%
Taylor expanded in b around inf 83.0%
mul-1-neg83.0%
distribute-rgt-neg-out83.0%
Simplified83.0%
Taylor expanded in a around 0 42.5%
if 1.44999999999999997e-136 < y < 1.65000000000000006e101Initial program 97.8%
Taylor expanded in y around 0 57.1%
sub-neg57.1%
log1p-define59.2%
Simplified59.2%
Taylor expanded in z around 0 59.2%
+-commutative59.2%
associate-*r*59.2%
associate-*r*59.2%
distribute-lft-out59.2%
mul-1-neg59.2%
Simplified59.2%
Taylor expanded in a around 0 21.3%
mul-1-neg21.3%
unsub-neg21.3%
*-commutative21.3%
*-commutative21.3%
associate-*l*20.6%
+-commutative20.6%
Simplified20.6%
Taylor expanded in z around inf 36.7%
associate-*r*32.7%
*-commutative32.7%
associate-*r*32.7%
neg-mul-132.7%
distribute-rgt-neg-in32.7%
Simplified32.7%
Final simplification36.5%
(FPCore (x y z t a b)
:precision binary64
(if (<= a -1.15e+21)
(- x (* z (* a (+ x (/ (* x b) z)))))
(if (<= a 126000000.0)
(* x (- 1.0 (* y t)))
(if (<= a 1.3e+87)
(* a (* x (- z)))
(if (<= a 3.2e+242) (- x (* x (* a b))) (* a (* x (- b))))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= -1.15e+21) {
tmp = x - (z * (a * (x + ((x * b) / z))));
} else if (a <= 126000000.0) {
tmp = x * (1.0 - (y * t));
} else if (a <= 1.3e+87) {
tmp = a * (x * -z);
} else if (a <= 3.2e+242) {
tmp = x - (x * (a * b));
} else {
tmp = a * (x * -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 (a <= (-1.15d+21)) then
tmp = x - (z * (a * (x + ((x * b) / z))))
else if (a <= 126000000.0d0) then
tmp = x * (1.0d0 - (y * t))
else if (a <= 1.3d+87) then
tmp = a * (x * -z)
else if (a <= 3.2d+242) then
tmp = x - (x * (a * b))
else
tmp = a * (x * -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 (a <= -1.15e+21) {
tmp = x - (z * (a * (x + ((x * b) / z))));
} else if (a <= 126000000.0) {
tmp = x * (1.0 - (y * t));
} else if (a <= 1.3e+87) {
tmp = a * (x * -z);
} else if (a <= 3.2e+242) {
tmp = x - (x * (a * b));
} else {
tmp = a * (x * -b);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if a <= -1.15e+21: tmp = x - (z * (a * (x + ((x * b) / z)))) elif a <= 126000000.0: tmp = x * (1.0 - (y * t)) elif a <= 1.3e+87: tmp = a * (x * -z) elif a <= 3.2e+242: tmp = x - (x * (a * b)) else: tmp = a * (x * -b) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (a <= -1.15e+21) tmp = Float64(x - Float64(z * Float64(a * Float64(x + Float64(Float64(x * b) / z))))); elseif (a <= 126000000.0) tmp = Float64(x * Float64(1.0 - Float64(y * t))); elseif (a <= 1.3e+87) tmp = Float64(a * Float64(x * Float64(-z))); elseif (a <= 3.2e+242) tmp = Float64(x - Float64(x * Float64(a * b))); else tmp = Float64(a * Float64(x * Float64(-b))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (a <= -1.15e+21) tmp = x - (z * (a * (x + ((x * b) / z)))); elseif (a <= 126000000.0) tmp = x * (1.0 - (y * t)); elseif (a <= 1.3e+87) tmp = a * (x * -z); elseif (a <= 3.2e+242) tmp = x - (x * (a * b)); else tmp = a * (x * -b); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[a, -1.15e+21], N[(x - N[(z * N[(a * N[(x + N[(N[(x * b), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 126000000.0], N[(x * N[(1.0 - N[(y * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.3e+87], N[(a * N[(x * (-z)), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.2e+242], N[(x - N[(x * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(a * N[(x * (-b)), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.15 \cdot 10^{+21}:\\
\;\;\;\;x - z \cdot \left(a \cdot \left(x + \frac{x \cdot b}{z}\right)\right)\\
\mathbf{elif}\;a \leq 126000000:\\
\;\;\;\;x \cdot \left(1 - y \cdot t\right)\\
\mathbf{elif}\;a \leq 1.3 \cdot 10^{+87}:\\
\;\;\;\;a \cdot \left(x \cdot \left(-z\right)\right)\\
\mathbf{elif}\;a \leq 3.2 \cdot 10^{+242}:\\
\;\;\;\;x - x \cdot \left(a \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;a \cdot \left(x \cdot \left(-b\right)\right)\\
\end{array}
\end{array}
if a < -1.15e21Initial program 93.7%
Taylor expanded in y around 0 74.8%
sub-neg74.8%
log1p-define84.2%
Simplified84.2%
Taylor expanded in z around 0 84.2%
+-commutative84.2%
associate-*r*84.2%
associate-*r*84.2%
distribute-lft-out84.2%
mul-1-neg84.2%
Simplified84.2%
Taylor expanded in a around 0 25.2%
mul-1-neg25.2%
unsub-neg25.2%
*-commutative25.2%
*-commutative25.2%
associate-*l*29.7%
+-commutative29.7%
Simplified29.7%
Taylor expanded in z around inf 35.4%
+-commutative35.4%
associate-/l*35.4%
distribute-lft-out37.2%
*-commutative37.2%
Simplified37.2%
if -1.15e21 < a < 1.26e8Initial program 100.0%
fma-define100.0%
sub-neg100.0%
log1p-define100.0%
Simplified100.0%
Taylor expanded in a around 0 90.5%
Taylor expanded in t around inf 73.0%
neg-mul-173.0%
Simplified73.0%
Taylor expanded in y around 0 44.3%
mul-1-neg44.3%
unsub-neg44.3%
*-commutative44.3%
Simplified44.3%
if 1.26e8 < a < 1.29999999999999999e87Initial program 100.0%
Taylor expanded in y around 0 72.2%
sub-neg72.2%
log1p-define72.2%
Simplified72.2%
Taylor expanded in z around 0 72.2%
+-commutative72.2%
associate-*r*72.2%
associate-*r*72.2%
distribute-lft-out72.2%
mul-1-neg72.2%
Simplified72.2%
Taylor expanded in a around 0 5.6%
mul-1-neg5.6%
unsub-neg5.6%
*-commutative5.6%
*-commutative5.6%
associate-*l*2.9%
+-commutative2.9%
Simplified2.9%
Taylor expanded in z around inf 33.2%
if 1.29999999999999999e87 < a < 3.2000000000000002e242Initial program 92.4%
Taylor expanded in y around 0 58.7%
sub-neg58.7%
log1p-define69.8%
Simplified69.8%
Taylor expanded in z around 0 69.8%
+-commutative69.8%
associate-*r*69.8%
associate-*r*69.8%
distribute-lft-out69.8%
mul-1-neg69.8%
Simplified69.8%
Taylor expanded in a around 0 21.6%
mul-1-neg21.6%
unsub-neg21.6%
*-commutative21.6%
*-commutative21.6%
associate-*l*21.5%
+-commutative21.5%
Simplified21.5%
Taylor expanded in z around 0 21.7%
associate-*r*36.0%
*-commutative36.0%
Simplified36.0%
if 3.2000000000000002e242 < a Initial program 79.3%
Taylor expanded in y around 0 72.2%
sub-neg72.2%
log1p-define93.0%
Simplified93.0%
Taylor expanded in z around 0 93.0%
+-commutative93.0%
associate-*r*93.0%
associate-*r*93.0%
distribute-lft-out93.0%
mul-1-neg93.0%
Simplified93.0%
Taylor expanded in a around 0 37.8%
mul-1-neg37.8%
unsub-neg37.8%
*-commutative37.8%
*-commutative37.8%
associate-*l*37.6%
+-commutative37.6%
Simplified37.6%
Taylor expanded in b around inf 51.4%
Final simplification41.4%
(FPCore (x y z t a b)
:precision binary64
(if (<= a -1.02e+223)
(* z (* x (- a)))
(if (<= a -2.85e+82)
(* x (* t (- y)))
(if (<= a -6.5e+19)
(* a (* x (- z)))
(if (<= a 3.8e+98) (* x (- 1.0 (* y t))) (* x (* a (- b))))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= -1.02e+223) {
tmp = z * (x * -a);
} else if (a <= -2.85e+82) {
tmp = x * (t * -y);
} else if (a <= -6.5e+19) {
tmp = a * (x * -z);
} else if (a <= 3.8e+98) {
tmp = x * (1.0 - (y * t));
} else {
tmp = x * (a * -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 (a <= (-1.02d+223)) then
tmp = z * (x * -a)
else if (a <= (-2.85d+82)) then
tmp = x * (t * -y)
else if (a <= (-6.5d+19)) then
tmp = a * (x * -z)
else if (a <= 3.8d+98) then
tmp = x * (1.0d0 - (y * t))
else
tmp = x * (a * -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 (a <= -1.02e+223) {
tmp = z * (x * -a);
} else if (a <= -2.85e+82) {
tmp = x * (t * -y);
} else if (a <= -6.5e+19) {
tmp = a * (x * -z);
} else if (a <= 3.8e+98) {
tmp = x * (1.0 - (y * t));
} else {
tmp = x * (a * -b);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if a <= -1.02e+223: tmp = z * (x * -a) elif a <= -2.85e+82: tmp = x * (t * -y) elif a <= -6.5e+19: tmp = a * (x * -z) elif a <= 3.8e+98: tmp = x * (1.0 - (y * t)) else: tmp = x * (a * -b) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (a <= -1.02e+223) tmp = Float64(z * Float64(x * Float64(-a))); elseif (a <= -2.85e+82) tmp = Float64(x * Float64(t * Float64(-y))); elseif (a <= -6.5e+19) tmp = Float64(a * Float64(x * Float64(-z))); elseif (a <= 3.8e+98) tmp = Float64(x * Float64(1.0 - Float64(y * t))); else tmp = Float64(x * Float64(a * Float64(-b))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (a <= -1.02e+223) tmp = z * (x * -a); elseif (a <= -2.85e+82) tmp = x * (t * -y); elseif (a <= -6.5e+19) tmp = a * (x * -z); elseif (a <= 3.8e+98) tmp = x * (1.0 - (y * t)); else tmp = x * (a * -b); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[a, -1.02e+223], N[(z * N[(x * (-a)), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -2.85e+82], N[(x * N[(t * (-y)), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -6.5e+19], N[(a * N[(x * (-z)), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.8e+98], N[(x * N[(1.0 - N[(y * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(a * (-b)), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.02 \cdot 10^{+223}:\\
\;\;\;\;z \cdot \left(x \cdot \left(-a\right)\right)\\
\mathbf{elif}\;a \leq -2.85 \cdot 10^{+82}:\\
\;\;\;\;x \cdot \left(t \cdot \left(-y\right)\right)\\
\mathbf{elif}\;a \leq -6.5 \cdot 10^{+19}:\\
\;\;\;\;a \cdot \left(x \cdot \left(-z\right)\right)\\
\mathbf{elif}\;a \leq 3.8 \cdot 10^{+98}:\\
\;\;\;\;x \cdot \left(1 - y \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(a \cdot \left(-b\right)\right)\\
\end{array}
\end{array}
if a < -1.02e223Initial program 79.3%
Taylor expanded in y around 0 64.0%
sub-neg64.0%
log1p-define94.8%
Simplified94.8%
Taylor expanded in z around 0 94.8%
+-commutative94.8%
associate-*r*94.8%
associate-*r*94.8%
distribute-lft-out94.8%
mul-1-neg94.8%
Simplified94.8%
Taylor expanded in a around 0 34.1%
mul-1-neg34.1%
unsub-neg34.1%
*-commutative34.1%
*-commutative34.1%
associate-*l*49.1%
+-commutative49.1%
Simplified49.1%
Taylor expanded in z around inf 24.3%
associate-*r*49.2%
*-commutative49.2%
associate-*r*49.2%
neg-mul-149.2%
distribute-rgt-neg-in49.2%
Simplified49.2%
if -1.02e223 < a < -2.85000000000000008e82Initial program 100.0%
fma-define100.0%
sub-neg100.0%
log1p-define100.0%
Simplified100.0%
Taylor expanded in a around 0 61.4%
Taylor expanded in t around inf 51.8%
neg-mul-151.8%
Simplified51.8%
Taylor expanded in y around 0 13.1%
mul-1-neg13.1%
unsub-neg13.1%
*-commutative13.1%
Simplified13.1%
Taylor expanded in y around inf 22.9%
mul-1-neg22.9%
*-commutative22.9%
distribute-rgt-neg-in22.9%
associate-*r*27.7%
Simplified27.7%
if -2.85000000000000008e82 < a < -6.5e19Initial program 100.0%
Taylor expanded in y around 0 83.8%
sub-neg83.8%
log1p-define83.8%
Simplified83.8%
Taylor expanded in z around 0 83.8%
+-commutative83.8%
associate-*r*83.8%
associate-*r*83.8%
distribute-lft-out83.8%
mul-1-neg83.8%
Simplified83.8%
Taylor expanded in a around 0 27.3%
mul-1-neg27.3%
unsub-neg27.3%
*-commutative27.3%
*-commutative27.3%
associate-*l*27.3%
+-commutative27.3%
Simplified27.3%
Taylor expanded in z around inf 27.6%
if -6.5e19 < a < 3.7999999999999999e98Initial program 100.0%
fma-define100.0%
sub-neg100.0%
log1p-define100.0%
Simplified100.0%
Taylor expanded in a around 0 87.1%
Taylor expanded in t around inf 70.8%
neg-mul-170.8%
Simplified70.8%
Taylor expanded in y around 0 41.1%
mul-1-neg41.1%
unsub-neg41.1%
*-commutative41.1%
Simplified41.1%
if 3.7999999999999999e98 < a Initial program 87.5%
Taylor expanded in y around 0 62.5%
sub-neg62.5%
log1p-define77.3%
Simplified77.3%
Taylor expanded in z around 0 77.3%
+-commutative77.3%
associate-*r*77.3%
associate-*r*77.3%
distribute-lft-out77.3%
mul-1-neg77.3%
Simplified77.3%
Taylor expanded in a around 0 25.4%
mul-1-neg25.4%
unsub-neg25.4%
*-commutative25.4%
*-commutative25.4%
associate-*l*25.3%
+-commutative25.3%
Simplified25.3%
Taylor expanded in b around inf 32.7%
mul-1-neg32.7%
associate-*r*35.1%
*-commutative35.1%
distribute-rgt-neg-in35.1%
*-commutative35.1%
distribute-rgt-neg-in35.1%
Simplified35.1%
Final simplification38.5%
(FPCore (x y z t a b)
:precision binary64
(if (<= y -2.4e+216)
(* x (* a (- b)))
(if (<= y -1.05e+132)
(* x (- 1.0 (* y t)))
(if (<= y 0.1)
(- x (* x (* a b)))
(if (<= y 7.2e+106) (* a (* x (- z))) (* x (* t (- y))))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (y <= -2.4e+216) {
tmp = x * (a * -b);
} else if (y <= -1.05e+132) {
tmp = x * (1.0 - (y * t));
} else if (y <= 0.1) {
tmp = x - (x * (a * b));
} else if (y <= 7.2e+106) {
tmp = a * (x * -z);
} else {
tmp = x * (t * -y);
}
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 <= (-2.4d+216)) then
tmp = x * (a * -b)
else if (y <= (-1.05d+132)) then
tmp = x * (1.0d0 - (y * t))
else if (y <= 0.1d0) then
tmp = x - (x * (a * b))
else if (y <= 7.2d+106) then
tmp = a * (x * -z)
else
tmp = x * (t * -y)
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 <= -2.4e+216) {
tmp = x * (a * -b);
} else if (y <= -1.05e+132) {
tmp = x * (1.0 - (y * t));
} else if (y <= 0.1) {
tmp = x - (x * (a * b));
} else if (y <= 7.2e+106) {
tmp = a * (x * -z);
} else {
tmp = x * (t * -y);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if y <= -2.4e+216: tmp = x * (a * -b) elif y <= -1.05e+132: tmp = x * (1.0 - (y * t)) elif y <= 0.1: tmp = x - (x * (a * b)) elif y <= 7.2e+106: tmp = a * (x * -z) else: tmp = x * (t * -y) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (y <= -2.4e+216) tmp = Float64(x * Float64(a * Float64(-b))); elseif (y <= -1.05e+132) tmp = Float64(x * Float64(1.0 - Float64(y * t))); elseif (y <= 0.1) tmp = Float64(x - Float64(x * Float64(a * b))); elseif (y <= 7.2e+106) tmp = Float64(a * Float64(x * Float64(-z))); else tmp = Float64(x * Float64(t * Float64(-y))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (y <= -2.4e+216) tmp = x * (a * -b); elseif (y <= -1.05e+132) tmp = x * (1.0 - (y * t)); elseif (y <= 0.1) tmp = x - (x * (a * b)); elseif (y <= 7.2e+106) tmp = a * (x * -z); else tmp = x * (t * -y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, -2.4e+216], N[(x * N[(a * (-b)), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -1.05e+132], N[(x * N[(1.0 - N[(y * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 0.1], N[(x - N[(x * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 7.2e+106], N[(a * N[(x * (-z)), $MachinePrecision]), $MachinePrecision], N[(x * N[(t * (-y)), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -2.4 \cdot 10^{+216}:\\
\;\;\;\;x \cdot \left(a \cdot \left(-b\right)\right)\\
\mathbf{elif}\;y \leq -1.05 \cdot 10^{+132}:\\
\;\;\;\;x \cdot \left(1 - y \cdot t\right)\\
\mathbf{elif}\;y \leq 0.1:\\
\;\;\;\;x - x \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;y \leq 7.2 \cdot 10^{+106}:\\
\;\;\;\;a \cdot \left(x \cdot \left(-z\right)\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(t \cdot \left(-y\right)\right)\\
\end{array}
\end{array}
if y < -2.3999999999999999e216Initial program 100.0%
Taylor expanded in y around 0 49.5%
sub-neg49.5%
log1p-define49.5%
Simplified49.5%
Taylor expanded in z around 0 49.5%
+-commutative49.5%
associate-*r*49.5%
associate-*r*49.5%
distribute-lft-out49.5%
mul-1-neg49.5%
Simplified49.5%
Taylor expanded in a around 0 23.2%
mul-1-neg23.2%
unsub-neg23.2%
*-commutative23.2%
*-commutative23.2%
associate-*l*23.4%
+-commutative23.4%
Simplified23.4%
Taylor expanded in b around inf 31.5%
mul-1-neg31.5%
associate-*r*42.5%
*-commutative42.5%
distribute-rgt-neg-in42.5%
*-commutative42.5%
distribute-rgt-neg-in42.5%
Simplified42.5%
if -2.3999999999999999e216 < y < -1.04999999999999997e132Initial program 100.0%
fma-define100.0%
sub-neg100.0%
log1p-define100.0%
Simplified100.0%
Taylor expanded in a around 0 100.0%
Taylor expanded in t around inf 67.4%
neg-mul-167.4%
Simplified67.4%
Taylor expanded in y around 0 30.3%
mul-1-neg30.3%
unsub-neg30.3%
*-commutative30.3%
Simplified30.3%
if -1.04999999999999997e132 < y < 0.10000000000000001Initial program 95.5%
Taylor expanded in y around 0 73.1%
sub-neg73.1%
log1p-define78.3%
Simplified78.3%
Taylor expanded in z around 0 78.3%
+-commutative78.3%
associate-*r*78.3%
associate-*r*78.3%
distribute-lft-out78.3%
mul-1-neg78.3%
Simplified78.3%
Taylor expanded in a around 0 37.6%
mul-1-neg37.6%
unsub-neg37.6%
*-commutative37.6%
*-commutative37.6%
associate-*l*39.2%
+-commutative39.2%
Simplified39.2%
Taylor expanded in z around 0 36.9%
associate-*r*38.8%
*-commutative38.8%
Simplified38.8%
if 0.10000000000000001 < y < 7.2000000000000002e106Initial program 95.3%
Taylor expanded in y around 0 31.2%
sub-neg31.2%
log1p-define35.9%
Simplified35.9%
Taylor expanded in z around 0 35.9%
+-commutative35.9%
associate-*r*35.9%
associate-*r*35.9%
distribute-lft-out35.9%
mul-1-neg35.9%
Simplified35.9%
Taylor expanded in a around 0 3.5%
mul-1-neg3.5%
unsub-neg3.5%
*-commutative3.5%
*-commutative3.5%
associate-*l*3.9%
+-commutative3.9%
Simplified3.9%
Taylor expanded in z around inf 58.3%
if 7.2000000000000002e106 < y Initial program 97.4%
fma-define97.4%
sub-neg97.4%
log1p-define100.0%
Simplified100.0%
Taylor expanded in a around 0 97.4%
Taylor expanded in t around inf 67.1%
neg-mul-167.1%
Simplified67.1%
Taylor expanded in y around 0 33.9%
mul-1-neg33.9%
unsub-neg33.9%
*-commutative33.9%
Simplified33.9%
Taylor expanded in y around inf 33.6%
mul-1-neg33.6%
*-commutative33.6%
distribute-rgt-neg-in33.6%
associate-*r*41.2%
Simplified41.2%
Final simplification40.4%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* x (* t (- y)))) (t_2 (* x (* a (- b)))))
(if (<= y -1.32e+216)
t_2
(if (<= y -3.5e+128)
t_1
(if (<= y -1.8e-36) t_2 (if (<= y 9.8e-23) x t_1))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * (t * -y);
double t_2 = x * (a * -b);
double tmp;
if (y <= -1.32e+216) {
tmp = t_2;
} else if (y <= -3.5e+128) {
tmp = t_1;
} else if (y <= -1.8e-36) {
tmp = t_2;
} else if (y <= 9.8e-23) {
tmp = x;
} 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) :: t_2
real(8) :: tmp
t_1 = x * (t * -y)
t_2 = x * (a * -b)
if (y <= (-1.32d+216)) then
tmp = t_2
else if (y <= (-3.5d+128)) then
tmp = t_1
else if (y <= (-1.8d-36)) then
tmp = t_2
else if (y <= 9.8d-23) then
tmp = 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 b) {
double t_1 = x * (t * -y);
double t_2 = x * (a * -b);
double tmp;
if (y <= -1.32e+216) {
tmp = t_2;
} else if (y <= -3.5e+128) {
tmp = t_1;
} else if (y <= -1.8e-36) {
tmp = t_2;
} else if (y <= 9.8e-23) {
tmp = x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x * (t * -y) t_2 = x * (a * -b) tmp = 0 if y <= -1.32e+216: tmp = t_2 elif y <= -3.5e+128: tmp = t_1 elif y <= -1.8e-36: tmp = t_2 elif y <= 9.8e-23: tmp = x else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x * Float64(t * Float64(-y))) t_2 = Float64(x * Float64(a * Float64(-b))) tmp = 0.0 if (y <= -1.32e+216) tmp = t_2; elseif (y <= -3.5e+128) tmp = t_1; elseif (y <= -1.8e-36) tmp = t_2; elseif (y <= 9.8e-23) tmp = x; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x * (t * -y); t_2 = x * (a * -b); tmp = 0.0; if (y <= -1.32e+216) tmp = t_2; elseif (y <= -3.5e+128) tmp = t_1; elseif (y <= -1.8e-36) tmp = t_2; elseif (y <= 9.8e-23) tmp = x; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[(t * (-y)), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(a * (-b)), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.32e+216], t$95$2, If[LessEqual[y, -3.5e+128], t$95$1, If[LessEqual[y, -1.8e-36], t$95$2, If[LessEqual[y, 9.8e-23], x, t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(t \cdot \left(-y\right)\right)\\
t_2 := x \cdot \left(a \cdot \left(-b\right)\right)\\
\mathbf{if}\;y \leq -1.32 \cdot 10^{+216}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -3.5 \cdot 10^{+128}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -1.8 \cdot 10^{-36}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq 9.8 \cdot 10^{-23}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -1.3199999999999999e216 or -3.49999999999999969e128 < y < -1.80000000000000016e-36Initial program 95.4%
Taylor expanded in y around 0 45.3%
sub-neg45.3%
log1p-define51.4%
Simplified51.4%
Taylor expanded in z around 0 51.4%
+-commutative51.4%
associate-*r*51.4%
associate-*r*51.4%
distribute-lft-out51.4%
mul-1-neg51.4%
Simplified51.4%
Taylor expanded in a around 0 21.4%
mul-1-neg21.4%
unsub-neg21.4%
*-commutative21.4%
*-commutative21.4%
associate-*l*21.5%
+-commutative21.5%
Simplified21.5%
Taylor expanded in b around inf 24.6%
mul-1-neg24.6%
associate-*r*30.4%
*-commutative30.4%
distribute-rgt-neg-in30.4%
*-commutative30.4%
distribute-rgt-neg-in30.4%
Simplified30.4%
if -1.3199999999999999e216 < y < -3.49999999999999969e128 or 9.7999999999999996e-23 < y Initial program 97.6%
fma-define97.6%
sub-neg97.6%
log1p-define100.0%
Simplified100.0%
Taylor expanded in a around 0 97.6%
Taylor expanded in t around inf 64.4%
neg-mul-164.4%
Simplified64.4%
Taylor expanded in y around 0 27.5%
mul-1-neg27.5%
unsub-neg27.5%
*-commutative27.5%
Simplified27.5%
Taylor expanded in y around inf 21.7%
mul-1-neg21.7%
*-commutative21.7%
distribute-rgt-neg-in21.7%
associate-*r*31.8%
Simplified31.8%
if -1.80000000000000016e-36 < y < 9.7999999999999996e-23Initial program 96.4%
Taylor expanded in b around inf 84.0%
mul-1-neg84.0%
distribute-rgt-neg-out84.0%
Simplified84.0%
Taylor expanded in a around 0 38.2%
Final simplification34.2%
(FPCore (x y z t a b)
:precision binary64
(if (<= a -7.5e+24)
(- x (* b (* a (+ x (* z (/ x b))))))
(if (<= a 5500000.0)
(* x (- 1.0 (* y t)))
(if (<= a 2.6e+86) (* a (* x (- z))) (- x (* x (* a b)))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= -7.5e+24) {
tmp = x - (b * (a * (x + (z * (x / b)))));
} else if (a <= 5500000.0) {
tmp = x * (1.0 - (y * t));
} else if (a <= 2.6e+86) {
tmp = a * (x * -z);
} else {
tmp = x - (x * (a * 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 (a <= (-7.5d+24)) then
tmp = x - (b * (a * (x + (z * (x / b)))))
else if (a <= 5500000.0d0) then
tmp = x * (1.0d0 - (y * t))
else if (a <= 2.6d+86) then
tmp = a * (x * -z)
else
tmp = x - (x * (a * 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 (a <= -7.5e+24) {
tmp = x - (b * (a * (x + (z * (x / b)))));
} else if (a <= 5500000.0) {
tmp = x * (1.0 - (y * t));
} else if (a <= 2.6e+86) {
tmp = a * (x * -z);
} else {
tmp = x - (x * (a * b));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if a <= -7.5e+24: tmp = x - (b * (a * (x + (z * (x / b))))) elif a <= 5500000.0: tmp = x * (1.0 - (y * t)) elif a <= 2.6e+86: tmp = a * (x * -z) else: tmp = x - (x * (a * b)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (a <= -7.5e+24) tmp = Float64(x - Float64(b * Float64(a * Float64(x + Float64(z * Float64(x / b)))))); elseif (a <= 5500000.0) tmp = Float64(x * Float64(1.0 - Float64(y * t))); elseif (a <= 2.6e+86) tmp = Float64(a * Float64(x * Float64(-z))); else tmp = Float64(x - Float64(x * Float64(a * b))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (a <= -7.5e+24) tmp = x - (b * (a * (x + (z * (x / b))))); elseif (a <= 5500000.0) tmp = x * (1.0 - (y * t)); elseif (a <= 2.6e+86) tmp = a * (x * -z); else tmp = x - (x * (a * b)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[a, -7.5e+24], N[(x - N[(b * N[(a * N[(x + N[(z * N[(x / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 5500000.0], N[(x * N[(1.0 - N[(y * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.6e+86], N[(a * N[(x * (-z)), $MachinePrecision]), $MachinePrecision], N[(x - N[(x * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -7.5 \cdot 10^{+24}:\\
\;\;\;\;x - b \cdot \left(a \cdot \left(x + z \cdot \frac{x}{b}\right)\right)\\
\mathbf{elif}\;a \leq 5500000:\\
\;\;\;\;x \cdot \left(1 - y \cdot t\right)\\
\mathbf{elif}\;a \leq 2.6 \cdot 10^{+86}:\\
\;\;\;\;a \cdot \left(x \cdot \left(-z\right)\right)\\
\mathbf{else}:\\
\;\;\;\;x - x \cdot \left(a \cdot b\right)\\
\end{array}
\end{array}
if a < -7.50000000000000014e24Initial program 93.7%
Taylor expanded in y around 0 74.8%
sub-neg74.8%
log1p-define84.2%
Simplified84.2%
Taylor expanded in z around 0 84.2%
+-commutative84.2%
associate-*r*84.2%
associate-*r*84.2%
distribute-lft-out84.2%
mul-1-neg84.2%
Simplified84.2%
Taylor expanded in a around 0 25.2%
mul-1-neg25.2%
unsub-neg25.2%
*-commutative25.2%
*-commutative25.2%
associate-*l*29.7%
+-commutative29.7%
Simplified29.7%
Taylor expanded in b around inf 31.0%
+-commutative31.0%
associate-/l*31.1%
distribute-lft-out34.3%
*-commutative34.3%
associate-/l*34.3%
Simplified34.3%
if -7.50000000000000014e24 < a < 5.5e6Initial program 100.0%
fma-define100.0%
sub-neg100.0%
log1p-define100.0%
Simplified100.0%
Taylor expanded in a around 0 90.5%
Taylor expanded in t around inf 73.0%
neg-mul-173.0%
Simplified73.0%
Taylor expanded in y around 0 44.3%
mul-1-neg44.3%
unsub-neg44.3%
*-commutative44.3%
Simplified44.3%
if 5.5e6 < a < 2.5999999999999998e86Initial program 100.0%
Taylor expanded in y around 0 72.2%
sub-neg72.2%
log1p-define72.2%
Simplified72.2%
Taylor expanded in z around 0 72.2%
+-commutative72.2%
associate-*r*72.2%
associate-*r*72.2%
distribute-lft-out72.2%
mul-1-neg72.2%
Simplified72.2%
Taylor expanded in a around 0 5.6%
mul-1-neg5.6%
unsub-neg5.6%
*-commutative5.6%
*-commutative5.6%
associate-*l*2.9%
+-commutative2.9%
Simplified2.9%
Taylor expanded in z around inf 33.2%
if 2.5999999999999998e86 < a Initial program 87.8%
Taylor expanded in y around 0 63.5%
sub-neg63.5%
log1p-define77.9%
Simplified77.9%
Taylor expanded in z around 0 77.9%
+-commutative77.9%
associate-*r*77.9%
associate-*r*77.9%
distribute-lft-out77.9%
mul-1-neg77.9%
Simplified77.9%
Taylor expanded in a around 0 27.3%
mul-1-neg27.3%
unsub-neg27.3%
*-commutative27.3%
*-commutative27.3%
associate-*l*27.2%
+-commutative27.2%
Simplified27.2%
Taylor expanded in z around 0 27.4%
associate-*r*36.6%
*-commutative36.6%
Simplified36.6%
Final simplification40.0%
(FPCore (x y z t a b)
:precision binary64
(if (<= a -6.8e+23)
(- x (* (+ z b) (* x a)))
(if (<= a 116000000.0)
(* x (- 1.0 (* y t)))
(if (<= a 1.75e+86) (* a (* x (- z))) (- x (* x (* a b)))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= -6.8e+23) {
tmp = x - ((z + b) * (x * a));
} else if (a <= 116000000.0) {
tmp = x * (1.0 - (y * t));
} else if (a <= 1.75e+86) {
tmp = a * (x * -z);
} else {
tmp = x - (x * (a * 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 (a <= (-6.8d+23)) then
tmp = x - ((z + b) * (x * a))
else if (a <= 116000000.0d0) then
tmp = x * (1.0d0 - (y * t))
else if (a <= 1.75d+86) then
tmp = a * (x * -z)
else
tmp = x - (x * (a * 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 (a <= -6.8e+23) {
tmp = x - ((z + b) * (x * a));
} else if (a <= 116000000.0) {
tmp = x * (1.0 - (y * t));
} else if (a <= 1.75e+86) {
tmp = a * (x * -z);
} else {
tmp = x - (x * (a * b));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if a <= -6.8e+23: tmp = x - ((z + b) * (x * a)) elif a <= 116000000.0: tmp = x * (1.0 - (y * t)) elif a <= 1.75e+86: tmp = a * (x * -z) else: tmp = x - (x * (a * b)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (a <= -6.8e+23) tmp = Float64(x - Float64(Float64(z + b) * Float64(x * a))); elseif (a <= 116000000.0) tmp = Float64(x * Float64(1.0 - Float64(y * t))); elseif (a <= 1.75e+86) tmp = Float64(a * Float64(x * Float64(-z))); else tmp = Float64(x - Float64(x * Float64(a * b))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (a <= -6.8e+23) tmp = x - ((z + b) * (x * a)); elseif (a <= 116000000.0) tmp = x * (1.0 - (y * t)); elseif (a <= 1.75e+86) tmp = a * (x * -z); else tmp = x - (x * (a * b)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[a, -6.8e+23], N[(x - N[(N[(z + b), $MachinePrecision] * N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 116000000.0], N[(x * N[(1.0 - N[(y * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.75e+86], N[(a * N[(x * (-z)), $MachinePrecision]), $MachinePrecision], N[(x - N[(x * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -6.8 \cdot 10^{+23}:\\
\;\;\;\;x - \left(z + b\right) \cdot \left(x \cdot a\right)\\
\mathbf{elif}\;a \leq 116000000:\\
\;\;\;\;x \cdot \left(1 - y \cdot t\right)\\
\mathbf{elif}\;a \leq 1.75 \cdot 10^{+86}:\\
\;\;\;\;a \cdot \left(x \cdot \left(-z\right)\right)\\
\mathbf{else}:\\
\;\;\;\;x - x \cdot \left(a \cdot b\right)\\
\end{array}
\end{array}
if a < -6.79999999999999983e23Initial program 93.7%
Taylor expanded in y around 0 74.8%
sub-neg74.8%
log1p-define84.2%
Simplified84.2%
Taylor expanded in z around 0 84.2%
+-commutative84.2%
associate-*r*84.2%
associate-*r*84.2%
distribute-lft-out84.2%
mul-1-neg84.2%
Simplified84.2%
Taylor expanded in a around 0 25.2%
mul-1-neg25.2%
unsub-neg25.2%
*-commutative25.2%
*-commutative25.2%
associate-*l*29.7%
+-commutative29.7%
Simplified29.7%
if -6.79999999999999983e23 < a < 1.16e8Initial program 100.0%
fma-define100.0%
sub-neg100.0%
log1p-define100.0%
Simplified100.0%
Taylor expanded in a around 0 90.5%
Taylor expanded in t around inf 73.0%
neg-mul-173.0%
Simplified73.0%
Taylor expanded in y around 0 44.3%
mul-1-neg44.3%
unsub-neg44.3%
*-commutative44.3%
Simplified44.3%
if 1.16e8 < a < 1.75000000000000009e86Initial program 100.0%
Taylor expanded in y around 0 72.2%
sub-neg72.2%
log1p-define72.2%
Simplified72.2%
Taylor expanded in z around 0 72.2%
+-commutative72.2%
associate-*r*72.2%
associate-*r*72.2%
distribute-lft-out72.2%
mul-1-neg72.2%
Simplified72.2%
Taylor expanded in a around 0 5.6%
mul-1-neg5.6%
unsub-neg5.6%
*-commutative5.6%
*-commutative5.6%
associate-*l*2.9%
+-commutative2.9%
Simplified2.9%
Taylor expanded in z around inf 33.2%
if 1.75000000000000009e86 < a Initial program 87.8%
Taylor expanded in y around 0 63.5%
sub-neg63.5%
log1p-define77.9%
Simplified77.9%
Taylor expanded in z around 0 77.9%
+-commutative77.9%
associate-*r*77.9%
associate-*r*77.9%
distribute-lft-out77.9%
mul-1-neg77.9%
Simplified77.9%
Taylor expanded in a around 0 27.3%
mul-1-neg27.3%
unsub-neg27.3%
*-commutative27.3%
*-commutative27.3%
associate-*l*27.2%
+-commutative27.2%
Simplified27.2%
Taylor expanded in z around 0 27.4%
associate-*r*36.6%
*-commutative36.6%
Simplified36.6%
Final simplification38.9%
(FPCore (x y z t a b) :precision binary64 (if (or (<= y -8.2e-38) (not (<= y 4.5e-53))) (* x (* a (- b))) x))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -8.2e-38) || !(y <= 4.5e-53)) {
tmp = x * (a * -b);
} 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 ((y <= (-8.2d-38)) .or. (.not. (y <= 4.5d-53))) then
tmp = x * (a * -b)
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 ((y <= -8.2e-38) || !(y <= 4.5e-53)) {
tmp = x * (a * -b);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (y <= -8.2e-38) or not (y <= 4.5e-53): tmp = x * (a * -b) else: tmp = x return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((y <= -8.2e-38) || !(y <= 4.5e-53)) tmp = Float64(x * Float64(a * Float64(-b))); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((y <= -8.2e-38) || ~((y <= 4.5e-53))) tmp = x * (a * -b); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -8.2e-38], N[Not[LessEqual[y, 4.5e-53]], $MachinePrecision]], N[(x * N[(a * (-b)), $MachinePrecision]), $MachinePrecision], x]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -8.2 \cdot 10^{-38} \lor \neg \left(y \leq 4.5 \cdot 10^{-53}\right):\\
\;\;\;\;x \cdot \left(a \cdot \left(-b\right)\right)\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if y < -8.1999999999999996e-38 or 4.49999999999999985e-53 < y Initial program 96.8%
Taylor expanded in y around 0 40.0%
sub-neg40.0%
log1p-define45.0%
Simplified45.0%
Taylor expanded in z around 0 45.0%
+-commutative45.0%
associate-*r*45.0%
associate-*r*45.0%
distribute-lft-out45.0%
mul-1-neg45.0%
Simplified45.0%
Taylor expanded in a around 0 17.0%
mul-1-neg17.0%
unsub-neg17.0%
*-commutative17.0%
*-commutative17.0%
associate-*l*17.1%
+-commutative17.1%
Simplified17.1%
Taylor expanded in b around inf 22.8%
mul-1-neg22.8%
associate-*r*24.0%
*-commutative24.0%
distribute-rgt-neg-in24.0%
*-commutative24.0%
distribute-rgt-neg-in24.0%
Simplified24.0%
if -8.1999999999999996e-38 < y < 4.49999999999999985e-53Initial program 96.1%
Taylor expanded in b around inf 82.9%
mul-1-neg82.9%
distribute-rgt-neg-out82.9%
Simplified82.9%
Taylor expanded in a around 0 39.5%
Final simplification30.1%
(FPCore (x y z t a b) :precision binary64 x)
double code(double x, double y, double z, double t, double a, double b) {
return x;
}
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
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x;
}
def code(x, y, z, t, a, b): return x
function code(x, y, z, t, a, b) return x end
function tmp = code(x, y, z, t, a, b) tmp = x; end
code[x_, y_, z_, t_, a_, b_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 96.5%
Taylor expanded in b around inf 56.9%
mul-1-neg56.9%
distribute-rgt-neg-out56.9%
Simplified56.9%
Taylor expanded in a around 0 18.4%
herbie shell --seed 2024096
(FPCore (x y z t a b)
:name "Numeric.SpecFunctions:incompleteBetaApprox from math-functions-0.1.5.2, B"
:precision binary64
(* x (exp (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b))))))