
(FPCore (i n) :precision binary64 (* 100.0 (/ (- (pow (+ 1.0 (/ i n)) n) 1.0) (/ i n))))
double code(double i, double n) {
return 100.0 * ((pow((1.0 + (i / n)), n) - 1.0) / (i / n));
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
code = 100.0d0 * ((((1.0d0 + (i / n)) ** n) - 1.0d0) / (i / n))
end function
public static double code(double i, double n) {
return 100.0 * ((Math.pow((1.0 + (i / n)), n) - 1.0) / (i / n));
}
def code(i, n): return 100.0 * ((math.pow((1.0 + (i / n)), n) - 1.0) / (i / n))
function code(i, n) return Float64(100.0 * Float64(Float64((Float64(1.0 + Float64(i / n)) ^ n) - 1.0) / Float64(i / n))) end
function tmp = code(i, n) tmp = 100.0 * ((((1.0 + (i / n)) ^ n) - 1.0) / (i / n)); end
code[i_, n_] := N[(100.0 * N[(N[(N[Power[N[(1.0 + N[(i / n), $MachinePrecision]), $MachinePrecision], n], $MachinePrecision] - 1.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
100 \cdot \frac{{\left(1 + \frac{i}{n}\right)}^{n} - 1}{\frac{i}{n}}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 19 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (i n) :precision binary64 (* 100.0 (/ (- (pow (+ 1.0 (/ i n)) n) 1.0) (/ i n))))
double code(double i, double n) {
return 100.0 * ((pow((1.0 + (i / n)), n) - 1.0) / (i / n));
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
code = 100.0d0 * ((((1.0d0 + (i / n)) ** n) - 1.0d0) / (i / n))
end function
public static double code(double i, double n) {
return 100.0 * ((Math.pow((1.0 + (i / n)), n) - 1.0) / (i / n));
}
def code(i, n): return 100.0 * ((math.pow((1.0 + (i / n)), n) - 1.0) / (i / n))
function code(i, n) return Float64(100.0 * Float64(Float64((Float64(1.0 + Float64(i / n)) ^ n) - 1.0) / Float64(i / n))) end
function tmp = code(i, n) tmp = 100.0 * ((((1.0 + (i / n)) ^ n) - 1.0) / (i / n)); end
code[i_, n_] := N[(100.0 * N[(N[(N[Power[N[(1.0 + N[(i / n), $MachinePrecision]), $MachinePrecision], n], $MachinePrecision] - 1.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
100 \cdot \frac{{\left(1 + \frac{i}{n}\right)}^{n} - 1}{\frac{i}{n}}
\end{array}
(FPCore (i n)
:precision binary64
(let* ((t_0 (pow (+ 1.0 (/ i n)) n)) (t_1 (/ (+ t_0 -1.0) (/ i n))))
(if (<= t_1 -5000000000000.0)
(* t_1 100.0)
(if (<= t_1 1e-313)
(* (/ (expm1 (* n (log1p (/ i n)))) i) (* n 100.0))
(if (<= t_1 INFINITY)
(/ (+ (* t_0 100.0) -100.0) (/ i n))
(/ n (+ 0.01 (* i -0.005))))))))
double code(double i, double n) {
double t_0 = pow((1.0 + (i / n)), n);
double t_1 = (t_0 + -1.0) / (i / n);
double tmp;
if (t_1 <= -5000000000000.0) {
tmp = t_1 * 100.0;
} else if (t_1 <= 1e-313) {
tmp = (expm1((n * log1p((i / n)))) / i) * (n * 100.0);
} else if (t_1 <= ((double) INFINITY)) {
tmp = ((t_0 * 100.0) + -100.0) / (i / n);
} else {
tmp = n / (0.01 + (i * -0.005));
}
return tmp;
}
public static double code(double i, double n) {
double t_0 = Math.pow((1.0 + (i / n)), n);
double t_1 = (t_0 + -1.0) / (i / n);
double tmp;
if (t_1 <= -5000000000000.0) {
tmp = t_1 * 100.0;
} else if (t_1 <= 1e-313) {
tmp = (Math.expm1((n * Math.log1p((i / n)))) / i) * (n * 100.0);
} else if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = ((t_0 * 100.0) + -100.0) / (i / n);
} else {
tmp = n / (0.01 + (i * -0.005));
}
return tmp;
}
def code(i, n): t_0 = math.pow((1.0 + (i / n)), n) t_1 = (t_0 + -1.0) / (i / n) tmp = 0 if t_1 <= -5000000000000.0: tmp = t_1 * 100.0 elif t_1 <= 1e-313: tmp = (math.expm1((n * math.log1p((i / n)))) / i) * (n * 100.0) elif t_1 <= math.inf: tmp = ((t_0 * 100.0) + -100.0) / (i / n) else: tmp = n / (0.01 + (i * -0.005)) return tmp
function code(i, n) t_0 = Float64(1.0 + Float64(i / n)) ^ n t_1 = Float64(Float64(t_0 + -1.0) / Float64(i / n)) tmp = 0.0 if (t_1 <= -5000000000000.0) tmp = Float64(t_1 * 100.0); elseif (t_1 <= 1e-313) tmp = Float64(Float64(expm1(Float64(n * log1p(Float64(i / n)))) / i) * Float64(n * 100.0)); elseif (t_1 <= Inf) tmp = Float64(Float64(Float64(t_0 * 100.0) + -100.0) / Float64(i / n)); else tmp = Float64(n / Float64(0.01 + Float64(i * -0.005))); end return tmp end
code[i_, n_] := Block[{t$95$0 = N[Power[N[(1.0 + N[(i / n), $MachinePrecision]), $MachinePrecision], n], $MachinePrecision]}, Block[{t$95$1 = N[(N[(t$95$0 + -1.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -5000000000000.0], N[(t$95$1 * 100.0), $MachinePrecision], If[LessEqual[t$95$1, 1e-313], N[(N[(N[(Exp[N[(n * N[Log[1 + N[(i / n), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision] / i), $MachinePrecision] * N[(n * 100.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[(N[(t$95$0 * 100.0), $MachinePrecision] + -100.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision], N[(n / N[(0.01 + N[(i * -0.005), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {\left(1 + \frac{i}{n}\right)}^{n}\\
t_1 := \frac{t\_0 + -1}{\frac{i}{n}}\\
\mathbf{if}\;t\_1 \leq -5000000000000:\\
\;\;\;\;t\_1 \cdot 100\\
\mathbf{elif}\;t\_1 \leq 10^{-313}:\\
\;\;\;\;\frac{\mathsf{expm1}\left(n \cdot \mathsf{log1p}\left(\frac{i}{n}\right)\right)}{i} \cdot \left(n \cdot 100\right)\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\frac{t\_0 \cdot 100 + -100}{\frac{i}{n}}\\
\mathbf{else}:\\
\;\;\;\;\frac{n}{0.01 + i \cdot -0.005}\\
\end{array}
\end{array}
if (/.f64 (-.f64 (pow.f64 (+.f64 #s(literal 1 binary64) (/.f64 i n)) n) #s(literal 1 binary64)) (/.f64 i n)) < -5e12Initial program 100.0%
if -5e12 < (/.f64 (-.f64 (pow.f64 (+.f64 #s(literal 1 binary64) (/.f64 i n)) n) #s(literal 1 binary64)) (/.f64 i n)) < 1.00000000001e-313Initial program 29.6%
associate-*r/29.6%
sub-neg29.6%
distribute-rgt-in29.6%
metadata-eval29.6%
metadata-eval29.6%
Simplified29.6%
metadata-eval29.6%
metadata-eval29.6%
distribute-rgt-in29.6%
sub-neg29.6%
associate-*r/29.6%
*-commutative29.6%
associate-/r/29.2%
associate-*l*29.2%
add-exp-log29.2%
expm1-define29.2%
log-pow36.5%
log1p-define94.8%
Applied egg-rr94.8%
if 1.00000000001e-313 < (/.f64 (-.f64 (pow.f64 (+.f64 #s(literal 1 binary64) (/.f64 i n)) n) #s(literal 1 binary64)) (/.f64 i n)) < +inf.0Initial program 99.8%
associate-*r/99.9%
sub-neg99.9%
distribute-rgt-in99.9%
metadata-eval99.9%
metadata-eval99.9%
Simplified99.9%
if +inf.0 < (/.f64 (-.f64 (pow.f64 (+.f64 #s(literal 1 binary64) (/.f64 i n)) n) #s(literal 1 binary64)) (/.f64 i n)) Initial program 0.0%
associate-/r/1.8%
associate-*r*1.8%
*-commutative1.8%
associate-*r/1.8%
sub-neg1.8%
distribute-lft-in1.8%
metadata-eval1.8%
metadata-eval1.8%
metadata-eval1.8%
fma-define1.8%
metadata-eval1.8%
Simplified1.8%
Taylor expanded in n around inf 13.4%
sub-neg13.4%
metadata-eval13.4%
metadata-eval13.4%
distribute-lft-in13.4%
metadata-eval13.4%
sub-neg13.4%
expm1-define72.8%
Simplified72.8%
clear-num73.0%
un-div-inv73.0%
*-un-lft-identity73.0%
times-frac73.0%
metadata-eval73.0%
Applied egg-rr73.0%
associate-*r/72.8%
Simplified72.8%
Taylor expanded in i around 0 98.2%
*-commutative98.2%
Simplified98.2%
Final simplification96.1%
(FPCore (i n)
:precision binary64
(let* ((t_0 (pow (+ 1.0 (/ i n)) n)) (t_1 (/ (+ t_0 -1.0) (/ i n))))
(if (<= t_1 (- INFINITY))
(* t_1 100.0)
(if (<= t_1 1e-313)
(* (expm1 (* n (log1p (/ i n)))) (* 100.0 (/ n i)))
(if (<= t_1 INFINITY)
(/ (+ (* t_0 100.0) -100.0) (/ i n))
(/ n (+ 0.01 (* i -0.005))))))))
double code(double i, double n) {
double t_0 = pow((1.0 + (i / n)), n);
double t_1 = (t_0 + -1.0) / (i / n);
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = t_1 * 100.0;
} else if (t_1 <= 1e-313) {
tmp = expm1((n * log1p((i / n)))) * (100.0 * (n / i));
} else if (t_1 <= ((double) INFINITY)) {
tmp = ((t_0 * 100.0) + -100.0) / (i / n);
} else {
tmp = n / (0.01 + (i * -0.005));
}
return tmp;
}
public static double code(double i, double n) {
double t_0 = Math.pow((1.0 + (i / n)), n);
double t_1 = (t_0 + -1.0) / (i / n);
double tmp;
if (t_1 <= -Double.POSITIVE_INFINITY) {
tmp = t_1 * 100.0;
} else if (t_1 <= 1e-313) {
tmp = Math.expm1((n * Math.log1p((i / n)))) * (100.0 * (n / i));
} else if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = ((t_0 * 100.0) + -100.0) / (i / n);
} else {
tmp = n / (0.01 + (i * -0.005));
}
return tmp;
}
def code(i, n): t_0 = math.pow((1.0 + (i / n)), n) t_1 = (t_0 + -1.0) / (i / n) tmp = 0 if t_1 <= -math.inf: tmp = t_1 * 100.0 elif t_1 <= 1e-313: tmp = math.expm1((n * math.log1p((i / n)))) * (100.0 * (n / i)) elif t_1 <= math.inf: tmp = ((t_0 * 100.0) + -100.0) / (i / n) else: tmp = n / (0.01 + (i * -0.005)) return tmp
function code(i, n) t_0 = Float64(1.0 + Float64(i / n)) ^ n t_1 = Float64(Float64(t_0 + -1.0) / Float64(i / n)) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = Float64(t_1 * 100.0); elseif (t_1 <= 1e-313) tmp = Float64(expm1(Float64(n * log1p(Float64(i / n)))) * Float64(100.0 * Float64(n / i))); elseif (t_1 <= Inf) tmp = Float64(Float64(Float64(t_0 * 100.0) + -100.0) / Float64(i / n)); else tmp = Float64(n / Float64(0.01 + Float64(i * -0.005))); end return tmp end
code[i_, n_] := Block[{t$95$0 = N[Power[N[(1.0 + N[(i / n), $MachinePrecision]), $MachinePrecision], n], $MachinePrecision]}, Block[{t$95$1 = N[(N[(t$95$0 + -1.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], N[(t$95$1 * 100.0), $MachinePrecision], If[LessEqual[t$95$1, 1e-313], N[(N[(Exp[N[(n * N[Log[1 + N[(i / n), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision] * N[(100.0 * N[(n / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[(N[(t$95$0 * 100.0), $MachinePrecision] + -100.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision], N[(n / N[(0.01 + N[(i * -0.005), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {\left(1 + \frac{i}{n}\right)}^{n}\\
t_1 := \frac{t\_0 + -1}{\frac{i}{n}}\\
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;t\_1 \cdot 100\\
\mathbf{elif}\;t\_1 \leq 10^{-313}:\\
\;\;\;\;\mathsf{expm1}\left(n \cdot \mathsf{log1p}\left(\frac{i}{n}\right)\right) \cdot \left(100 \cdot \frac{n}{i}\right)\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\frac{t\_0 \cdot 100 + -100}{\frac{i}{n}}\\
\mathbf{else}:\\
\;\;\;\;\frac{n}{0.01 + i \cdot -0.005}\\
\end{array}
\end{array}
if (/.f64 (-.f64 (pow.f64 (+.f64 #s(literal 1 binary64) (/.f64 i n)) n) #s(literal 1 binary64)) (/.f64 i n)) < -inf.0Initial program 100.0%
if -inf.0 < (/.f64 (-.f64 (pow.f64 (+.f64 #s(literal 1 binary64) (/.f64 i n)) n) #s(literal 1 binary64)) (/.f64 i n)) < 1.00000000001e-313Initial program 30.0%
associate-*r/30.0%
sub-neg30.0%
distribute-rgt-in30.0%
metadata-eval30.0%
metadata-eval30.0%
Simplified30.0%
metadata-eval30.0%
metadata-eval30.0%
distribute-rgt-in30.0%
sub-neg30.0%
associate-*r/30.0%
*-commutative30.0%
div-inv29.9%
clear-num29.6%
associate-*l*29.6%
add-exp-log29.6%
expm1-define29.6%
log-pow36.9%
log1p-define94.1%
Applied egg-rr94.1%
if 1.00000000001e-313 < (/.f64 (-.f64 (pow.f64 (+.f64 #s(literal 1 binary64) (/.f64 i n)) n) #s(literal 1 binary64)) (/.f64 i n)) < +inf.0Initial program 99.8%
associate-*r/99.9%
sub-neg99.9%
distribute-rgt-in99.9%
metadata-eval99.9%
metadata-eval99.9%
Simplified99.9%
if +inf.0 < (/.f64 (-.f64 (pow.f64 (+.f64 #s(literal 1 binary64) (/.f64 i n)) n) #s(literal 1 binary64)) (/.f64 i n)) Initial program 0.0%
associate-/r/1.8%
associate-*r*1.8%
*-commutative1.8%
associate-*r/1.8%
sub-neg1.8%
distribute-lft-in1.8%
metadata-eval1.8%
metadata-eval1.8%
metadata-eval1.8%
fma-define1.8%
metadata-eval1.8%
Simplified1.8%
Taylor expanded in n around inf 13.4%
sub-neg13.4%
metadata-eval13.4%
metadata-eval13.4%
distribute-lft-in13.4%
metadata-eval13.4%
sub-neg13.4%
expm1-define72.8%
Simplified72.8%
clear-num73.0%
un-div-inv73.0%
*-un-lft-identity73.0%
times-frac73.0%
metadata-eval73.0%
Applied egg-rr73.0%
associate-*r/72.8%
Simplified72.8%
Taylor expanded in i around 0 98.2%
*-commutative98.2%
Simplified98.2%
Final simplification95.6%
(FPCore (i n)
:precision binary64
(let* ((t_0 (pow (+ 1.0 (/ i n)) n)) (t_1 (/ (+ t_0 -1.0) (/ i n))))
(if (<= t_1 (- INFINITY))
(* t_1 100.0)
(if (<= t_1 1e-313)
(* 100.0 (* (expm1 (* n (log1p (/ i n)))) (/ n i)))
(if (<= t_1 INFINITY)
(/ (+ (* t_0 100.0) -100.0) (/ i n))
(/ n (+ 0.01 (* i -0.005))))))))
double code(double i, double n) {
double t_0 = pow((1.0 + (i / n)), n);
double t_1 = (t_0 + -1.0) / (i / n);
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = t_1 * 100.0;
} else if (t_1 <= 1e-313) {
tmp = 100.0 * (expm1((n * log1p((i / n)))) * (n / i));
} else if (t_1 <= ((double) INFINITY)) {
tmp = ((t_0 * 100.0) + -100.0) / (i / n);
} else {
tmp = n / (0.01 + (i * -0.005));
}
return tmp;
}
public static double code(double i, double n) {
double t_0 = Math.pow((1.0 + (i / n)), n);
double t_1 = (t_0 + -1.0) / (i / n);
double tmp;
if (t_1 <= -Double.POSITIVE_INFINITY) {
tmp = t_1 * 100.0;
} else if (t_1 <= 1e-313) {
tmp = 100.0 * (Math.expm1((n * Math.log1p((i / n)))) * (n / i));
} else if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = ((t_0 * 100.0) + -100.0) / (i / n);
} else {
tmp = n / (0.01 + (i * -0.005));
}
return tmp;
}
def code(i, n): t_0 = math.pow((1.0 + (i / n)), n) t_1 = (t_0 + -1.0) / (i / n) tmp = 0 if t_1 <= -math.inf: tmp = t_1 * 100.0 elif t_1 <= 1e-313: tmp = 100.0 * (math.expm1((n * math.log1p((i / n)))) * (n / i)) elif t_1 <= math.inf: tmp = ((t_0 * 100.0) + -100.0) / (i / n) else: tmp = n / (0.01 + (i * -0.005)) return tmp
function code(i, n) t_0 = Float64(1.0 + Float64(i / n)) ^ n t_1 = Float64(Float64(t_0 + -1.0) / Float64(i / n)) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = Float64(t_1 * 100.0); elseif (t_1 <= 1e-313) tmp = Float64(100.0 * Float64(expm1(Float64(n * log1p(Float64(i / n)))) * Float64(n / i))); elseif (t_1 <= Inf) tmp = Float64(Float64(Float64(t_0 * 100.0) + -100.0) / Float64(i / n)); else tmp = Float64(n / Float64(0.01 + Float64(i * -0.005))); end return tmp end
code[i_, n_] := Block[{t$95$0 = N[Power[N[(1.0 + N[(i / n), $MachinePrecision]), $MachinePrecision], n], $MachinePrecision]}, Block[{t$95$1 = N[(N[(t$95$0 + -1.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], N[(t$95$1 * 100.0), $MachinePrecision], If[LessEqual[t$95$1, 1e-313], N[(100.0 * N[(N[(Exp[N[(n * N[Log[1 + N[(i / n), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision] * N[(n / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[(N[(t$95$0 * 100.0), $MachinePrecision] + -100.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision], N[(n / N[(0.01 + N[(i * -0.005), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {\left(1 + \frac{i}{n}\right)}^{n}\\
t_1 := \frac{t\_0 + -1}{\frac{i}{n}}\\
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;t\_1 \cdot 100\\
\mathbf{elif}\;t\_1 \leq 10^{-313}:\\
\;\;\;\;100 \cdot \left(\mathsf{expm1}\left(n \cdot \mathsf{log1p}\left(\frac{i}{n}\right)\right) \cdot \frac{n}{i}\right)\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\frac{t\_0 \cdot 100 + -100}{\frac{i}{n}}\\
\mathbf{else}:\\
\;\;\;\;\frac{n}{0.01 + i \cdot -0.005}\\
\end{array}
\end{array}
if (/.f64 (-.f64 (pow.f64 (+.f64 #s(literal 1 binary64) (/.f64 i n)) n) #s(literal 1 binary64)) (/.f64 i n)) < -inf.0Initial program 100.0%
if -inf.0 < (/.f64 (-.f64 (pow.f64 (+.f64 #s(literal 1 binary64) (/.f64 i n)) n) #s(literal 1 binary64)) (/.f64 i n)) < 1.00000000001e-313Initial program 30.0%
associate-*r/30.0%
sub-neg30.0%
distribute-rgt-in30.0%
metadata-eval30.0%
metadata-eval30.0%
Simplified30.0%
metadata-eval30.0%
metadata-eval30.0%
distribute-rgt-in30.0%
sub-neg30.0%
associate-*r/30.0%
*-commutative30.0%
div-inv29.9%
add-exp-log29.9%
expm1-define29.9%
log-pow37.2%
log1p-define94.5%
clear-num94.1%
Applied egg-rr94.1%
if 1.00000000001e-313 < (/.f64 (-.f64 (pow.f64 (+.f64 #s(literal 1 binary64) (/.f64 i n)) n) #s(literal 1 binary64)) (/.f64 i n)) < +inf.0Initial program 99.8%
associate-*r/99.9%
sub-neg99.9%
distribute-rgt-in99.9%
metadata-eval99.9%
metadata-eval99.9%
Simplified99.9%
if +inf.0 < (/.f64 (-.f64 (pow.f64 (+.f64 #s(literal 1 binary64) (/.f64 i n)) n) #s(literal 1 binary64)) (/.f64 i n)) Initial program 0.0%
associate-/r/1.8%
associate-*r*1.8%
*-commutative1.8%
associate-*r/1.8%
sub-neg1.8%
distribute-lft-in1.8%
metadata-eval1.8%
metadata-eval1.8%
metadata-eval1.8%
fma-define1.8%
metadata-eval1.8%
Simplified1.8%
Taylor expanded in n around inf 13.4%
sub-neg13.4%
metadata-eval13.4%
metadata-eval13.4%
distribute-lft-in13.4%
metadata-eval13.4%
sub-neg13.4%
expm1-define72.8%
Simplified72.8%
clear-num73.0%
un-div-inv73.0%
*-un-lft-identity73.0%
times-frac73.0%
metadata-eval73.0%
Applied egg-rr73.0%
associate-*r/72.8%
Simplified72.8%
Taylor expanded in i around 0 98.2%
*-commutative98.2%
Simplified98.2%
Final simplification95.7%
(FPCore (i n)
:precision binary64
(let* ((t_0 (* n (/ (* 100.0 (expm1 i)) i)))
(t_1 (/ n (+ 0.01 (* i (- (* i 0.0008333333333333334) 0.005))))))
(if (<= n -3e-23)
t_0
(if (<= n -6.2e-233)
t_1
(if (<= n 8.6e-220) (/ 0.0 (/ i n)) (if (<= n 0.13) t_1 t_0))))))
double code(double i, double n) {
double t_0 = n * ((100.0 * expm1(i)) / i);
double t_1 = n / (0.01 + (i * ((i * 0.0008333333333333334) - 0.005)));
double tmp;
if (n <= -3e-23) {
tmp = t_0;
} else if (n <= -6.2e-233) {
tmp = t_1;
} else if (n <= 8.6e-220) {
tmp = 0.0 / (i / n);
} else if (n <= 0.13) {
tmp = t_1;
} else {
tmp = t_0;
}
return tmp;
}
public static double code(double i, double n) {
double t_0 = n * ((100.0 * Math.expm1(i)) / i);
double t_1 = n / (0.01 + (i * ((i * 0.0008333333333333334) - 0.005)));
double tmp;
if (n <= -3e-23) {
tmp = t_0;
} else if (n <= -6.2e-233) {
tmp = t_1;
} else if (n <= 8.6e-220) {
tmp = 0.0 / (i / n);
} else if (n <= 0.13) {
tmp = t_1;
} else {
tmp = t_0;
}
return tmp;
}
def code(i, n): t_0 = n * ((100.0 * math.expm1(i)) / i) t_1 = n / (0.01 + (i * ((i * 0.0008333333333333334) - 0.005))) tmp = 0 if n <= -3e-23: tmp = t_0 elif n <= -6.2e-233: tmp = t_1 elif n <= 8.6e-220: tmp = 0.0 / (i / n) elif n <= 0.13: tmp = t_1 else: tmp = t_0 return tmp
function code(i, n) t_0 = Float64(n * Float64(Float64(100.0 * expm1(i)) / i)) t_1 = Float64(n / Float64(0.01 + Float64(i * Float64(Float64(i * 0.0008333333333333334) - 0.005)))) tmp = 0.0 if (n <= -3e-23) tmp = t_0; elseif (n <= -6.2e-233) tmp = t_1; elseif (n <= 8.6e-220) tmp = Float64(0.0 / Float64(i / n)); elseif (n <= 0.13) tmp = t_1; else tmp = t_0; end return tmp end
code[i_, n_] := Block[{t$95$0 = N[(n * N[(N[(100.0 * N[(Exp[i] - 1), $MachinePrecision]), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(n / N[(0.01 + N[(i * N[(N[(i * 0.0008333333333333334), $MachinePrecision] - 0.005), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[n, -3e-23], t$95$0, If[LessEqual[n, -6.2e-233], t$95$1, If[LessEqual[n, 8.6e-220], N[(0.0 / N[(i / n), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 0.13], t$95$1, t$95$0]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := n \cdot \frac{100 \cdot \mathsf{expm1}\left(i\right)}{i}\\
t_1 := \frac{n}{0.01 + i \cdot \left(i \cdot 0.0008333333333333334 - 0.005\right)}\\
\mathbf{if}\;n \leq -3 \cdot 10^{-23}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;n \leq -6.2 \cdot 10^{-233}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;n \leq 8.6 \cdot 10^{-220}:\\
\;\;\;\;\frac{0}{\frac{i}{n}}\\
\mathbf{elif}\;n \leq 0.13:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if n < -3.00000000000000003e-23 or 0.13 < n Initial program 29.8%
associate-/r/30.2%
associate-*r*30.2%
*-commutative30.2%
associate-*r/30.2%
sub-neg30.2%
distribute-lft-in30.2%
metadata-eval30.2%
metadata-eval30.2%
metadata-eval30.2%
fma-define30.2%
metadata-eval30.2%
Simplified30.2%
Taylor expanded in n around inf 40.4%
sub-neg40.4%
metadata-eval40.4%
metadata-eval40.4%
distribute-lft-in40.4%
metadata-eval40.4%
sub-neg40.4%
expm1-define87.5%
Simplified87.5%
if -3.00000000000000003e-23 < n < -6.2000000000000003e-233 or 8.59999999999999958e-220 < n < 0.13Initial program 22.9%
associate-/r/23.1%
associate-*r*23.1%
*-commutative23.1%
associate-*r/23.1%
sub-neg23.1%
distribute-lft-in23.1%
metadata-eval23.1%
metadata-eval23.1%
metadata-eval23.1%
fma-define23.1%
metadata-eval23.1%
Simplified23.1%
Taylor expanded in n around inf 14.4%
sub-neg14.4%
metadata-eval14.4%
metadata-eval14.4%
distribute-lft-in14.4%
metadata-eval14.4%
sub-neg14.4%
expm1-define53.3%
Simplified53.3%
clear-num53.3%
un-div-inv53.2%
*-un-lft-identity53.2%
times-frac53.2%
metadata-eval53.2%
Applied egg-rr53.2%
associate-*r/53.0%
Simplified53.0%
Taylor expanded in i around 0 74.9%
if -6.2000000000000003e-233 < n < 8.59999999999999958e-220Initial program 71.5%
associate-*r/71.5%
sub-neg71.5%
distribute-rgt-in71.5%
metadata-eval71.5%
metadata-eval71.5%
Simplified71.5%
Taylor expanded in i around 0 94.0%
Final simplification84.5%
(FPCore (i n)
:precision binary64
(let* ((t_0 (/ n (+ 0.01 (* i (- (* i 0.0008333333333333334) 0.005))))))
(if (<= n -4.9e-23)
(* 100.0 (/ (expm1 i) (/ i n)))
(if (<= n -3e-233)
t_0
(if (<= n 7e-220)
(/ 0.0 (/ i n))
(if (<= n 0.13)
t_0
(*
n
(+
100.0
(*
i
(+
50.0
(* i (+ 16.666666666666668 (* i 4.166666666666667)))))))))))))
double code(double i, double n) {
double t_0 = n / (0.01 + (i * ((i * 0.0008333333333333334) - 0.005)));
double tmp;
if (n <= -4.9e-23) {
tmp = 100.0 * (expm1(i) / (i / n));
} else if (n <= -3e-233) {
tmp = t_0;
} else if (n <= 7e-220) {
tmp = 0.0 / (i / n);
} else if (n <= 0.13) {
tmp = t_0;
} else {
tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667))))));
}
return tmp;
}
public static double code(double i, double n) {
double t_0 = n / (0.01 + (i * ((i * 0.0008333333333333334) - 0.005)));
double tmp;
if (n <= -4.9e-23) {
tmp = 100.0 * (Math.expm1(i) / (i / n));
} else if (n <= -3e-233) {
tmp = t_0;
} else if (n <= 7e-220) {
tmp = 0.0 / (i / n);
} else if (n <= 0.13) {
tmp = t_0;
} else {
tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667))))));
}
return tmp;
}
def code(i, n): t_0 = n / (0.01 + (i * ((i * 0.0008333333333333334) - 0.005))) tmp = 0 if n <= -4.9e-23: tmp = 100.0 * (math.expm1(i) / (i / n)) elif n <= -3e-233: tmp = t_0 elif n <= 7e-220: tmp = 0.0 / (i / n) elif n <= 0.13: tmp = t_0 else: tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667)))))) return tmp
function code(i, n) t_0 = Float64(n / Float64(0.01 + Float64(i * Float64(Float64(i * 0.0008333333333333334) - 0.005)))) tmp = 0.0 if (n <= -4.9e-23) tmp = Float64(100.0 * Float64(expm1(i) / Float64(i / n))); elseif (n <= -3e-233) tmp = t_0; elseif (n <= 7e-220) tmp = Float64(0.0 / Float64(i / n)); elseif (n <= 0.13) tmp = t_0; else tmp = Float64(n * Float64(100.0 + Float64(i * Float64(50.0 + Float64(i * Float64(16.666666666666668 + Float64(i * 4.166666666666667))))))); end return tmp end
code[i_, n_] := Block[{t$95$0 = N[(n / N[(0.01 + N[(i * N[(N[(i * 0.0008333333333333334), $MachinePrecision] - 0.005), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[n, -4.9e-23], N[(100.0 * N[(N[(Exp[i] - 1), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, -3e-233], t$95$0, If[LessEqual[n, 7e-220], N[(0.0 / N[(i / n), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 0.13], t$95$0, N[(n * N[(100.0 + N[(i * N[(50.0 + N[(i * N[(16.666666666666668 + N[(i * 4.166666666666667), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{n}{0.01 + i \cdot \left(i \cdot 0.0008333333333333334 - 0.005\right)}\\
\mathbf{if}\;n \leq -4.9 \cdot 10^{-23}:\\
\;\;\;\;100 \cdot \frac{\mathsf{expm1}\left(i\right)}{\frac{i}{n}}\\
\mathbf{elif}\;n \leq -3 \cdot 10^{-233}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;n \leq 7 \cdot 10^{-220}:\\
\;\;\;\;\frac{0}{\frac{i}{n}}\\
\mathbf{elif}\;n \leq 0.13:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;n \cdot \left(100 + i \cdot \left(50 + i \cdot \left(16.666666666666668 + i \cdot 4.166666666666667\right)\right)\right)\\
\end{array}
\end{array}
if n < -4.8999999999999998e-23Initial program 26.8%
Taylor expanded in n around inf 37.1%
expm1-define71.8%
Simplified71.8%
if -4.8999999999999998e-23 < n < -2.99999999999999999e-233 or 6.99999999999999975e-220 < n < 0.13Initial program 22.9%
associate-/r/23.1%
associate-*r*23.1%
*-commutative23.1%
associate-*r/23.1%
sub-neg23.1%
distribute-lft-in23.1%
metadata-eval23.1%
metadata-eval23.1%
metadata-eval23.1%
fma-define23.1%
metadata-eval23.1%
Simplified23.1%
Taylor expanded in n around inf 14.4%
sub-neg14.4%
metadata-eval14.4%
metadata-eval14.4%
distribute-lft-in14.4%
metadata-eval14.4%
sub-neg14.4%
expm1-define53.3%
Simplified53.3%
clear-num53.3%
un-div-inv53.2%
*-un-lft-identity53.2%
times-frac53.2%
metadata-eval53.2%
Applied egg-rr53.2%
associate-*r/53.0%
Simplified53.0%
Taylor expanded in i around 0 74.9%
if -2.99999999999999999e-233 < n < 6.99999999999999975e-220Initial program 71.5%
associate-*r/71.5%
sub-neg71.5%
distribute-rgt-in71.5%
metadata-eval71.5%
metadata-eval71.5%
Simplified71.5%
Taylor expanded in i around 0 94.0%
if 0.13 < n Initial program 32.9%
associate-/r/33.4%
associate-*r*33.4%
*-commutative33.4%
associate-*r/33.4%
sub-neg33.4%
distribute-lft-in33.4%
metadata-eval33.4%
metadata-eval33.4%
metadata-eval33.4%
fma-define33.4%
metadata-eval33.4%
Simplified33.4%
Taylor expanded in n around inf 43.5%
sub-neg43.5%
metadata-eval43.5%
metadata-eval43.5%
distribute-lft-in43.5%
metadata-eval43.5%
sub-neg43.5%
expm1-define87.5%
Simplified87.5%
Taylor expanded in i around 0 79.7%
*-commutative79.7%
Simplified79.7%
Final simplification77.6%
(FPCore (i n)
:precision binary64
(let* ((t_0 (/ n (+ 0.01 (* i (- (* i 0.0008333333333333334) 0.005)))))
(t_1
(*
n
(+
100.0
(*
i
(+ 50.0 (* i (+ 16.666666666666668 (* i 4.166666666666667)))))))))
(if (<= n -8.2e+177)
t_1
(if (<= n -3.3e-233)
t_0
(if (<= n 8.6e-220) (/ 0.0 (/ i n)) (if (<= n 0.13) t_0 t_1))))))
double code(double i, double n) {
double t_0 = n / (0.01 + (i * ((i * 0.0008333333333333334) - 0.005)));
double t_1 = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667))))));
double tmp;
if (n <= -8.2e+177) {
tmp = t_1;
} else if (n <= -3.3e-233) {
tmp = t_0;
} else if (n <= 8.6e-220) {
tmp = 0.0 / (i / n);
} else if (n <= 0.13) {
tmp = t_0;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = n / (0.01d0 + (i * ((i * 0.0008333333333333334d0) - 0.005d0)))
t_1 = n * (100.0d0 + (i * (50.0d0 + (i * (16.666666666666668d0 + (i * 4.166666666666667d0))))))
if (n <= (-8.2d+177)) then
tmp = t_1
else if (n <= (-3.3d-233)) then
tmp = t_0
else if (n <= 8.6d-220) then
tmp = 0.0d0 / (i / n)
else if (n <= 0.13d0) then
tmp = t_0
else
tmp = t_1
end if
code = tmp
end function
public static double code(double i, double n) {
double t_0 = n / (0.01 + (i * ((i * 0.0008333333333333334) - 0.005)));
double t_1 = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667))))));
double tmp;
if (n <= -8.2e+177) {
tmp = t_1;
} else if (n <= -3.3e-233) {
tmp = t_0;
} else if (n <= 8.6e-220) {
tmp = 0.0 / (i / n);
} else if (n <= 0.13) {
tmp = t_0;
} else {
tmp = t_1;
}
return tmp;
}
def code(i, n): t_0 = n / (0.01 + (i * ((i * 0.0008333333333333334) - 0.005))) t_1 = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667)))))) tmp = 0 if n <= -8.2e+177: tmp = t_1 elif n <= -3.3e-233: tmp = t_0 elif n <= 8.6e-220: tmp = 0.0 / (i / n) elif n <= 0.13: tmp = t_0 else: tmp = t_1 return tmp
function code(i, n) t_0 = Float64(n / Float64(0.01 + Float64(i * Float64(Float64(i * 0.0008333333333333334) - 0.005)))) t_1 = Float64(n * Float64(100.0 + Float64(i * Float64(50.0 + Float64(i * Float64(16.666666666666668 + Float64(i * 4.166666666666667))))))) tmp = 0.0 if (n <= -8.2e+177) tmp = t_1; elseif (n <= -3.3e-233) tmp = t_0; elseif (n <= 8.6e-220) tmp = Float64(0.0 / Float64(i / n)); elseif (n <= 0.13) tmp = t_0; else tmp = t_1; end return tmp end
function tmp_2 = code(i, n) t_0 = n / (0.01 + (i * ((i * 0.0008333333333333334) - 0.005))); t_1 = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667)))))); tmp = 0.0; if (n <= -8.2e+177) tmp = t_1; elseif (n <= -3.3e-233) tmp = t_0; elseif (n <= 8.6e-220) tmp = 0.0 / (i / n); elseif (n <= 0.13) tmp = t_0; else tmp = t_1; end tmp_2 = tmp; end
code[i_, n_] := Block[{t$95$0 = N[(n / N[(0.01 + N[(i * N[(N[(i * 0.0008333333333333334), $MachinePrecision] - 0.005), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(n * N[(100.0 + N[(i * N[(50.0 + N[(i * N[(16.666666666666668 + N[(i * 4.166666666666667), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[n, -8.2e+177], t$95$1, If[LessEqual[n, -3.3e-233], t$95$0, If[LessEqual[n, 8.6e-220], N[(0.0 / N[(i / n), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 0.13], t$95$0, t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{n}{0.01 + i \cdot \left(i \cdot 0.0008333333333333334 - 0.005\right)}\\
t_1 := n \cdot \left(100 + i \cdot \left(50 + i \cdot \left(16.666666666666668 + i \cdot 4.166666666666667\right)\right)\right)\\
\mathbf{if}\;n \leq -8.2 \cdot 10^{+177}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;n \leq -3.3 \cdot 10^{-233}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;n \leq 8.6 \cdot 10^{-220}:\\
\;\;\;\;\frac{0}{\frac{i}{n}}\\
\mathbf{elif}\;n \leq 0.13:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if n < -8.20000000000000029e177 or 0.13 < n Initial program 28.6%
associate-/r/29.0%
associate-*r*29.0%
*-commutative29.0%
associate-*r/29.0%
sub-neg29.0%
distribute-lft-in29.0%
metadata-eval29.0%
metadata-eval29.0%
metadata-eval29.0%
fma-define29.0%
metadata-eval29.0%
Simplified29.0%
Taylor expanded in n around inf 46.2%
sub-neg46.2%
metadata-eval46.2%
metadata-eval46.2%
distribute-lft-in46.2%
metadata-eval46.2%
sub-neg46.2%
expm1-define89.5%
Simplified89.5%
Taylor expanded in i around 0 76.3%
*-commutative76.3%
Simplified76.3%
if -8.20000000000000029e177 < n < -3.3e-233 or 8.59999999999999958e-220 < n < 0.13Initial program 26.4%
associate-/r/26.6%
associate-*r*26.6%
*-commutative26.6%
associate-*r/26.6%
sub-neg26.6%
distribute-lft-in26.6%
metadata-eval26.6%
metadata-eval26.6%
metadata-eval26.6%
fma-define26.6%
metadata-eval26.6%
Simplified26.6%
Taylor expanded in n around inf 18.6%
sub-neg18.6%
metadata-eval18.6%
metadata-eval18.6%
distribute-lft-in18.6%
metadata-eval18.6%
sub-neg18.6%
expm1-define63.9%
Simplified63.9%
clear-num63.9%
un-div-inv63.8%
*-un-lft-identity63.8%
times-frac63.8%
metadata-eval63.8%
Applied egg-rr63.8%
associate-*r/63.6%
Simplified63.6%
Taylor expanded in i around 0 70.0%
if -3.3e-233 < n < 8.59999999999999958e-220Initial program 71.5%
associate-*r/71.5%
sub-neg71.5%
distribute-rgt-in71.5%
metadata-eval71.5%
metadata-eval71.5%
Simplified71.5%
Taylor expanded in i around 0 94.0%
Final simplification75.5%
(FPCore (i n)
:precision binary64
(let* ((t_0 (/ n (+ 0.01 (* i (- (* i 0.0008333333333333334) 0.005))))))
(if (<= n -9e+177)
(* n (+ 100.0 (* i (+ 50.0 (* i 16.666666666666668)))))
(if (<= n -6.5e-233)
t_0
(if (<= n 2.45e-219)
(/ 0.0 (/ i n))
(if (<= n 0.13) t_0 (* n (/ (* i (+ 100.0 (* i 50.0))) i))))))))
double code(double i, double n) {
double t_0 = n / (0.01 + (i * ((i * 0.0008333333333333334) - 0.005)));
double tmp;
if (n <= -9e+177) {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
} else if (n <= -6.5e-233) {
tmp = t_0;
} else if (n <= 2.45e-219) {
tmp = 0.0 / (i / n);
} else if (n <= 0.13) {
tmp = t_0;
} else {
tmp = n * ((i * (100.0 + (i * 50.0))) / i);
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: t_0
real(8) :: tmp
t_0 = n / (0.01d0 + (i * ((i * 0.0008333333333333334d0) - 0.005d0)))
if (n <= (-9d+177)) then
tmp = n * (100.0d0 + (i * (50.0d0 + (i * 16.666666666666668d0))))
else if (n <= (-6.5d-233)) then
tmp = t_0
else if (n <= 2.45d-219) then
tmp = 0.0d0 / (i / n)
else if (n <= 0.13d0) then
tmp = t_0
else
tmp = n * ((i * (100.0d0 + (i * 50.0d0))) / i)
end if
code = tmp
end function
public static double code(double i, double n) {
double t_0 = n / (0.01 + (i * ((i * 0.0008333333333333334) - 0.005)));
double tmp;
if (n <= -9e+177) {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
} else if (n <= -6.5e-233) {
tmp = t_0;
} else if (n <= 2.45e-219) {
tmp = 0.0 / (i / n);
} else if (n <= 0.13) {
tmp = t_0;
} else {
tmp = n * ((i * (100.0 + (i * 50.0))) / i);
}
return tmp;
}
def code(i, n): t_0 = n / (0.01 + (i * ((i * 0.0008333333333333334) - 0.005))) tmp = 0 if n <= -9e+177: tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))) elif n <= -6.5e-233: tmp = t_0 elif n <= 2.45e-219: tmp = 0.0 / (i / n) elif n <= 0.13: tmp = t_0 else: tmp = n * ((i * (100.0 + (i * 50.0))) / i) return tmp
function code(i, n) t_0 = Float64(n / Float64(0.01 + Float64(i * Float64(Float64(i * 0.0008333333333333334) - 0.005)))) tmp = 0.0 if (n <= -9e+177) tmp = Float64(n * Float64(100.0 + Float64(i * Float64(50.0 + Float64(i * 16.666666666666668))))); elseif (n <= -6.5e-233) tmp = t_0; elseif (n <= 2.45e-219) tmp = Float64(0.0 / Float64(i / n)); elseif (n <= 0.13) tmp = t_0; else tmp = Float64(n * Float64(Float64(i * Float64(100.0 + Float64(i * 50.0))) / i)); end return tmp end
function tmp_2 = code(i, n) t_0 = n / (0.01 + (i * ((i * 0.0008333333333333334) - 0.005))); tmp = 0.0; if (n <= -9e+177) tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))); elseif (n <= -6.5e-233) tmp = t_0; elseif (n <= 2.45e-219) tmp = 0.0 / (i / n); elseif (n <= 0.13) tmp = t_0; else tmp = n * ((i * (100.0 + (i * 50.0))) / i); end tmp_2 = tmp; end
code[i_, n_] := Block[{t$95$0 = N[(n / N[(0.01 + N[(i * N[(N[(i * 0.0008333333333333334), $MachinePrecision] - 0.005), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[n, -9e+177], N[(n * N[(100.0 + N[(i * N[(50.0 + N[(i * 16.666666666666668), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, -6.5e-233], t$95$0, If[LessEqual[n, 2.45e-219], N[(0.0 / N[(i / n), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 0.13], t$95$0, N[(n * N[(N[(i * N[(100.0 + N[(i * 50.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{n}{0.01 + i \cdot \left(i \cdot 0.0008333333333333334 - 0.005\right)}\\
\mathbf{if}\;n \leq -9 \cdot 10^{+177}:\\
\;\;\;\;n \cdot \left(100 + i \cdot \left(50 + i \cdot 16.666666666666668\right)\right)\\
\mathbf{elif}\;n \leq -6.5 \cdot 10^{-233}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;n \leq 2.45 \cdot 10^{-219}:\\
\;\;\;\;\frac{0}{\frac{i}{n}}\\
\mathbf{elif}\;n \leq 0.13:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;n \cdot \frac{i \cdot \left(100 + i \cdot 50\right)}{i}\\
\end{array}
\end{array}
if n < -8.9999999999999994e177Initial program 19.2%
associate-/r/19.6%
associate-*r*19.6%
*-commutative19.6%
associate-*r/19.6%
sub-neg19.6%
distribute-lft-in19.6%
metadata-eval19.6%
metadata-eval19.6%
metadata-eval19.6%
fma-define19.6%
metadata-eval19.6%
Simplified19.6%
Taylor expanded in n around inf 52.2%
sub-neg52.2%
metadata-eval52.2%
metadata-eval52.2%
distribute-lft-in52.1%
metadata-eval52.1%
sub-neg52.1%
expm1-define93.8%
Simplified93.8%
Taylor expanded in i around 0 66.7%
*-commutative66.7%
Simplified66.7%
if -8.9999999999999994e177 < n < -6.49999999999999989e-233 or 2.44999999999999995e-219 < n < 0.13Initial program 26.4%
associate-/r/26.6%
associate-*r*26.6%
*-commutative26.6%
associate-*r/26.6%
sub-neg26.6%
distribute-lft-in26.6%
metadata-eval26.6%
metadata-eval26.6%
metadata-eval26.6%
fma-define26.6%
metadata-eval26.6%
Simplified26.6%
Taylor expanded in n around inf 18.6%
sub-neg18.6%
metadata-eval18.6%
metadata-eval18.6%
distribute-lft-in18.6%
metadata-eval18.6%
sub-neg18.6%
expm1-define63.9%
Simplified63.9%
clear-num63.9%
un-div-inv63.8%
*-un-lft-identity63.8%
times-frac63.8%
metadata-eval63.8%
Applied egg-rr63.8%
associate-*r/63.6%
Simplified63.6%
Taylor expanded in i around 0 70.0%
if -6.49999999999999989e-233 < n < 2.44999999999999995e-219Initial program 71.5%
associate-*r/71.5%
sub-neg71.5%
distribute-rgt-in71.5%
metadata-eval71.5%
metadata-eval71.5%
Simplified71.5%
Taylor expanded in i around 0 94.0%
if 0.13 < n Initial program 32.9%
associate-/r/33.4%
associate-*r*33.4%
*-commutative33.4%
associate-*r/33.4%
sub-neg33.4%
distribute-lft-in33.4%
metadata-eval33.4%
metadata-eval33.4%
metadata-eval33.4%
fma-define33.4%
metadata-eval33.4%
Simplified33.4%
Taylor expanded in n around inf 43.5%
sub-neg43.5%
metadata-eval43.5%
metadata-eval43.5%
distribute-lft-in43.5%
metadata-eval43.5%
sub-neg43.5%
expm1-define87.5%
Simplified87.5%
Taylor expanded in i around 0 75.6%
Final simplification74.0%
(FPCore (i n)
:precision binary64
(if (<= n -1.9e+178)
(* n (+ 100.0 (* i (+ 50.0 (* i 16.666666666666668)))))
(if (<= n -6.5e-233)
(/ n (+ 0.01 (* i -0.005)))
(if (<= n 1.85e-116)
(/ 0.0 (/ i n))
(* n (/ (* i (+ 100.0 (* i 50.0))) i))))))
double code(double i, double n) {
double tmp;
if (n <= -1.9e+178) {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
} else if (n <= -6.5e-233) {
tmp = n / (0.01 + (i * -0.005));
} else if (n <= 1.85e-116) {
tmp = 0.0 / (i / n);
} else {
tmp = n * ((i * (100.0 + (i * 50.0))) / i);
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if (n <= (-1.9d+178)) then
tmp = n * (100.0d0 + (i * (50.0d0 + (i * 16.666666666666668d0))))
else if (n <= (-6.5d-233)) then
tmp = n / (0.01d0 + (i * (-0.005d0)))
else if (n <= 1.85d-116) then
tmp = 0.0d0 / (i / n)
else
tmp = n * ((i * (100.0d0 + (i * 50.0d0))) / i)
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if (n <= -1.9e+178) {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
} else if (n <= -6.5e-233) {
tmp = n / (0.01 + (i * -0.005));
} else if (n <= 1.85e-116) {
tmp = 0.0 / (i / n);
} else {
tmp = n * ((i * (100.0 + (i * 50.0))) / i);
}
return tmp;
}
def code(i, n): tmp = 0 if n <= -1.9e+178: tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))) elif n <= -6.5e-233: tmp = n / (0.01 + (i * -0.005)) elif n <= 1.85e-116: tmp = 0.0 / (i / n) else: tmp = n * ((i * (100.0 + (i * 50.0))) / i) return tmp
function code(i, n) tmp = 0.0 if (n <= -1.9e+178) tmp = Float64(n * Float64(100.0 + Float64(i * Float64(50.0 + Float64(i * 16.666666666666668))))); elseif (n <= -6.5e-233) tmp = Float64(n / Float64(0.01 + Float64(i * -0.005))); elseif (n <= 1.85e-116) tmp = Float64(0.0 / Float64(i / n)); else tmp = Float64(n * Float64(Float64(i * Float64(100.0 + Float64(i * 50.0))) / i)); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if (n <= -1.9e+178) tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))); elseif (n <= -6.5e-233) tmp = n / (0.01 + (i * -0.005)); elseif (n <= 1.85e-116) tmp = 0.0 / (i / n); else tmp = n * ((i * (100.0 + (i * 50.0))) / i); end tmp_2 = tmp; end
code[i_, n_] := If[LessEqual[n, -1.9e+178], N[(n * N[(100.0 + N[(i * N[(50.0 + N[(i * 16.666666666666668), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, -6.5e-233], N[(n / N[(0.01 + N[(i * -0.005), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 1.85e-116], N[(0.0 / N[(i / n), $MachinePrecision]), $MachinePrecision], N[(n * N[(N[(i * N[(100.0 + N[(i * 50.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -1.9 \cdot 10^{+178}:\\
\;\;\;\;n \cdot \left(100 + i \cdot \left(50 + i \cdot 16.666666666666668\right)\right)\\
\mathbf{elif}\;n \leq -6.5 \cdot 10^{-233}:\\
\;\;\;\;\frac{n}{0.01 + i \cdot -0.005}\\
\mathbf{elif}\;n \leq 1.85 \cdot 10^{-116}:\\
\;\;\;\;\frac{0}{\frac{i}{n}}\\
\mathbf{else}:\\
\;\;\;\;n \cdot \frac{i \cdot \left(100 + i \cdot 50\right)}{i}\\
\end{array}
\end{array}
if n < -1.89999999999999999e178Initial program 19.2%
associate-/r/19.6%
associate-*r*19.6%
*-commutative19.6%
associate-*r/19.6%
sub-neg19.6%
distribute-lft-in19.6%
metadata-eval19.6%
metadata-eval19.6%
metadata-eval19.6%
fma-define19.6%
metadata-eval19.6%
Simplified19.6%
Taylor expanded in n around inf 52.2%
sub-neg52.2%
metadata-eval52.2%
metadata-eval52.2%
distribute-lft-in52.1%
metadata-eval52.1%
sub-neg52.1%
expm1-define93.8%
Simplified93.8%
Taylor expanded in i around 0 66.7%
*-commutative66.7%
Simplified66.7%
if -1.89999999999999999e178 < n < -6.49999999999999989e-233Initial program 33.1%
associate-/r/33.2%
associate-*r*33.2%
*-commutative33.2%
associate-*r/33.2%
sub-neg33.2%
distribute-lft-in33.2%
metadata-eval33.2%
metadata-eval33.2%
metadata-eval33.2%
fma-define33.2%
metadata-eval33.2%
Simplified33.2%
Taylor expanded in n around inf 19.7%
sub-neg19.7%
metadata-eval19.7%
metadata-eval19.7%
distribute-lft-in19.7%
metadata-eval19.7%
sub-neg19.7%
expm1-define68.8%
Simplified68.8%
clear-num68.9%
un-div-inv68.8%
*-un-lft-identity68.8%
times-frac68.8%
metadata-eval68.8%
Applied egg-rr68.8%
associate-*r/68.5%
Simplified68.5%
Taylor expanded in i around 0 63.8%
*-commutative63.8%
Simplified63.8%
if -6.49999999999999989e-233 < n < 1.8500000000000001e-116Initial program 53.0%
associate-*r/53.0%
sub-neg53.0%
distribute-rgt-in53.0%
metadata-eval53.0%
metadata-eval53.0%
Simplified53.0%
Taylor expanded in i around 0 89.3%
if 1.8500000000000001e-116 < n Initial program 27.5%
associate-/r/27.9%
associate-*r*27.9%
*-commutative27.9%
associate-*r/27.9%
sub-neg27.9%
distribute-lft-in27.9%
metadata-eval27.9%
metadata-eval27.9%
metadata-eval27.9%
fma-define27.9%
metadata-eval27.9%
Simplified27.9%
Taylor expanded in n around inf 36.5%
sub-neg36.5%
metadata-eval36.5%
metadata-eval36.5%
distribute-lft-in36.5%
metadata-eval36.5%
sub-neg36.5%
expm1-define81.3%
Simplified81.3%
Taylor expanded in i around 0 70.8%
Final simplification71.0%
(FPCore (i n)
:precision binary64
(let* ((t_0 (* 100.0 (* i (/ n i)))))
(if (<= i -4e-28)
t_0
(if (<= i 4.1e+32)
(* n 100.0)
(if (<= i 3.4e+238) (* 50.0 (* i n)) t_0)))))
double code(double i, double n) {
double t_0 = 100.0 * (i * (n / i));
double tmp;
if (i <= -4e-28) {
tmp = t_0;
} else if (i <= 4.1e+32) {
tmp = n * 100.0;
} else if (i <= 3.4e+238) {
tmp = 50.0 * (i * n);
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: t_0
real(8) :: tmp
t_0 = 100.0d0 * (i * (n / i))
if (i <= (-4d-28)) then
tmp = t_0
else if (i <= 4.1d+32) then
tmp = n * 100.0d0
else if (i <= 3.4d+238) then
tmp = 50.0d0 * (i * n)
else
tmp = t_0
end if
code = tmp
end function
public static double code(double i, double n) {
double t_0 = 100.0 * (i * (n / i));
double tmp;
if (i <= -4e-28) {
tmp = t_0;
} else if (i <= 4.1e+32) {
tmp = n * 100.0;
} else if (i <= 3.4e+238) {
tmp = 50.0 * (i * n);
} else {
tmp = t_0;
}
return tmp;
}
def code(i, n): t_0 = 100.0 * (i * (n / i)) tmp = 0 if i <= -4e-28: tmp = t_0 elif i <= 4.1e+32: tmp = n * 100.0 elif i <= 3.4e+238: tmp = 50.0 * (i * n) else: tmp = t_0 return tmp
function code(i, n) t_0 = Float64(100.0 * Float64(i * Float64(n / i))) tmp = 0.0 if (i <= -4e-28) tmp = t_0; elseif (i <= 4.1e+32) tmp = Float64(n * 100.0); elseif (i <= 3.4e+238) tmp = Float64(50.0 * Float64(i * n)); else tmp = t_0; end return tmp end
function tmp_2 = code(i, n) t_0 = 100.0 * (i * (n / i)); tmp = 0.0; if (i <= -4e-28) tmp = t_0; elseif (i <= 4.1e+32) tmp = n * 100.0; elseif (i <= 3.4e+238) tmp = 50.0 * (i * n); else tmp = t_0; end tmp_2 = tmp; end
code[i_, n_] := Block[{t$95$0 = N[(100.0 * N[(i * N[(n / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -4e-28], t$95$0, If[LessEqual[i, 4.1e+32], N[(n * 100.0), $MachinePrecision], If[LessEqual[i, 3.4e+238], N[(50.0 * N[(i * n), $MachinePrecision]), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 100 \cdot \left(i \cdot \frac{n}{i}\right)\\
\mathbf{if}\;i \leq -4 \cdot 10^{-28}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;i \leq 4.1 \cdot 10^{+32}:\\
\;\;\;\;n \cdot 100\\
\mathbf{elif}\;i \leq 3.4 \cdot 10^{+238}:\\
\;\;\;\;50 \cdot \left(i \cdot n\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if i < -3.99999999999999988e-28 or 3.3999999999999998e238 < i Initial program 60.5%
Taylor expanded in i around 0 36.3%
+-commutative36.3%
Simplified36.3%
div-inv36.3%
associate--l+35.9%
metadata-eval35.9%
+-rgt-identity35.9%
clear-num34.9%
Applied egg-rr34.9%
if -3.99999999999999988e-28 < i < 4.09999999999999981e32Initial program 10.6%
Taylor expanded in i around 0 84.6%
*-commutative84.6%
Simplified84.6%
if 4.09999999999999981e32 < i < 3.3999999999999998e238Initial program 39.6%
associate-/r/39.8%
associate-*r*39.8%
*-commutative39.8%
associate-*r/39.8%
sub-neg39.8%
distribute-lft-in39.8%
metadata-eval39.8%
metadata-eval39.8%
metadata-eval39.8%
fma-define39.8%
metadata-eval39.8%
Simplified39.8%
Taylor expanded in n around inf 57.5%
sub-neg57.5%
metadata-eval57.5%
metadata-eval57.5%
distribute-lft-in57.5%
metadata-eval57.5%
sub-neg57.5%
expm1-define57.5%
Simplified57.5%
Taylor expanded in i around 0 39.1%
Taylor expanded in i around inf 39.1%
Final simplification59.7%
(FPCore (i n)
:precision binary64
(let* ((t_0 (* 100.0 (* i (/ n i)))))
(if (<= i -2.5e-14)
t_0
(if (<= i 0.005)
(* 100.0 (+ n (* i -0.5)))
(if (<= i 7e+241) (* 50.0 (* i n)) t_0)))))
double code(double i, double n) {
double t_0 = 100.0 * (i * (n / i));
double tmp;
if (i <= -2.5e-14) {
tmp = t_0;
} else if (i <= 0.005) {
tmp = 100.0 * (n + (i * -0.5));
} else if (i <= 7e+241) {
tmp = 50.0 * (i * n);
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: t_0
real(8) :: tmp
t_0 = 100.0d0 * (i * (n / i))
if (i <= (-2.5d-14)) then
tmp = t_0
else if (i <= 0.005d0) then
tmp = 100.0d0 * (n + (i * (-0.5d0)))
else if (i <= 7d+241) then
tmp = 50.0d0 * (i * n)
else
tmp = t_0
end if
code = tmp
end function
public static double code(double i, double n) {
double t_0 = 100.0 * (i * (n / i));
double tmp;
if (i <= -2.5e-14) {
tmp = t_0;
} else if (i <= 0.005) {
tmp = 100.0 * (n + (i * -0.5));
} else if (i <= 7e+241) {
tmp = 50.0 * (i * n);
} else {
tmp = t_0;
}
return tmp;
}
def code(i, n): t_0 = 100.0 * (i * (n / i)) tmp = 0 if i <= -2.5e-14: tmp = t_0 elif i <= 0.005: tmp = 100.0 * (n + (i * -0.5)) elif i <= 7e+241: tmp = 50.0 * (i * n) else: tmp = t_0 return tmp
function code(i, n) t_0 = Float64(100.0 * Float64(i * Float64(n / i))) tmp = 0.0 if (i <= -2.5e-14) tmp = t_0; elseif (i <= 0.005) tmp = Float64(100.0 * Float64(n + Float64(i * -0.5))); elseif (i <= 7e+241) tmp = Float64(50.0 * Float64(i * n)); else tmp = t_0; end return tmp end
function tmp_2 = code(i, n) t_0 = 100.0 * (i * (n / i)); tmp = 0.0; if (i <= -2.5e-14) tmp = t_0; elseif (i <= 0.005) tmp = 100.0 * (n + (i * -0.5)); elseif (i <= 7e+241) tmp = 50.0 * (i * n); else tmp = t_0; end tmp_2 = tmp; end
code[i_, n_] := Block[{t$95$0 = N[(100.0 * N[(i * N[(n / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -2.5e-14], t$95$0, If[LessEqual[i, 0.005], N[(100.0 * N[(n + N[(i * -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 7e+241], N[(50.0 * N[(i * n), $MachinePrecision]), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 100 \cdot \left(i \cdot \frac{n}{i}\right)\\
\mathbf{if}\;i \leq -2.5 \cdot 10^{-14}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;i \leq 0.005:\\
\;\;\;\;100 \cdot \left(n + i \cdot -0.5\right)\\
\mathbf{elif}\;i \leq 7 \cdot 10^{+241}:\\
\;\;\;\;50 \cdot \left(i \cdot n\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if i < -2.5000000000000001e-14 or 7e241 < i Initial program 60.6%
Taylor expanded in i around 0 35.3%
+-commutative35.3%
Simplified35.3%
div-inv35.3%
associate--l+35.3%
metadata-eval35.3%
+-rgt-identity35.3%
clear-num34.2%
Applied egg-rr34.2%
if -2.5000000000000001e-14 < i < 0.0050000000000000001Initial program 10.1%
Taylor expanded in i around 0 62.8%
associate-*r/62.8%
metadata-eval62.8%
Simplified62.8%
Taylor expanded in n around 0 62.5%
associate-*r/62.5%
associate-*l/62.5%
*-commutative62.5%
Simplified62.5%
Taylor expanded in i around 0 86.7%
*-commutative86.7%
Simplified86.7%
if 0.0050000000000000001 < i < 7e241Initial program 41.8%
associate-/r/42.0%
associate-*r*42.0%
*-commutative42.0%
associate-*r/42.0%
sub-neg42.0%
distribute-lft-in42.0%
metadata-eval42.0%
metadata-eval42.0%
metadata-eval42.0%
fma-define42.0%
metadata-eval42.0%
Simplified42.0%
Taylor expanded in n around inf 55.9%
sub-neg55.9%
metadata-eval55.9%
metadata-eval55.9%
distribute-lft-in55.9%
metadata-eval55.9%
sub-neg55.9%
expm1-define55.9%
Simplified55.9%
Taylor expanded in i around 0 35.7%
Taylor expanded in i around inf 35.7%
Final simplification59.7%
(FPCore (i n)
:precision binary64
(let* ((t_0 (* 100.0 (/ i (/ i n)))))
(if (<= i -1.65e-16)
t_0
(if (<= i 0.005)
(* 100.0 (+ n (* i -0.5)))
(if (<= i 5.4e+227) (* 50.0 (* i n)) t_0)))))
double code(double i, double n) {
double t_0 = 100.0 * (i / (i / n));
double tmp;
if (i <= -1.65e-16) {
tmp = t_0;
} else if (i <= 0.005) {
tmp = 100.0 * (n + (i * -0.5));
} else if (i <= 5.4e+227) {
tmp = 50.0 * (i * n);
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: t_0
real(8) :: tmp
t_0 = 100.0d0 * (i / (i / n))
if (i <= (-1.65d-16)) then
tmp = t_0
else if (i <= 0.005d0) then
tmp = 100.0d0 * (n + (i * (-0.5d0)))
else if (i <= 5.4d+227) then
tmp = 50.0d0 * (i * n)
else
tmp = t_0
end if
code = tmp
end function
public static double code(double i, double n) {
double t_0 = 100.0 * (i / (i / n));
double tmp;
if (i <= -1.65e-16) {
tmp = t_0;
} else if (i <= 0.005) {
tmp = 100.0 * (n + (i * -0.5));
} else if (i <= 5.4e+227) {
tmp = 50.0 * (i * n);
} else {
tmp = t_0;
}
return tmp;
}
def code(i, n): t_0 = 100.0 * (i / (i / n)) tmp = 0 if i <= -1.65e-16: tmp = t_0 elif i <= 0.005: tmp = 100.0 * (n + (i * -0.5)) elif i <= 5.4e+227: tmp = 50.0 * (i * n) else: tmp = t_0 return tmp
function code(i, n) t_0 = Float64(100.0 * Float64(i / Float64(i / n))) tmp = 0.0 if (i <= -1.65e-16) tmp = t_0; elseif (i <= 0.005) tmp = Float64(100.0 * Float64(n + Float64(i * -0.5))); elseif (i <= 5.4e+227) tmp = Float64(50.0 * Float64(i * n)); else tmp = t_0; end return tmp end
function tmp_2 = code(i, n) t_0 = 100.0 * (i / (i / n)); tmp = 0.0; if (i <= -1.65e-16) tmp = t_0; elseif (i <= 0.005) tmp = 100.0 * (n + (i * -0.5)); elseif (i <= 5.4e+227) tmp = 50.0 * (i * n); else tmp = t_0; end tmp_2 = tmp; end
code[i_, n_] := Block[{t$95$0 = N[(100.0 * N[(i / N[(i / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -1.65e-16], t$95$0, If[LessEqual[i, 0.005], N[(100.0 * N[(n + N[(i * -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 5.4e+227], N[(50.0 * N[(i * n), $MachinePrecision]), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 100 \cdot \frac{i}{\frac{i}{n}}\\
\mathbf{if}\;i \leq -1.65 \cdot 10^{-16}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;i \leq 0.005:\\
\;\;\;\;100 \cdot \left(n + i \cdot -0.5\right)\\
\mathbf{elif}\;i \leq 5.4 \cdot 10^{+227}:\\
\;\;\;\;50 \cdot \left(i \cdot n\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if i < -1.64999999999999994e-16 or 5.3999999999999997e227 < i Initial program 60.8%
Taylor expanded in i around 0 35.4%
if -1.64999999999999994e-16 < i < 0.0050000000000000001Initial program 10.1%
Taylor expanded in i around 0 62.8%
associate-*r/62.8%
metadata-eval62.8%
Simplified62.8%
Taylor expanded in n around 0 62.5%
associate-*r/62.5%
associate-*l/62.5%
*-commutative62.5%
Simplified62.5%
Taylor expanded in i around 0 86.7%
*-commutative86.7%
Simplified86.7%
if 0.0050000000000000001 < i < 5.3999999999999997e227Initial program 40.2%
associate-/r/40.4%
associate-*r*40.4%
*-commutative40.4%
associate-*r/40.4%
sub-neg40.4%
distribute-lft-in40.4%
metadata-eval40.4%
metadata-eval40.4%
metadata-eval40.4%
fma-define40.4%
metadata-eval40.4%
Simplified40.4%
Taylor expanded in n around inf 57.4%
sub-neg57.4%
metadata-eval57.4%
metadata-eval57.4%
distribute-lft-in57.4%
metadata-eval57.4%
sub-neg57.4%
expm1-define57.4%
Simplified57.4%
Taylor expanded in i around 0 35.8%
Taylor expanded in i around inf 35.8%
Final simplification60.1%
(FPCore (i n)
:precision binary64
(if (<= n -7.5e+179)
(* 100.0 (/ (* i n) i))
(if (<= n -3.1e-233)
(/ n (+ 0.01 (* i -0.005)))
(if (<= n 2.05e-113) (/ 0.0 (/ i n)) (* n (+ 100.0 (* i 50.0)))))))
double code(double i, double n) {
double tmp;
if (n <= -7.5e+179) {
tmp = 100.0 * ((i * n) / i);
} else if (n <= -3.1e-233) {
tmp = n / (0.01 + (i * -0.005));
} else if (n <= 2.05e-113) {
tmp = 0.0 / (i / n);
} else {
tmp = n * (100.0 + (i * 50.0));
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if (n <= (-7.5d+179)) then
tmp = 100.0d0 * ((i * n) / i)
else if (n <= (-3.1d-233)) then
tmp = n / (0.01d0 + (i * (-0.005d0)))
else if (n <= 2.05d-113) then
tmp = 0.0d0 / (i / n)
else
tmp = n * (100.0d0 + (i * 50.0d0))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if (n <= -7.5e+179) {
tmp = 100.0 * ((i * n) / i);
} else if (n <= -3.1e-233) {
tmp = n / (0.01 + (i * -0.005));
} else if (n <= 2.05e-113) {
tmp = 0.0 / (i / n);
} else {
tmp = n * (100.0 + (i * 50.0));
}
return tmp;
}
def code(i, n): tmp = 0 if n <= -7.5e+179: tmp = 100.0 * ((i * n) / i) elif n <= -3.1e-233: tmp = n / (0.01 + (i * -0.005)) elif n <= 2.05e-113: tmp = 0.0 / (i / n) else: tmp = n * (100.0 + (i * 50.0)) return tmp
function code(i, n) tmp = 0.0 if (n <= -7.5e+179) tmp = Float64(100.0 * Float64(Float64(i * n) / i)); elseif (n <= -3.1e-233) tmp = Float64(n / Float64(0.01 + Float64(i * -0.005))); elseif (n <= 2.05e-113) tmp = Float64(0.0 / Float64(i / n)); else tmp = Float64(n * Float64(100.0 + Float64(i * 50.0))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if (n <= -7.5e+179) tmp = 100.0 * ((i * n) / i); elseif (n <= -3.1e-233) tmp = n / (0.01 + (i * -0.005)); elseif (n <= 2.05e-113) tmp = 0.0 / (i / n); else tmp = n * (100.0 + (i * 50.0)); end tmp_2 = tmp; end
code[i_, n_] := If[LessEqual[n, -7.5e+179], N[(100.0 * N[(N[(i * n), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, -3.1e-233], N[(n / N[(0.01 + N[(i * -0.005), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 2.05e-113], N[(0.0 / N[(i / n), $MachinePrecision]), $MachinePrecision], N[(n * N[(100.0 + N[(i * 50.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -7.5 \cdot 10^{+179}:\\
\;\;\;\;100 \cdot \frac{i \cdot n}{i}\\
\mathbf{elif}\;n \leq -3.1 \cdot 10^{-233}:\\
\;\;\;\;\frac{n}{0.01 + i \cdot -0.005}\\
\mathbf{elif}\;n \leq 2.05 \cdot 10^{-113}:\\
\;\;\;\;\frac{0}{\frac{i}{n}}\\
\mathbf{else}:\\
\;\;\;\;n \cdot \left(100 + i \cdot 50\right)\\
\end{array}
\end{array}
if n < -7.50000000000000007e179Initial program 19.2%
Taylor expanded in i around 0 4.3%
+-commutative4.3%
Simplified4.3%
*-un-lft-identity4.3%
div-inv4.3%
times-frac21.5%
associate--l+62.9%
metadata-eval62.9%
+-rgt-identity62.9%
Applied egg-rr62.9%
frac-times23.9%
div-inv24.0%
associate-*l/24.0%
clear-num24.0%
associate-*l/63.2%
Applied egg-rr63.2%
if -7.50000000000000007e179 < n < -3.10000000000000015e-233Initial program 33.1%
associate-/r/33.2%
associate-*r*33.2%
*-commutative33.2%
associate-*r/33.2%
sub-neg33.2%
distribute-lft-in33.2%
metadata-eval33.2%
metadata-eval33.2%
metadata-eval33.2%
fma-define33.2%
metadata-eval33.2%
Simplified33.2%
Taylor expanded in n around inf 19.7%
sub-neg19.7%
metadata-eval19.7%
metadata-eval19.7%
distribute-lft-in19.7%
metadata-eval19.7%
sub-neg19.7%
expm1-define68.8%
Simplified68.8%
clear-num68.9%
un-div-inv68.8%
*-un-lft-identity68.8%
times-frac68.8%
metadata-eval68.8%
Applied egg-rr68.8%
associate-*r/68.5%
Simplified68.5%
Taylor expanded in i around 0 63.8%
*-commutative63.8%
Simplified63.8%
if -3.10000000000000015e-233 < n < 2.05e-113Initial program 53.0%
associate-*r/53.0%
sub-neg53.0%
distribute-rgt-in53.0%
metadata-eval53.0%
metadata-eval53.0%
Simplified53.0%
Taylor expanded in i around 0 89.3%
if 2.05e-113 < n Initial program 27.5%
associate-/r/27.9%
associate-*r*27.9%
*-commutative27.9%
associate-*r/27.9%
sub-neg27.9%
distribute-lft-in27.9%
metadata-eval27.9%
metadata-eval27.9%
metadata-eval27.9%
fma-define27.9%
metadata-eval27.9%
Simplified27.9%
Taylor expanded in n around inf 36.5%
sub-neg36.5%
metadata-eval36.5%
metadata-eval36.5%
distribute-lft-in36.5%
metadata-eval36.5%
sub-neg36.5%
expm1-define81.3%
Simplified81.3%
Taylor expanded in i around 0 66.7%
Final simplification69.1%
(FPCore (i n)
:precision binary64
(if (<= n -9e+177)
(* n (+ 100.0 (* i (+ 50.0 (* i 16.666666666666668)))))
(if (<= n -5.4e-233)
(/ n (+ 0.01 (* i -0.005)))
(if (<= n 7.5e-120) (/ 0.0 (/ i n)) (* n (+ 100.0 (* i 50.0)))))))
double code(double i, double n) {
double tmp;
if (n <= -9e+177) {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
} else if (n <= -5.4e-233) {
tmp = n / (0.01 + (i * -0.005));
} else if (n <= 7.5e-120) {
tmp = 0.0 / (i / n);
} else {
tmp = n * (100.0 + (i * 50.0));
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if (n <= (-9d+177)) then
tmp = n * (100.0d0 + (i * (50.0d0 + (i * 16.666666666666668d0))))
else if (n <= (-5.4d-233)) then
tmp = n / (0.01d0 + (i * (-0.005d0)))
else if (n <= 7.5d-120) then
tmp = 0.0d0 / (i / n)
else
tmp = n * (100.0d0 + (i * 50.0d0))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if (n <= -9e+177) {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
} else if (n <= -5.4e-233) {
tmp = n / (0.01 + (i * -0.005));
} else if (n <= 7.5e-120) {
tmp = 0.0 / (i / n);
} else {
tmp = n * (100.0 + (i * 50.0));
}
return tmp;
}
def code(i, n): tmp = 0 if n <= -9e+177: tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))) elif n <= -5.4e-233: tmp = n / (0.01 + (i * -0.005)) elif n <= 7.5e-120: tmp = 0.0 / (i / n) else: tmp = n * (100.0 + (i * 50.0)) return tmp
function code(i, n) tmp = 0.0 if (n <= -9e+177) tmp = Float64(n * Float64(100.0 + Float64(i * Float64(50.0 + Float64(i * 16.666666666666668))))); elseif (n <= -5.4e-233) tmp = Float64(n / Float64(0.01 + Float64(i * -0.005))); elseif (n <= 7.5e-120) tmp = Float64(0.0 / Float64(i / n)); else tmp = Float64(n * Float64(100.0 + Float64(i * 50.0))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if (n <= -9e+177) tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))); elseif (n <= -5.4e-233) tmp = n / (0.01 + (i * -0.005)); elseif (n <= 7.5e-120) tmp = 0.0 / (i / n); else tmp = n * (100.0 + (i * 50.0)); end tmp_2 = tmp; end
code[i_, n_] := If[LessEqual[n, -9e+177], N[(n * N[(100.0 + N[(i * N[(50.0 + N[(i * 16.666666666666668), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, -5.4e-233], N[(n / N[(0.01 + N[(i * -0.005), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 7.5e-120], N[(0.0 / N[(i / n), $MachinePrecision]), $MachinePrecision], N[(n * N[(100.0 + N[(i * 50.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -9 \cdot 10^{+177}:\\
\;\;\;\;n \cdot \left(100 + i \cdot \left(50 + i \cdot 16.666666666666668\right)\right)\\
\mathbf{elif}\;n \leq -5.4 \cdot 10^{-233}:\\
\;\;\;\;\frac{n}{0.01 + i \cdot -0.005}\\
\mathbf{elif}\;n \leq 7.5 \cdot 10^{-120}:\\
\;\;\;\;\frac{0}{\frac{i}{n}}\\
\mathbf{else}:\\
\;\;\;\;n \cdot \left(100 + i \cdot 50\right)\\
\end{array}
\end{array}
if n < -8.9999999999999994e177Initial program 19.2%
associate-/r/19.6%
associate-*r*19.6%
*-commutative19.6%
associate-*r/19.6%
sub-neg19.6%
distribute-lft-in19.6%
metadata-eval19.6%
metadata-eval19.6%
metadata-eval19.6%
fma-define19.6%
metadata-eval19.6%
Simplified19.6%
Taylor expanded in n around inf 52.2%
sub-neg52.2%
metadata-eval52.2%
metadata-eval52.2%
distribute-lft-in52.1%
metadata-eval52.1%
sub-neg52.1%
expm1-define93.8%
Simplified93.8%
Taylor expanded in i around 0 66.7%
*-commutative66.7%
Simplified66.7%
if -8.9999999999999994e177 < n < -5.3999999999999999e-233Initial program 33.1%
associate-/r/33.2%
associate-*r*33.2%
*-commutative33.2%
associate-*r/33.2%
sub-neg33.2%
distribute-lft-in33.2%
metadata-eval33.2%
metadata-eval33.2%
metadata-eval33.2%
fma-define33.2%
metadata-eval33.2%
Simplified33.2%
Taylor expanded in n around inf 19.7%
sub-neg19.7%
metadata-eval19.7%
metadata-eval19.7%
distribute-lft-in19.7%
metadata-eval19.7%
sub-neg19.7%
expm1-define68.8%
Simplified68.8%
clear-num68.9%
un-div-inv68.8%
*-un-lft-identity68.8%
times-frac68.8%
metadata-eval68.8%
Applied egg-rr68.8%
associate-*r/68.5%
Simplified68.5%
Taylor expanded in i around 0 63.8%
*-commutative63.8%
Simplified63.8%
if -5.3999999999999999e-233 < n < 7.5000000000000004e-120Initial program 53.0%
associate-*r/53.0%
sub-neg53.0%
distribute-rgt-in53.0%
metadata-eval53.0%
metadata-eval53.0%
Simplified53.0%
Taylor expanded in i around 0 89.3%
if 7.5000000000000004e-120 < n Initial program 27.5%
associate-/r/27.9%
associate-*r*27.9%
*-commutative27.9%
associate-*r/27.9%
sub-neg27.9%
distribute-lft-in27.9%
metadata-eval27.9%
metadata-eval27.9%
metadata-eval27.9%
fma-define27.9%
metadata-eval27.9%
Simplified27.9%
Taylor expanded in n around inf 36.5%
sub-neg36.5%
metadata-eval36.5%
metadata-eval36.5%
distribute-lft-in36.5%
metadata-eval36.5%
sub-neg36.5%
expm1-define81.3%
Simplified81.3%
Taylor expanded in i around 0 66.7%
Final simplification69.6%
(FPCore (i n) :precision binary64 (if (or (<= n -1.36e+14) (not (<= n 10000000.0))) (* 100.0 (/ (* i n) i)) (* 100.0 (/ i (/ i n)))))
double code(double i, double n) {
double tmp;
if ((n <= -1.36e+14) || !(n <= 10000000.0)) {
tmp = 100.0 * ((i * n) / i);
} else {
tmp = 100.0 * (i / (i / n));
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if ((n <= (-1.36d+14)) .or. (.not. (n <= 10000000.0d0))) then
tmp = 100.0d0 * ((i * n) / i)
else
tmp = 100.0d0 * (i / (i / n))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if ((n <= -1.36e+14) || !(n <= 10000000.0)) {
tmp = 100.0 * ((i * n) / i);
} else {
tmp = 100.0 * (i / (i / n));
}
return tmp;
}
def code(i, n): tmp = 0 if (n <= -1.36e+14) or not (n <= 10000000.0): tmp = 100.0 * ((i * n) / i) else: tmp = 100.0 * (i / (i / n)) return tmp
function code(i, n) tmp = 0.0 if ((n <= -1.36e+14) || !(n <= 10000000.0)) tmp = Float64(100.0 * Float64(Float64(i * n) / i)); else tmp = Float64(100.0 * Float64(i / Float64(i / n))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if ((n <= -1.36e+14) || ~((n <= 10000000.0))) tmp = 100.0 * ((i * n) / i); else tmp = 100.0 * (i / (i / n)); end tmp_2 = tmp; end
code[i_, n_] := If[Or[LessEqual[n, -1.36e+14], N[Not[LessEqual[n, 10000000.0]], $MachinePrecision]], N[(100.0 * N[(N[(i * n), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision], N[(100.0 * N[(i / N[(i / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -1.36 \cdot 10^{+14} \lor \neg \left(n \leq 10000000\right):\\
\;\;\;\;100 \cdot \frac{i \cdot n}{i}\\
\mathbf{else}:\\
\;\;\;\;100 \cdot \frac{i}{\frac{i}{n}}\\
\end{array}
\end{array}
if n < -1.36e14 or 1e7 < n Initial program 30.3%
Taylor expanded in i around 0 3.6%
+-commutative3.6%
Simplified3.6%
*-un-lft-identity3.6%
div-inv3.6%
times-frac18.1%
associate--l+63.5%
metadata-eval63.5%
+-rgt-identity63.5%
Applied egg-rr63.5%
frac-times27.3%
div-inv27.3%
associate-*l/26.5%
clear-num26.5%
associate-*l/63.6%
Applied egg-rr63.6%
if -1.36e14 < n < 1e7Initial program 35.4%
Taylor expanded in i around 0 67.5%
Final simplification65.5%
(FPCore (i n) :precision binary64 (if (<= n -1.5e+14) (* 100.0 (/ (* i n) i)) (if (<= n 0.44) (* 100.0 (/ i (/ i n))) (* n (+ 100.0 (* i 50.0))))))
double code(double i, double n) {
double tmp;
if (n <= -1.5e+14) {
tmp = 100.0 * ((i * n) / i);
} else if (n <= 0.44) {
tmp = 100.0 * (i / (i / n));
} else {
tmp = n * (100.0 + (i * 50.0));
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if (n <= (-1.5d+14)) then
tmp = 100.0d0 * ((i * n) / i)
else if (n <= 0.44d0) then
tmp = 100.0d0 * (i / (i / n))
else
tmp = n * (100.0d0 + (i * 50.0d0))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if (n <= -1.5e+14) {
tmp = 100.0 * ((i * n) / i);
} else if (n <= 0.44) {
tmp = 100.0 * (i / (i / n));
} else {
tmp = n * (100.0 + (i * 50.0));
}
return tmp;
}
def code(i, n): tmp = 0 if n <= -1.5e+14: tmp = 100.0 * ((i * n) / i) elif n <= 0.44: tmp = 100.0 * (i / (i / n)) else: tmp = n * (100.0 + (i * 50.0)) return tmp
function code(i, n) tmp = 0.0 if (n <= -1.5e+14) tmp = Float64(100.0 * Float64(Float64(i * n) / i)); elseif (n <= 0.44) tmp = Float64(100.0 * Float64(i / Float64(i / n))); else tmp = Float64(n * Float64(100.0 + Float64(i * 50.0))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if (n <= -1.5e+14) tmp = 100.0 * ((i * n) / i); elseif (n <= 0.44) tmp = 100.0 * (i / (i / n)); else tmp = n * (100.0 + (i * 50.0)); end tmp_2 = tmp; end
code[i_, n_] := If[LessEqual[n, -1.5e+14], N[(100.0 * N[(N[(i * n), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 0.44], N[(100.0 * N[(i / N[(i / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(n * N[(100.0 + N[(i * 50.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -1.5 \cdot 10^{+14}:\\
\;\;\;\;100 \cdot \frac{i \cdot n}{i}\\
\mathbf{elif}\;n \leq 0.44:\\
\;\;\;\;100 \cdot \frac{i}{\frac{i}{n}}\\
\mathbf{else}:\\
\;\;\;\;n \cdot \left(100 + i \cdot 50\right)\\
\end{array}
\end{array}
if n < -1.5e14Initial program 27.2%
Taylor expanded in i around 0 3.5%
+-commutative3.5%
Simplified3.5%
*-un-lft-identity3.5%
div-inv3.5%
times-frac12.3%
associate--l+61.7%
metadata-eval61.7%
+-rgt-identity61.7%
Applied egg-rr61.7%
frac-times34.8%
div-inv34.9%
associate-*l/33.2%
clear-num33.3%
associate-*l/61.9%
Applied egg-rr61.9%
if -1.5e14 < n < 0.440000000000000002Initial program 35.7%
Taylor expanded in i around 0 67.3%
if 0.440000000000000002 < n Initial program 32.9%
associate-/r/33.4%
associate-*r*33.4%
*-commutative33.4%
associate-*r/33.4%
sub-neg33.4%
distribute-lft-in33.4%
metadata-eval33.4%
metadata-eval33.4%
metadata-eval33.4%
fma-define33.4%
metadata-eval33.4%
Simplified33.4%
Taylor expanded in n around inf 43.5%
sub-neg43.5%
metadata-eval43.5%
metadata-eval43.5%
distribute-lft-in43.5%
metadata-eval43.5%
sub-neg43.5%
expm1-define87.5%
Simplified87.5%
Taylor expanded in i around 0 70.5%
Final simplification66.8%
(FPCore (i n) :precision binary64 (if (<= n -7.5e+179) (* 100.0 (/ (* i n) i)) (if (<= n 0.017) (/ n (+ 0.01 (* i -0.005))) (* n (+ 100.0 (* i 50.0))))))
double code(double i, double n) {
double tmp;
if (n <= -7.5e+179) {
tmp = 100.0 * ((i * n) / i);
} else if (n <= 0.017) {
tmp = n / (0.01 + (i * -0.005));
} else {
tmp = n * (100.0 + (i * 50.0));
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if (n <= (-7.5d+179)) then
tmp = 100.0d0 * ((i * n) / i)
else if (n <= 0.017d0) then
tmp = n / (0.01d0 + (i * (-0.005d0)))
else
tmp = n * (100.0d0 + (i * 50.0d0))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if (n <= -7.5e+179) {
tmp = 100.0 * ((i * n) / i);
} else if (n <= 0.017) {
tmp = n / (0.01 + (i * -0.005));
} else {
tmp = n * (100.0 + (i * 50.0));
}
return tmp;
}
def code(i, n): tmp = 0 if n <= -7.5e+179: tmp = 100.0 * ((i * n) / i) elif n <= 0.017: tmp = n / (0.01 + (i * -0.005)) else: tmp = n * (100.0 + (i * 50.0)) return tmp
function code(i, n) tmp = 0.0 if (n <= -7.5e+179) tmp = Float64(100.0 * Float64(Float64(i * n) / i)); elseif (n <= 0.017) tmp = Float64(n / Float64(0.01 + Float64(i * -0.005))); else tmp = Float64(n * Float64(100.0 + Float64(i * 50.0))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if (n <= -7.5e+179) tmp = 100.0 * ((i * n) / i); elseif (n <= 0.017) tmp = n / (0.01 + (i * -0.005)); else tmp = n * (100.0 + (i * 50.0)); end tmp_2 = tmp; end
code[i_, n_] := If[LessEqual[n, -7.5e+179], N[(100.0 * N[(N[(i * n), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 0.017], N[(n / N[(0.01 + N[(i * -0.005), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(n * N[(100.0 + N[(i * 50.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -7.5 \cdot 10^{+179}:\\
\;\;\;\;100 \cdot \frac{i \cdot n}{i}\\
\mathbf{elif}\;n \leq 0.017:\\
\;\;\;\;\frac{n}{0.01 + i \cdot -0.005}\\
\mathbf{else}:\\
\;\;\;\;n \cdot \left(100 + i \cdot 50\right)\\
\end{array}
\end{array}
if n < -7.50000000000000007e179Initial program 19.2%
Taylor expanded in i around 0 4.3%
+-commutative4.3%
Simplified4.3%
*-un-lft-identity4.3%
div-inv4.3%
times-frac21.5%
associate--l+62.9%
metadata-eval62.9%
+-rgt-identity62.9%
Applied egg-rr62.9%
frac-times23.9%
div-inv24.0%
associate-*l/24.0%
clear-num24.0%
associate-*l/63.2%
Applied egg-rr63.2%
if -7.50000000000000007e179 < n < 0.017000000000000001Initial program 35.6%
associate-/r/35.5%
associate-*r*35.4%
*-commutative35.4%
associate-*r/35.5%
sub-neg35.5%
distribute-lft-in35.4%
metadata-eval35.4%
metadata-eval35.4%
metadata-eval35.4%
fma-define35.5%
metadata-eval35.5%
Simplified35.5%
Taylor expanded in n around inf 27.1%
sub-neg27.1%
metadata-eval27.1%
metadata-eval27.1%
distribute-lft-in27.1%
metadata-eval27.1%
sub-neg27.1%
expm1-define58.8%
Simplified58.8%
clear-num58.8%
un-div-inv58.7%
*-un-lft-identity58.7%
times-frac58.7%
metadata-eval58.7%
Applied egg-rr58.7%
associate-*r/58.6%
Simplified58.6%
Taylor expanded in i around 0 66.9%
*-commutative66.9%
Simplified66.9%
if 0.017000000000000001 < n Initial program 32.9%
associate-/r/33.4%
associate-*r*33.4%
*-commutative33.4%
associate-*r/33.4%
sub-neg33.4%
distribute-lft-in33.4%
metadata-eval33.4%
metadata-eval33.4%
metadata-eval33.4%
fma-define33.4%
metadata-eval33.4%
Simplified33.4%
Taylor expanded in n around inf 43.5%
sub-neg43.5%
metadata-eval43.5%
metadata-eval43.5%
distribute-lft-in43.5%
metadata-eval43.5%
sub-neg43.5%
expm1-define87.5%
Simplified87.5%
Taylor expanded in i around 0 70.5%
Final simplification67.4%
(FPCore (i n) :precision binary64 (if (<= i 1.56e+29) (* n 100.0) (* 50.0 (* i n))))
double code(double i, double n) {
double tmp;
if (i <= 1.56e+29) {
tmp = n * 100.0;
} else {
tmp = 50.0 * (i * n);
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if (i <= 1.56d+29) then
tmp = n * 100.0d0
else
tmp = 50.0d0 * (i * n)
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if (i <= 1.56e+29) {
tmp = n * 100.0;
} else {
tmp = 50.0 * (i * n);
}
return tmp;
}
def code(i, n): tmp = 0 if i <= 1.56e+29: tmp = n * 100.0 else: tmp = 50.0 * (i * n) return tmp
function code(i, n) tmp = 0.0 if (i <= 1.56e+29) tmp = Float64(n * 100.0); else tmp = Float64(50.0 * Float64(i * n)); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if (i <= 1.56e+29) tmp = n * 100.0; else tmp = 50.0 * (i * n); end tmp_2 = tmp; end
code[i_, n_] := If[LessEqual[i, 1.56e+29], N[(n * 100.0), $MachinePrecision], N[(50.0 * N[(i * n), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq 1.56 \cdot 10^{+29}:\\
\;\;\;\;n \cdot 100\\
\mathbf{else}:\\
\;\;\;\;50 \cdot \left(i \cdot n\right)\\
\end{array}
\end{array}
if i < 1.5599999999999999e29Initial program 28.8%
Taylor expanded in i around 0 56.9%
*-commutative56.9%
Simplified56.9%
if 1.5599999999999999e29 < i Initial program 45.0%
associate-/r/45.3%
associate-*r*45.3%
*-commutative45.3%
associate-*r/45.3%
sub-neg45.3%
distribute-lft-in45.3%
metadata-eval45.3%
metadata-eval45.3%
metadata-eval45.3%
fma-define45.3%
metadata-eval45.3%
Simplified45.3%
Taylor expanded in n around inf 47.5%
sub-neg47.5%
metadata-eval47.5%
metadata-eval47.5%
distribute-lft-in47.5%
metadata-eval47.5%
sub-neg47.5%
expm1-define47.5%
Simplified47.5%
Taylor expanded in i around 0 34.7%
Taylor expanded in i around inf 34.7%
Final simplification51.5%
(FPCore (i n) :precision binary64 (* i -50.0))
double code(double i, double n) {
return i * -50.0;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
code = i * (-50.0d0)
end function
public static double code(double i, double n) {
return i * -50.0;
}
def code(i, n): return i * -50.0
function code(i, n) return Float64(i * -50.0) end
function tmp = code(i, n) tmp = i * -50.0; end
code[i_, n_] := N[(i * -50.0), $MachinePrecision]
\begin{array}{l}
\\
i \cdot -50
\end{array}
Initial program 32.7%
Taylor expanded in i around 0 41.4%
associate-*r/41.4%
metadata-eval41.4%
Simplified41.4%
Taylor expanded in n around 0 2.7%
*-commutative2.7%
Simplified2.7%
Final simplification2.7%
(FPCore (i n) :precision binary64 (* n 100.0))
double code(double i, double n) {
return n * 100.0;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
code = n * 100.0d0
end function
public static double code(double i, double n) {
return n * 100.0;
}
def code(i, n): return n * 100.0
function code(i, n) return Float64(n * 100.0) end
function tmp = code(i, n) tmp = n * 100.0; end
code[i_, n_] := N[(n * 100.0), $MachinePrecision]
\begin{array}{l}
\\
n \cdot 100
\end{array}
Initial program 32.7%
Taylor expanded in i around 0 44.4%
*-commutative44.4%
Simplified44.4%
Final simplification44.4%
(FPCore (i n)
:precision binary64
(let* ((t_0 (+ 1.0 (/ i n))))
(*
100.0
(/
(-
(exp
(*
n
(if (== t_0 1.0)
(/ i n)
(/ (* (/ i n) (log t_0)) (- (+ (/ i n) 1.0) 1.0)))))
1.0)
(/ i n)))))
double code(double i, double n) {
double t_0 = 1.0 + (i / n);
double tmp;
if (t_0 == 1.0) {
tmp = i / n;
} else {
tmp = ((i / n) * log(t_0)) / (((i / n) + 1.0) - 1.0);
}
return 100.0 * ((exp((n * tmp)) - 1.0) / (i / n));
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: t_0
real(8) :: tmp
t_0 = 1.0d0 + (i / n)
if (t_0 == 1.0d0) then
tmp = i / n
else
tmp = ((i / n) * log(t_0)) / (((i / n) + 1.0d0) - 1.0d0)
end if
code = 100.0d0 * ((exp((n * tmp)) - 1.0d0) / (i / n))
end function
public static double code(double i, double n) {
double t_0 = 1.0 + (i / n);
double tmp;
if (t_0 == 1.0) {
tmp = i / n;
} else {
tmp = ((i / n) * Math.log(t_0)) / (((i / n) + 1.0) - 1.0);
}
return 100.0 * ((Math.exp((n * tmp)) - 1.0) / (i / n));
}
def code(i, n): t_0 = 1.0 + (i / n) tmp = 0 if t_0 == 1.0: tmp = i / n else: tmp = ((i / n) * math.log(t_0)) / (((i / n) + 1.0) - 1.0) return 100.0 * ((math.exp((n * tmp)) - 1.0) / (i / n))
function code(i, n) t_0 = Float64(1.0 + Float64(i / n)) tmp = 0.0 if (t_0 == 1.0) tmp = Float64(i / n); else tmp = Float64(Float64(Float64(i / n) * log(t_0)) / Float64(Float64(Float64(i / n) + 1.0) - 1.0)); end return Float64(100.0 * Float64(Float64(exp(Float64(n * tmp)) - 1.0) / Float64(i / n))) end
function tmp_2 = code(i, n) t_0 = 1.0 + (i / n); tmp = 0.0; if (t_0 == 1.0) tmp = i / n; else tmp = ((i / n) * log(t_0)) / (((i / n) + 1.0) - 1.0); end tmp_2 = 100.0 * ((exp((n * tmp)) - 1.0) / (i / n)); end
code[i_, n_] := Block[{t$95$0 = N[(1.0 + N[(i / n), $MachinePrecision]), $MachinePrecision]}, N[(100.0 * N[(N[(N[Exp[N[(n * If[Equal[t$95$0, 1.0], N[(i / n), $MachinePrecision], N[(N[(N[(i / n), $MachinePrecision] * N[Log[t$95$0], $MachinePrecision]), $MachinePrecision] / N[(N[(N[(i / n), $MachinePrecision] + 1.0), $MachinePrecision] - 1.0), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]], $MachinePrecision] - 1.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 1 + \frac{i}{n}\\
100 \cdot \frac{e^{n \cdot \begin{array}{l}
\mathbf{if}\;t\_0 = 1:\\
\;\;\;\;\frac{i}{n}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{i}{n} \cdot \log t\_0}{\left(\frac{i}{n} + 1\right) - 1}\\
\end{array}} - 1}{\frac{i}{n}}
\end{array}
\end{array}
herbie shell --seed 2024066
(FPCore (i n)
:name "Compound Interest"
:precision binary64
:alt
(* 100.0 (/ (- (exp (* n (if (== (+ 1.0 (/ i n)) 1.0) (/ i n) (/ (* (/ i n) (log (+ 1.0 (/ i n)))) (- (+ (/ i n) 1.0) 1.0))))) 1.0) (/ i n)))
(* 100.0 (/ (- (pow (+ 1.0 (/ i n)) n) 1.0) (/ i n))))