
(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 15 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 (if (<= (/ (+ (pow (+ 1.0 (/ i n)) n) -1.0) (/ i n)) INFINITY) (/ (* n 100.0) (/ i (expm1 (* n (log1p (/ i n)))))) (/ (* n 100.0) (+ 1.0 (* i (+ (/ 0.5 n) -0.5))))))
double code(double i, double n) {
double tmp;
if (((pow((1.0 + (i / n)), n) + -1.0) / (i / n)) <= ((double) INFINITY)) {
tmp = (n * 100.0) / (i / expm1((n * log1p((i / n)))));
} else {
tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5)));
}
return tmp;
}
public static double code(double i, double n) {
double tmp;
if (((Math.pow((1.0 + (i / n)), n) + -1.0) / (i / n)) <= Double.POSITIVE_INFINITY) {
tmp = (n * 100.0) / (i / Math.expm1((n * Math.log1p((i / n)))));
} else {
tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5)));
}
return tmp;
}
def code(i, n): tmp = 0 if ((math.pow((1.0 + (i / n)), n) + -1.0) / (i / n)) <= math.inf: tmp = (n * 100.0) / (i / math.expm1((n * math.log1p((i / n))))) else: tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5))) return tmp
function code(i, n) tmp = 0.0 if (Float64(Float64((Float64(1.0 + Float64(i / n)) ^ n) + -1.0) / Float64(i / n)) <= Inf) tmp = Float64(Float64(n * 100.0) / Float64(i / expm1(Float64(n * log1p(Float64(i / n)))))); else tmp = Float64(Float64(n * 100.0) / Float64(1.0 + Float64(i * Float64(Float64(0.5 / n) + -0.5)))); end return tmp end
code[i_, n_] := If[LessEqual[N[(N[(N[Power[N[(1.0 + N[(i / n), $MachinePrecision]), $MachinePrecision], n], $MachinePrecision] + -1.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision], Infinity], N[(N[(n * 100.0), $MachinePrecision] / N[(i / N[(Exp[N[(n * N[Log[1 + N[(i / n), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(n * 100.0), $MachinePrecision] / N[(1.0 + N[(i * N[(N[(0.5 / n), $MachinePrecision] + -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{{\left(1 + \frac{i}{n}\right)}^{n} + -1}{\frac{i}{n}} \leq \infty:\\
\;\;\;\;\frac{n \cdot 100}{\frac{i}{\mathsf{expm1}\left(n \cdot \mathsf{log1p}\left(\frac{i}{n}\right)\right)}}\\
\mathbf{else}:\\
\;\;\;\;\frac{n \cdot 100}{1 + i \cdot \left(\frac{0.5}{n} + -0.5\right)}\\
\end{array}
\end{array}
if (/.f64 (-.f64 (pow.f64 (+.f64 1 (/.f64 i n)) n) 1) (/.f64 i n)) < +inf.0Initial program 31.4%
*-commutative31.4%
associate-/r/31.3%
sub-neg31.3%
metadata-eval31.3%
associate-*r*31.2%
*-commutative31.2%
clear-num31.2%
un-div-inv31.3%
metadata-eval31.3%
sub-neg31.3%
pow-to-exp28.8%
expm1-def39.2%
*-commutative39.2%
log1p-udef96.2%
Applied egg-rr96.2%
if +inf.0 < (/.f64 (-.f64 (pow.f64 (+.f64 1 (/.f64 i n)) n) 1) (/.f64 i n)) Initial program 0.0%
*-commutative0.0%
associate-/r/1.9%
sub-neg1.9%
metadata-eval1.9%
associate-*r*1.8%
*-commutative1.8%
clear-num1.8%
un-div-inv1.8%
metadata-eval1.8%
sub-neg1.8%
pow-to-exp1.8%
expm1-def1.8%
*-commutative1.8%
log1p-udef1.8%
Applied egg-rr1.8%
Taylor expanded in i around 0 100.0%
sub-neg100.0%
associate-*r/100.0%
metadata-eval100.0%
metadata-eval100.0%
Simplified100.0%
Final simplification97.0%
(FPCore (i n) :precision binary64 (if (<= (/ (+ (pow (+ 1.0 (/ i n)) n) -1.0) (/ i n)) INFINITY) (* (expm1 (* n (log1p (/ i n)))) (/ 100.0 (/ i n))) (/ (* n 100.0) (+ 1.0 (* i (+ (/ 0.5 n) -0.5))))))
double code(double i, double n) {
double tmp;
if (((pow((1.0 + (i / n)), n) + -1.0) / (i / n)) <= ((double) INFINITY)) {
tmp = expm1((n * log1p((i / n)))) * (100.0 / (i / n));
} else {
tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5)));
}
return tmp;
}
public static double code(double i, double n) {
double tmp;
if (((Math.pow((1.0 + (i / n)), n) + -1.0) / (i / n)) <= Double.POSITIVE_INFINITY) {
tmp = Math.expm1((n * Math.log1p((i / n)))) * (100.0 / (i / n));
} else {
tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5)));
}
return tmp;
}
def code(i, n): tmp = 0 if ((math.pow((1.0 + (i / n)), n) + -1.0) / (i / n)) <= math.inf: tmp = math.expm1((n * math.log1p((i / n)))) * (100.0 / (i / n)) else: tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5))) return tmp
function code(i, n) tmp = 0.0 if (Float64(Float64((Float64(1.0 + Float64(i / n)) ^ n) + -1.0) / Float64(i / n)) <= Inf) tmp = Float64(expm1(Float64(n * log1p(Float64(i / n)))) * Float64(100.0 / Float64(i / n))); else tmp = Float64(Float64(n * 100.0) / Float64(1.0 + Float64(i * Float64(Float64(0.5 / n) + -0.5)))); end return tmp end
code[i_, n_] := If[LessEqual[N[(N[(N[Power[N[(1.0 + N[(i / n), $MachinePrecision]), $MachinePrecision], n], $MachinePrecision] + -1.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision], Infinity], N[(N[(Exp[N[(n * N[Log[1 + N[(i / n), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision] * N[(100.0 / N[(i / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(n * 100.0), $MachinePrecision] / N[(1.0 + N[(i * N[(N[(0.5 / n), $MachinePrecision] + -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{{\left(1 + \frac{i}{n}\right)}^{n} + -1}{\frac{i}{n}} \leq \infty:\\
\;\;\;\;\mathsf{expm1}\left(n \cdot \mathsf{log1p}\left(\frac{i}{n}\right)\right) \cdot \frac{100}{\frac{i}{n}}\\
\mathbf{else}:\\
\;\;\;\;\frac{n \cdot 100}{1 + i \cdot \left(\frac{0.5}{n} + -0.5\right)}\\
\end{array}
\end{array}
if (/.f64 (-.f64 (pow.f64 (+.f64 1 (/.f64 i n)) n) 1) (/.f64 i n)) < +inf.0Initial program 31.4%
clear-num31.4%
un-div-inv31.4%
pow-to-exp28.9%
expm1-def38.5%
*-commutative38.5%
log1p-udef96.2%
Applied egg-rr96.2%
associate-/r/95.2%
Simplified95.2%
if +inf.0 < (/.f64 (-.f64 (pow.f64 (+.f64 1 (/.f64 i n)) n) 1) (/.f64 i n)) Initial program 0.0%
*-commutative0.0%
associate-/r/1.9%
sub-neg1.9%
metadata-eval1.9%
associate-*r*1.8%
*-commutative1.8%
clear-num1.8%
un-div-inv1.8%
metadata-eval1.8%
sub-neg1.8%
pow-to-exp1.8%
expm1-def1.8%
*-commutative1.8%
log1p-udef1.8%
Applied egg-rr1.8%
Taylor expanded in i around 0 100.0%
sub-neg100.0%
associate-*r/100.0%
metadata-eval100.0%
metadata-eval100.0%
Simplified100.0%
Final simplification96.2%
(FPCore (i n) :precision binary64 (if (<= (/ (+ (pow (+ 1.0 (/ i n)) n) -1.0) (/ i n)) INFINITY) (* (* n 100.0) (/ (expm1 (* n (log1p (/ i n)))) i)) (/ (* n 100.0) (+ 1.0 (* i (+ (/ 0.5 n) -0.5))))))
double code(double i, double n) {
double tmp;
if (((pow((1.0 + (i / n)), n) + -1.0) / (i / n)) <= ((double) INFINITY)) {
tmp = (n * 100.0) * (expm1((n * log1p((i / n)))) / i);
} else {
tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5)));
}
return tmp;
}
public static double code(double i, double n) {
double tmp;
if (((Math.pow((1.0 + (i / n)), n) + -1.0) / (i / n)) <= Double.POSITIVE_INFINITY) {
tmp = (n * 100.0) * (Math.expm1((n * Math.log1p((i / n)))) / i);
} else {
tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5)));
}
return tmp;
}
def code(i, n): tmp = 0 if ((math.pow((1.0 + (i / n)), n) + -1.0) / (i / n)) <= math.inf: tmp = (n * 100.0) * (math.expm1((n * math.log1p((i / n)))) / i) else: tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5))) return tmp
function code(i, n) tmp = 0.0 if (Float64(Float64((Float64(1.0 + Float64(i / n)) ^ n) + -1.0) / Float64(i / n)) <= Inf) tmp = Float64(Float64(n * 100.0) * Float64(expm1(Float64(n * log1p(Float64(i / n)))) / i)); else tmp = Float64(Float64(n * 100.0) / Float64(1.0 + Float64(i * Float64(Float64(0.5 / n) + -0.5)))); end return tmp end
code[i_, n_] := If[LessEqual[N[(N[(N[Power[N[(1.0 + N[(i / n), $MachinePrecision]), $MachinePrecision], n], $MachinePrecision] + -1.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision], Infinity], N[(N[(n * 100.0), $MachinePrecision] * N[(N[(Exp[N[(n * N[Log[1 + N[(i / n), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision], N[(N[(n * 100.0), $MachinePrecision] / N[(1.0 + N[(i * N[(N[(0.5 / n), $MachinePrecision] + -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{{\left(1 + \frac{i}{n}\right)}^{n} + -1}{\frac{i}{n}} \leq \infty:\\
\;\;\;\;\left(n \cdot 100\right) \cdot \frac{\mathsf{expm1}\left(n \cdot \mathsf{log1p}\left(\frac{i}{n}\right)\right)}{i}\\
\mathbf{else}:\\
\;\;\;\;\frac{n \cdot 100}{1 + i \cdot \left(\frac{0.5}{n} + -0.5\right)}\\
\end{array}
\end{array}
if (/.f64 (-.f64 (pow.f64 (+.f64 1 (/.f64 i n)) n) 1) (/.f64 i n)) < +inf.0Initial program 31.4%
*-commutative31.4%
associate-/r/31.3%
sub-neg31.3%
metadata-eval31.3%
associate-*r*31.2%
metadata-eval31.2%
sub-neg31.2%
associate-*l/31.3%
associate-/l*31.4%
pow-to-exp28.9%
expm1-def39.3%
*-commutative39.3%
log1p-udef96.0%
Applied egg-rr96.0%
associate-/r/96.2%
Simplified96.2%
if +inf.0 < (/.f64 (-.f64 (pow.f64 (+.f64 1 (/.f64 i n)) n) 1) (/.f64 i n)) Initial program 0.0%
*-commutative0.0%
associate-/r/1.9%
sub-neg1.9%
metadata-eval1.9%
associate-*r*1.8%
*-commutative1.8%
clear-num1.8%
un-div-inv1.8%
metadata-eval1.8%
sub-neg1.8%
pow-to-exp1.8%
expm1-def1.8%
*-commutative1.8%
log1p-udef1.8%
Applied egg-rr1.8%
Taylor expanded in i around 0 100.0%
sub-neg100.0%
associate-*r/100.0%
metadata-eval100.0%
metadata-eval100.0%
Simplified100.0%
Final simplification97.0%
(FPCore (i n) :precision binary64 (if (or (<= i -8e+18) (not (<= i 0.11))) (* 100.0 (/ (expm1 i) (/ i n))) (/ (* n 100.0) (+ 1.0 (* i (+ (/ 0.5 n) -0.5))))))
double code(double i, double n) {
double tmp;
if ((i <= -8e+18) || !(i <= 0.11)) {
tmp = 100.0 * (expm1(i) / (i / n));
} else {
tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5)));
}
return tmp;
}
public static double code(double i, double n) {
double tmp;
if ((i <= -8e+18) || !(i <= 0.11)) {
tmp = 100.0 * (Math.expm1(i) / (i / n));
} else {
tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5)));
}
return tmp;
}
def code(i, n): tmp = 0 if (i <= -8e+18) or not (i <= 0.11): tmp = 100.0 * (math.expm1(i) / (i / n)) else: tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5))) return tmp
function code(i, n) tmp = 0.0 if ((i <= -8e+18) || !(i <= 0.11)) tmp = Float64(100.0 * Float64(expm1(i) / Float64(i / n))); else tmp = Float64(Float64(n * 100.0) / Float64(1.0 + Float64(i * Float64(Float64(0.5 / n) + -0.5)))); end return tmp end
code[i_, n_] := If[Or[LessEqual[i, -8e+18], N[Not[LessEqual[i, 0.11]], $MachinePrecision]], N[(100.0 * N[(N[(Exp[i] - 1), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(n * 100.0), $MachinePrecision] / N[(1.0 + N[(i * N[(N[(0.5 / n), $MachinePrecision] + -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -8 \cdot 10^{+18} \lor \neg \left(i \leq 0.11\right):\\
\;\;\;\;100 \cdot \frac{\mathsf{expm1}\left(i\right)}{\frac{i}{n}}\\
\mathbf{else}:\\
\;\;\;\;\frac{n \cdot 100}{1 + i \cdot \left(\frac{0.5}{n} + -0.5\right)}\\
\end{array}
\end{array}
if i < -8e18 or 0.110000000000000001 < i Initial program 45.5%
Taylor expanded in n around inf 69.7%
expm1-def69.7%
Simplified69.7%
if -8e18 < i < 0.110000000000000001Initial program 11.9%
*-commutative11.9%
associate-/r/12.5%
sub-neg12.5%
metadata-eval12.5%
associate-*r*12.5%
*-commutative12.5%
clear-num12.5%
un-div-inv12.5%
metadata-eval12.5%
sub-neg12.5%
pow-to-exp12.5%
expm1-def19.6%
*-commutative19.6%
log1p-udef70.8%
Applied egg-rr70.8%
Taylor expanded in i around 0 94.3%
sub-neg94.3%
associate-*r/94.3%
metadata-eval94.3%
metadata-eval94.3%
Simplified94.3%
Final simplification84.9%
(FPCore (i n) :precision binary64 (if (or (<= n -0.01) (not (<= n 0.45))) (* 100.0 (/ n (/ i (expm1 i)))) (/ (* n 100.0) (+ 1.0 (* i (+ (/ 0.5 n) -0.5))))))
double code(double i, double n) {
double tmp;
if ((n <= -0.01) || !(n <= 0.45)) {
tmp = 100.0 * (n / (i / expm1(i)));
} else {
tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5)));
}
return tmp;
}
public static double code(double i, double n) {
double tmp;
if ((n <= -0.01) || !(n <= 0.45)) {
tmp = 100.0 * (n / (i / Math.expm1(i)));
} else {
tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5)));
}
return tmp;
}
def code(i, n): tmp = 0 if (n <= -0.01) or not (n <= 0.45): tmp = 100.0 * (n / (i / math.expm1(i))) else: tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5))) return tmp
function code(i, n) tmp = 0.0 if ((n <= -0.01) || !(n <= 0.45)) tmp = Float64(100.0 * Float64(n / Float64(i / expm1(i)))); else tmp = Float64(Float64(n * 100.0) / Float64(1.0 + Float64(i * Float64(Float64(0.5 / n) + -0.5)))); end return tmp end
code[i_, n_] := If[Or[LessEqual[n, -0.01], N[Not[LessEqual[n, 0.45]], $MachinePrecision]], N[(100.0 * N[(n / N[(i / N[(Exp[i] - 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(n * 100.0), $MachinePrecision] / N[(1.0 + N[(i * N[(N[(0.5 / n), $MachinePrecision] + -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -0.01 \lor \neg \left(n \leq 0.45\right):\\
\;\;\;\;100 \cdot \frac{n}{\frac{i}{\mathsf{expm1}\left(i\right)}}\\
\mathbf{else}:\\
\;\;\;\;\frac{n \cdot 100}{1 + i \cdot \left(\frac{0.5}{n} + -0.5\right)}\\
\end{array}
\end{array}
if n < -0.0100000000000000002 or 0.450000000000000011 < n Initial program 20.2%
Taylor expanded in n around inf 40.9%
*-commutative40.9%
associate-/l*40.9%
expm1-def96.7%
Simplified96.7%
if -0.0100000000000000002 < n < 0.450000000000000011Initial program 31.6%
*-commutative31.6%
associate-/r/31.5%
sub-neg31.5%
metadata-eval31.5%
associate-*r*31.5%
*-commutative31.5%
clear-num31.5%
un-div-inv31.5%
metadata-eval31.5%
sub-neg31.5%
pow-to-exp31.5%
expm1-def51.9%
*-commutative51.9%
log1p-udef90.7%
Applied egg-rr90.7%
Taylor expanded in i around 0 82.2%
sub-neg82.2%
associate-*r/82.2%
metadata-eval82.2%
metadata-eval82.2%
Simplified82.2%
Final simplification90.8%
(FPCore (i n)
:precision binary64
(let* ((t_0 (* (* n 100.0) (+ 1.0 (* i (+ 0.5 (* i 0.16666666666666666)))))))
(if (<= n -2.1e+204)
t_0
(if (<= n -6.5e-213)
(* 10000.0 (/ n (- 100.0 (* i 50.0))))
(if (<= n 1.3e-166) (* -100.0 (/ n (* i (- 0.5 (/ 0.5 n))))) t_0)))))
double code(double i, double n) {
double t_0 = (n * 100.0) * (1.0 + (i * (0.5 + (i * 0.16666666666666666))));
double tmp;
if (n <= -2.1e+204) {
tmp = t_0;
} else if (n <= -6.5e-213) {
tmp = 10000.0 * (n / (100.0 - (i * 50.0)));
} else if (n <= 1.3e-166) {
tmp = -100.0 * (n / (i * (0.5 - (0.5 / 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 = (n * 100.0d0) * (1.0d0 + (i * (0.5d0 + (i * 0.16666666666666666d0))))
if (n <= (-2.1d+204)) then
tmp = t_0
else if (n <= (-6.5d-213)) then
tmp = 10000.0d0 * (n / (100.0d0 - (i * 50.0d0)))
else if (n <= 1.3d-166) then
tmp = (-100.0d0) * (n / (i * (0.5d0 - (0.5d0 / n))))
else
tmp = t_0
end if
code = tmp
end function
public static double code(double i, double n) {
double t_0 = (n * 100.0) * (1.0 + (i * (0.5 + (i * 0.16666666666666666))));
double tmp;
if (n <= -2.1e+204) {
tmp = t_0;
} else if (n <= -6.5e-213) {
tmp = 10000.0 * (n / (100.0 - (i * 50.0)));
} else if (n <= 1.3e-166) {
tmp = -100.0 * (n / (i * (0.5 - (0.5 / n))));
} else {
tmp = t_0;
}
return tmp;
}
def code(i, n): t_0 = (n * 100.0) * (1.0 + (i * (0.5 + (i * 0.16666666666666666)))) tmp = 0 if n <= -2.1e+204: tmp = t_0 elif n <= -6.5e-213: tmp = 10000.0 * (n / (100.0 - (i * 50.0))) elif n <= 1.3e-166: tmp = -100.0 * (n / (i * (0.5 - (0.5 / n)))) else: tmp = t_0 return tmp
function code(i, n) t_0 = Float64(Float64(n * 100.0) * Float64(1.0 + Float64(i * Float64(0.5 + Float64(i * 0.16666666666666666))))) tmp = 0.0 if (n <= -2.1e+204) tmp = t_0; elseif (n <= -6.5e-213) tmp = Float64(10000.0 * Float64(n / Float64(100.0 - Float64(i * 50.0)))); elseif (n <= 1.3e-166) tmp = Float64(-100.0 * Float64(n / Float64(i * Float64(0.5 - Float64(0.5 / n))))); else tmp = t_0; end return tmp end
function tmp_2 = code(i, n) t_0 = (n * 100.0) * (1.0 + (i * (0.5 + (i * 0.16666666666666666)))); tmp = 0.0; if (n <= -2.1e+204) tmp = t_0; elseif (n <= -6.5e-213) tmp = 10000.0 * (n / (100.0 - (i * 50.0))); elseif (n <= 1.3e-166) tmp = -100.0 * (n / (i * (0.5 - (0.5 / n)))); else tmp = t_0; end tmp_2 = tmp; end
code[i_, n_] := Block[{t$95$0 = N[(N[(n * 100.0), $MachinePrecision] * N[(1.0 + N[(i * N[(0.5 + N[(i * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[n, -2.1e+204], t$95$0, If[LessEqual[n, -6.5e-213], N[(10000.0 * N[(n / N[(100.0 - N[(i * 50.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 1.3e-166], N[(-100.0 * N[(n / N[(i * N[(0.5 - N[(0.5 / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(n \cdot 100\right) \cdot \left(1 + i \cdot \left(0.5 + i \cdot 0.16666666666666666\right)\right)\\
\mathbf{if}\;n \leq -2.1 \cdot 10^{+204}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;n \leq -6.5 \cdot 10^{-213}:\\
\;\;\;\;10000 \cdot \frac{n}{100 - i \cdot 50}\\
\mathbf{elif}\;n \leq 1.3 \cdot 10^{-166}:\\
\;\;\;\;-100 \cdot \frac{n}{i \cdot \left(0.5 - \frac{0.5}{n}\right)}\\
\mathbf{else}:\\
\;\;\;\;t_0\\
\end{array}
\end{array}
if n < -2.1e204 or 1.29999999999999995e-166 < n Initial program 16.0%
*-commutative16.0%
associate-/r/16.4%
associate-*l*16.4%
sub-neg16.4%
metadata-eval16.4%
Simplified16.4%
Taylor expanded in n around inf 33.4%
expm1-def89.4%
Simplified89.4%
div-inv89.3%
Applied egg-rr89.3%
Taylor expanded in i around 0 74.6%
+-commutative74.6%
unpow274.6%
associate-*r*74.6%
distribute-rgt-out74.6%
*-commutative74.6%
Simplified74.6%
if -2.1e204 < n < -6.5e-213Initial program 26.8%
Taylor expanded in i around 0 57.3%
sub-neg57.3%
associate-*r/57.3%
metadata-eval57.3%
distribute-neg-frac57.3%
metadata-eval57.3%
Simplified57.3%
distribute-rgt-in57.3%
flip-+43.0%
*-commutative43.0%
*-commutative43.0%
swap-sqr42.3%
metadata-eval42.3%
associate-*l*42.3%
associate-*l*42.3%
associate-*l*42.3%
Applied egg-rr42.3%
Taylor expanded in i around 0 53.6%
*-commutative53.6%
unpow253.6%
associate-*l*54.2%
Simplified54.2%
Taylor expanded in n around inf 65.5%
cancel-sign-sub-inv65.5%
metadata-eval65.5%
metadata-eval65.5%
cancel-sign-sub-inv65.5%
*-commutative65.5%
Simplified65.5%
if -6.5e-213 < n < 1.29999999999999995e-166Initial program 61.7%
Taylor expanded in i around 0 12.4%
sub-neg12.4%
associate-*r/12.4%
metadata-eval12.4%
distribute-neg-frac12.4%
metadata-eval12.4%
Simplified12.4%
distribute-rgt-in12.4%
flip-+6.3%
*-commutative6.3%
*-commutative6.3%
swap-sqr6.3%
metadata-eval6.3%
associate-*l*6.3%
associate-*l*6.3%
associate-*l*6.3%
Applied egg-rr6.3%
Taylor expanded in i around 0 82.9%
*-commutative82.9%
unpow282.9%
associate-*l*82.9%
Simplified82.9%
Taylor expanded in i around inf 83.4%
associate-*r/83.4%
metadata-eval83.4%
Simplified83.4%
Final simplification73.3%
(FPCore (i n)
:precision binary64
(let* ((t_0 (* n (+ 100.0 (* i 50.0)))))
(if (<= n -5.9e+205)
t_0
(if (<= n -3.2e-218)
(* 10000.0 (/ n (- 100.0 (* i 50.0))))
(if (<= n 1.5e-166) (* -100.0 (/ n (* i (- 0.5 (/ 0.5 n))))) t_0)))))
double code(double i, double n) {
double t_0 = n * (100.0 + (i * 50.0));
double tmp;
if (n <= -5.9e+205) {
tmp = t_0;
} else if (n <= -3.2e-218) {
tmp = 10000.0 * (n / (100.0 - (i * 50.0)));
} else if (n <= 1.5e-166) {
tmp = -100.0 * (n / (i * (0.5 - (0.5 / 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 = n * (100.0d0 + (i * 50.0d0))
if (n <= (-5.9d+205)) then
tmp = t_0
else if (n <= (-3.2d-218)) then
tmp = 10000.0d0 * (n / (100.0d0 - (i * 50.0d0)))
else if (n <= 1.5d-166) then
tmp = (-100.0d0) * (n / (i * (0.5d0 - (0.5d0 / n))))
else
tmp = t_0
end if
code = tmp
end function
public static double code(double i, double n) {
double t_0 = n * (100.0 + (i * 50.0));
double tmp;
if (n <= -5.9e+205) {
tmp = t_0;
} else if (n <= -3.2e-218) {
tmp = 10000.0 * (n / (100.0 - (i * 50.0)));
} else if (n <= 1.5e-166) {
tmp = -100.0 * (n / (i * (0.5 - (0.5 / n))));
} else {
tmp = t_0;
}
return tmp;
}
def code(i, n): t_0 = n * (100.0 + (i * 50.0)) tmp = 0 if n <= -5.9e+205: tmp = t_0 elif n <= -3.2e-218: tmp = 10000.0 * (n / (100.0 - (i * 50.0))) elif n <= 1.5e-166: tmp = -100.0 * (n / (i * (0.5 - (0.5 / n)))) else: tmp = t_0 return tmp
function code(i, n) t_0 = Float64(n * Float64(100.0 + Float64(i * 50.0))) tmp = 0.0 if (n <= -5.9e+205) tmp = t_0; elseif (n <= -3.2e-218) tmp = Float64(10000.0 * Float64(n / Float64(100.0 - Float64(i * 50.0)))); elseif (n <= 1.5e-166) tmp = Float64(-100.0 * Float64(n / Float64(i * Float64(0.5 - Float64(0.5 / n))))); else tmp = t_0; end return tmp end
function tmp_2 = code(i, n) t_0 = n * (100.0 + (i * 50.0)); tmp = 0.0; if (n <= -5.9e+205) tmp = t_0; elseif (n <= -3.2e-218) tmp = 10000.0 * (n / (100.0 - (i * 50.0))); elseif (n <= 1.5e-166) tmp = -100.0 * (n / (i * (0.5 - (0.5 / n)))); else tmp = t_0; end tmp_2 = tmp; end
code[i_, n_] := Block[{t$95$0 = N[(n * N[(100.0 + N[(i * 50.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[n, -5.9e+205], t$95$0, If[LessEqual[n, -3.2e-218], N[(10000.0 * N[(n / N[(100.0 - N[(i * 50.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 1.5e-166], N[(-100.0 * N[(n / N[(i * N[(0.5 - N[(0.5 / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := n \cdot \left(100 + i \cdot 50\right)\\
\mathbf{if}\;n \leq -5.9 \cdot 10^{+205}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;n \leq -3.2 \cdot 10^{-218}:\\
\;\;\;\;10000 \cdot \frac{n}{100 - i \cdot 50}\\
\mathbf{elif}\;n \leq 1.5 \cdot 10^{-166}:\\
\;\;\;\;-100 \cdot \frac{n}{i \cdot \left(0.5 - \frac{0.5}{n}\right)}\\
\mathbf{else}:\\
\;\;\;\;t_0\\
\end{array}
\end{array}
if n < -5.9000000000000001e205 or 1.5000000000000001e-166 < n Initial program 16.0%
Taylor expanded in n around inf 33.5%
*-commutative33.5%
associate-/l*33.5%
expm1-def89.5%
Simplified89.5%
Taylor expanded in i around 0 71.6%
associate-*r*71.6%
distribute-rgt-out71.7%
Simplified71.7%
if -5.9000000000000001e205 < n < -3.2000000000000001e-218Initial program 26.8%
Taylor expanded in i around 0 57.3%
sub-neg57.3%
associate-*r/57.3%
metadata-eval57.3%
distribute-neg-frac57.3%
metadata-eval57.3%
Simplified57.3%
distribute-rgt-in57.3%
flip-+43.0%
*-commutative43.0%
*-commutative43.0%
swap-sqr42.3%
metadata-eval42.3%
associate-*l*42.3%
associate-*l*42.3%
associate-*l*42.3%
Applied egg-rr42.3%
Taylor expanded in i around 0 53.6%
*-commutative53.6%
unpow253.6%
associate-*l*54.2%
Simplified54.2%
Taylor expanded in n around inf 65.5%
cancel-sign-sub-inv65.5%
metadata-eval65.5%
metadata-eval65.5%
cancel-sign-sub-inv65.5%
*-commutative65.5%
Simplified65.5%
if -3.2000000000000001e-218 < n < 1.5000000000000001e-166Initial program 61.7%
Taylor expanded in i around 0 12.4%
sub-neg12.4%
associate-*r/12.4%
metadata-eval12.4%
distribute-neg-frac12.4%
metadata-eval12.4%
Simplified12.4%
distribute-rgt-in12.4%
flip-+6.3%
*-commutative6.3%
*-commutative6.3%
swap-sqr6.3%
metadata-eval6.3%
associate-*l*6.3%
associate-*l*6.3%
associate-*l*6.3%
Applied egg-rr6.3%
Taylor expanded in i around 0 82.9%
*-commutative82.9%
unpow282.9%
associate-*l*82.9%
Simplified82.9%
Taylor expanded in i around inf 83.4%
associate-*r/83.4%
metadata-eval83.4%
Simplified83.4%
Final simplification71.5%
(FPCore (i n)
:precision binary64
(if (<= n -2.15e+204)
(* n (+ 100.0 (* i 50.0)))
(if (<= n -3.7e-219)
(* 10000.0 (/ n (- 100.0 (* i 50.0))))
(if (<= n 1.65e-166)
(* -100.0 (/ n (* i (- 0.5 (/ 0.5 n)))))
(* 100.0 (+ n (* i (- (* n 0.5) 0.5))))))))
double code(double i, double n) {
double tmp;
if (n <= -2.15e+204) {
tmp = n * (100.0 + (i * 50.0));
} else if (n <= -3.7e-219) {
tmp = 10000.0 * (n / (100.0 - (i * 50.0)));
} else if (n <= 1.65e-166) {
tmp = -100.0 * (n / (i * (0.5 - (0.5 / n))));
} else {
tmp = 100.0 * (n + (i * ((n * 0.5) - 0.5)));
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if (n <= (-2.15d+204)) then
tmp = n * (100.0d0 + (i * 50.0d0))
else if (n <= (-3.7d-219)) then
tmp = 10000.0d0 * (n / (100.0d0 - (i * 50.0d0)))
else if (n <= 1.65d-166) then
tmp = (-100.0d0) * (n / (i * (0.5d0 - (0.5d0 / n))))
else
tmp = 100.0d0 * (n + (i * ((n * 0.5d0) - 0.5d0)))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if (n <= -2.15e+204) {
tmp = n * (100.0 + (i * 50.0));
} else if (n <= -3.7e-219) {
tmp = 10000.0 * (n / (100.0 - (i * 50.0)));
} else if (n <= 1.65e-166) {
tmp = -100.0 * (n / (i * (0.5 - (0.5 / n))));
} else {
tmp = 100.0 * (n + (i * ((n * 0.5) - 0.5)));
}
return tmp;
}
def code(i, n): tmp = 0 if n <= -2.15e+204: tmp = n * (100.0 + (i * 50.0)) elif n <= -3.7e-219: tmp = 10000.0 * (n / (100.0 - (i * 50.0))) elif n <= 1.65e-166: tmp = -100.0 * (n / (i * (0.5 - (0.5 / n)))) else: tmp = 100.0 * (n + (i * ((n * 0.5) - 0.5))) return tmp
function code(i, n) tmp = 0.0 if (n <= -2.15e+204) tmp = Float64(n * Float64(100.0 + Float64(i * 50.0))); elseif (n <= -3.7e-219) tmp = Float64(10000.0 * Float64(n / Float64(100.0 - Float64(i * 50.0)))); elseif (n <= 1.65e-166) tmp = Float64(-100.0 * Float64(n / Float64(i * Float64(0.5 - Float64(0.5 / n))))); else tmp = Float64(100.0 * Float64(n + Float64(i * Float64(Float64(n * 0.5) - 0.5)))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if (n <= -2.15e+204) tmp = n * (100.0 + (i * 50.0)); elseif (n <= -3.7e-219) tmp = 10000.0 * (n / (100.0 - (i * 50.0))); elseif (n <= 1.65e-166) tmp = -100.0 * (n / (i * (0.5 - (0.5 / n)))); else tmp = 100.0 * (n + (i * ((n * 0.5) - 0.5))); end tmp_2 = tmp; end
code[i_, n_] := If[LessEqual[n, -2.15e+204], N[(n * N[(100.0 + N[(i * 50.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, -3.7e-219], N[(10000.0 * N[(n / N[(100.0 - N[(i * 50.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 1.65e-166], N[(-100.0 * N[(n / N[(i * N[(0.5 - N[(0.5 / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(100.0 * N[(n + N[(i * N[(N[(n * 0.5), $MachinePrecision] - 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -2.15 \cdot 10^{+204}:\\
\;\;\;\;n \cdot \left(100 + i \cdot 50\right)\\
\mathbf{elif}\;n \leq -3.7 \cdot 10^{-219}:\\
\;\;\;\;10000 \cdot \frac{n}{100 - i \cdot 50}\\
\mathbf{elif}\;n \leq 1.65 \cdot 10^{-166}:\\
\;\;\;\;-100 \cdot \frac{n}{i \cdot \left(0.5 - \frac{0.5}{n}\right)}\\
\mathbf{else}:\\
\;\;\;\;100 \cdot \left(n + i \cdot \left(n \cdot 0.5 - 0.5\right)\right)\\
\end{array}
\end{array}
if n < -2.15e204Initial program 9.3%
Taylor expanded in n around inf 56.4%
*-commutative56.4%
associate-/l*56.4%
expm1-def99.9%
Simplified99.9%
Taylor expanded in i around 0 65.0%
associate-*r*65.0%
distribute-rgt-out65.0%
Simplified65.0%
if -2.15e204 < n < -3.7e-219Initial program 26.8%
Taylor expanded in i around 0 57.3%
sub-neg57.3%
associate-*r/57.3%
metadata-eval57.3%
distribute-neg-frac57.3%
metadata-eval57.3%
Simplified57.3%
distribute-rgt-in57.3%
flip-+43.0%
*-commutative43.0%
*-commutative43.0%
swap-sqr42.3%
metadata-eval42.3%
associate-*l*42.3%
associate-*l*42.3%
associate-*l*42.3%
Applied egg-rr42.3%
Taylor expanded in i around 0 53.6%
*-commutative53.6%
unpow253.6%
associate-*l*54.2%
Simplified54.2%
Taylor expanded in n around inf 65.5%
cancel-sign-sub-inv65.5%
metadata-eval65.5%
metadata-eval65.5%
cancel-sign-sub-inv65.5%
*-commutative65.5%
Simplified65.5%
if -3.7e-219 < n < 1.65000000000000009e-166Initial program 61.7%
Taylor expanded in i around 0 12.4%
sub-neg12.4%
associate-*r/12.4%
metadata-eval12.4%
distribute-neg-frac12.4%
metadata-eval12.4%
Simplified12.4%
distribute-rgt-in12.4%
flip-+6.3%
*-commutative6.3%
*-commutative6.3%
swap-sqr6.3%
metadata-eval6.3%
associate-*l*6.3%
associate-*l*6.3%
associate-*l*6.3%
Applied egg-rr6.3%
Taylor expanded in i around 0 82.9%
*-commutative82.9%
unpow282.9%
associate-*l*82.9%
Simplified82.9%
Taylor expanded in i around inf 83.4%
associate-*r/83.4%
metadata-eval83.4%
Simplified83.4%
if 1.65000000000000009e-166 < n Initial program 18.1%
Taylor expanded in i around 0 73.9%
sub-neg73.9%
associate-*r/73.9%
metadata-eval73.9%
distribute-neg-frac73.9%
metadata-eval73.9%
Simplified73.9%
Taylor expanded in n around 0 73.9%
Final simplification71.6%
(FPCore (i n) :precision binary64 (if (or (<= n -1.75e+204) (not (<= n 0.45))) (* (* n 100.0) (+ 1.0 (* i (+ 0.5 (* i 0.16666666666666666))))) (/ (* n 100.0) (+ 1.0 (* i (+ (/ 0.5 n) -0.5))))))
double code(double i, double n) {
double tmp;
if ((n <= -1.75e+204) || !(n <= 0.45)) {
tmp = (n * 100.0) * (1.0 + (i * (0.5 + (i * 0.16666666666666666))));
} else {
tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5)));
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if ((n <= (-1.75d+204)) .or. (.not. (n <= 0.45d0))) then
tmp = (n * 100.0d0) * (1.0d0 + (i * (0.5d0 + (i * 0.16666666666666666d0))))
else
tmp = (n * 100.0d0) / (1.0d0 + (i * ((0.5d0 / n) + (-0.5d0))))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if ((n <= -1.75e+204) || !(n <= 0.45)) {
tmp = (n * 100.0) * (1.0 + (i * (0.5 + (i * 0.16666666666666666))));
} else {
tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5)));
}
return tmp;
}
def code(i, n): tmp = 0 if (n <= -1.75e+204) or not (n <= 0.45): tmp = (n * 100.0) * (1.0 + (i * (0.5 + (i * 0.16666666666666666)))) else: tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5))) return tmp
function code(i, n) tmp = 0.0 if ((n <= -1.75e+204) || !(n <= 0.45)) tmp = Float64(Float64(n * 100.0) * Float64(1.0 + Float64(i * Float64(0.5 + Float64(i * 0.16666666666666666))))); else tmp = Float64(Float64(n * 100.0) / Float64(1.0 + Float64(i * Float64(Float64(0.5 / n) + -0.5)))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if ((n <= -1.75e+204) || ~((n <= 0.45))) tmp = (n * 100.0) * (1.0 + (i * (0.5 + (i * 0.16666666666666666)))); else tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5))); end tmp_2 = tmp; end
code[i_, n_] := If[Or[LessEqual[n, -1.75e+204], N[Not[LessEqual[n, 0.45]], $MachinePrecision]], N[(N[(n * 100.0), $MachinePrecision] * N[(1.0 + N[(i * N[(0.5 + N[(i * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(n * 100.0), $MachinePrecision] / N[(1.0 + N[(i * N[(N[(0.5 / n), $MachinePrecision] + -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -1.75 \cdot 10^{+204} \lor \neg \left(n \leq 0.45\right):\\
\;\;\;\;\left(n \cdot 100\right) \cdot \left(1 + i \cdot \left(0.5 + i \cdot 0.16666666666666666\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{n \cdot 100}{1 + i \cdot \left(\frac{0.5}{n} + -0.5\right)}\\
\end{array}
\end{array}
if n < -1.74999999999999995e204 or 0.450000000000000011 < n Initial program 18.7%
*-commutative18.7%
associate-/r/19.3%
associate-*l*19.3%
sub-neg19.3%
metadata-eval19.3%
Simplified19.3%
Taylor expanded in n around inf 43.7%
expm1-def98.1%
Simplified98.1%
div-inv98.0%
Applied egg-rr98.0%
Taylor expanded in i around 0 78.1%
+-commutative78.1%
unpow278.1%
associate-*r*78.1%
distribute-rgt-out78.1%
*-commutative78.1%
Simplified78.1%
if -1.74999999999999995e204 < n < 0.450000000000000011Initial program 29.7%
*-commutative29.7%
associate-/r/29.7%
sub-neg29.7%
metadata-eval29.7%
associate-*r*29.7%
*-commutative29.7%
clear-num29.7%
un-div-inv29.7%
metadata-eval29.7%
sub-neg29.7%
pow-to-exp27.6%
expm1-def42.4%
*-commutative42.4%
log1p-udef85.6%
Applied egg-rr85.6%
Taylor expanded in i around 0 78.1%
sub-neg78.1%
associate-*r/78.1%
metadata-eval78.1%
metadata-eval78.1%
Simplified78.1%
Final simplification78.1%
(FPCore (i n)
:precision binary64
(if (<= n -4.1e+204)
(* 100.0 (+ n (* n (+ (* i 0.5) (* i (* i 0.25))))))
(if (<= n 0.45)
(/ (* n 100.0) (+ 1.0 (* i (+ (/ 0.5 n) -0.5))))
(* (* n 100.0) (+ 1.0 (* i (+ 0.5 (* i 0.16666666666666666))))))))
double code(double i, double n) {
double tmp;
if (n <= -4.1e+204) {
tmp = 100.0 * (n + (n * ((i * 0.5) + (i * (i * 0.25)))));
} else if (n <= 0.45) {
tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5)));
} else {
tmp = (n * 100.0) * (1.0 + (i * (0.5 + (i * 0.16666666666666666))));
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if (n <= (-4.1d+204)) then
tmp = 100.0d0 * (n + (n * ((i * 0.5d0) + (i * (i * 0.25d0)))))
else if (n <= 0.45d0) then
tmp = (n * 100.0d0) / (1.0d0 + (i * ((0.5d0 / n) + (-0.5d0))))
else
tmp = (n * 100.0d0) * (1.0d0 + (i * (0.5d0 + (i * 0.16666666666666666d0))))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if (n <= -4.1e+204) {
tmp = 100.0 * (n + (n * ((i * 0.5) + (i * (i * 0.25)))));
} else if (n <= 0.45) {
tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5)));
} else {
tmp = (n * 100.0) * (1.0 + (i * (0.5 + (i * 0.16666666666666666))));
}
return tmp;
}
def code(i, n): tmp = 0 if n <= -4.1e+204: tmp = 100.0 * (n + (n * ((i * 0.5) + (i * (i * 0.25))))) elif n <= 0.45: tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5))) else: tmp = (n * 100.0) * (1.0 + (i * (0.5 + (i * 0.16666666666666666)))) return tmp
function code(i, n) tmp = 0.0 if (n <= -4.1e+204) tmp = Float64(100.0 * Float64(n + Float64(n * Float64(Float64(i * 0.5) + Float64(i * Float64(i * 0.25)))))); elseif (n <= 0.45) tmp = Float64(Float64(n * 100.0) / Float64(1.0 + Float64(i * Float64(Float64(0.5 / n) + -0.5)))); else tmp = Float64(Float64(n * 100.0) * Float64(1.0 + Float64(i * Float64(0.5 + Float64(i * 0.16666666666666666))))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if (n <= -4.1e+204) tmp = 100.0 * (n + (n * ((i * 0.5) + (i * (i * 0.25))))); elseif (n <= 0.45) tmp = (n * 100.0) / (1.0 + (i * ((0.5 / n) + -0.5))); else tmp = (n * 100.0) * (1.0 + (i * (0.5 + (i * 0.16666666666666666)))); end tmp_2 = tmp; end
code[i_, n_] := If[LessEqual[n, -4.1e+204], N[(100.0 * N[(n + N[(n * N[(N[(i * 0.5), $MachinePrecision] + N[(i * N[(i * 0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 0.45], N[(N[(n * 100.0), $MachinePrecision] / N[(1.0 + N[(i * N[(N[(0.5 / n), $MachinePrecision] + -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(n * 100.0), $MachinePrecision] * N[(1.0 + N[(i * N[(0.5 + N[(i * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -4.1 \cdot 10^{+204}:\\
\;\;\;\;100 \cdot \left(n + n \cdot \left(i \cdot 0.5 + i \cdot \left(i \cdot 0.25\right)\right)\right)\\
\mathbf{elif}\;n \leq 0.45:\\
\;\;\;\;\frac{n \cdot 100}{1 + i \cdot \left(\frac{0.5}{n} + -0.5\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(n \cdot 100\right) \cdot \left(1 + i \cdot \left(0.5 + i \cdot 0.16666666666666666\right)\right)\\
\end{array}
\end{array}
if n < -4.09999999999999975e204Initial program 9.3%
Taylor expanded in n around inf 56.4%
*-commutative56.4%
associate-/l*56.4%
expm1-def99.9%
Simplified99.9%
Taylor expanded in i around 0 52.6%
*-commutative52.6%
Simplified52.6%
Taylor expanded in i around 0 64.9%
+-commutative64.9%
associate-*r*64.9%
associate-*r*64.9%
distribute-rgt-out66.3%
unpow266.3%
associate-*r*66.3%
Simplified66.3%
if -4.09999999999999975e204 < n < 0.450000000000000011Initial program 29.7%
*-commutative29.7%
associate-/r/29.7%
sub-neg29.7%
metadata-eval29.7%
associate-*r*29.7%
*-commutative29.7%
clear-num29.7%
un-div-inv29.7%
metadata-eval29.7%
sub-neg29.7%
pow-to-exp27.6%
expm1-def42.4%
*-commutative42.4%
log1p-udef85.6%
Applied egg-rr85.6%
Taylor expanded in i around 0 78.1%
sub-neg78.1%
associate-*r/78.1%
metadata-eval78.1%
metadata-eval78.1%
Simplified78.1%
if 0.450000000000000011 < n Initial program 23.2%
*-commutative23.2%
associate-/r/23.8%
associate-*l*23.8%
sub-neg23.8%
metadata-eval23.8%
Simplified23.8%
Taylor expanded in n around inf 37.8%
expm1-def97.3%
Simplified97.3%
div-inv97.2%
Applied egg-rr97.2%
Taylor expanded in i around 0 83.7%
+-commutative83.7%
unpow283.7%
associate-*r*83.7%
distribute-rgt-out83.7%
*-commutative83.7%
Simplified83.7%
Final simplification78.1%
(FPCore (i n)
:precision binary64
(let* ((t_0 (* n (+ 100.0 (* i 50.0)))))
(if (<= n -5.2e+205)
t_0
(if (<= n -3.8e-198)
(* 10000.0 (/ n (- 100.0 (* i 50.0))))
(if (<= n 1.75e-166) 0.0 t_0)))))
double code(double i, double n) {
double t_0 = n * (100.0 + (i * 50.0));
double tmp;
if (n <= -5.2e+205) {
tmp = t_0;
} else if (n <= -3.8e-198) {
tmp = 10000.0 * (n / (100.0 - (i * 50.0)));
} else if (n <= 1.75e-166) {
tmp = 0.0;
} 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 = n * (100.0d0 + (i * 50.0d0))
if (n <= (-5.2d+205)) then
tmp = t_0
else if (n <= (-3.8d-198)) then
tmp = 10000.0d0 * (n / (100.0d0 - (i * 50.0d0)))
else if (n <= 1.75d-166) then
tmp = 0.0d0
else
tmp = t_0
end if
code = tmp
end function
public static double code(double i, double n) {
double t_0 = n * (100.0 + (i * 50.0));
double tmp;
if (n <= -5.2e+205) {
tmp = t_0;
} else if (n <= -3.8e-198) {
tmp = 10000.0 * (n / (100.0 - (i * 50.0)));
} else if (n <= 1.75e-166) {
tmp = 0.0;
} else {
tmp = t_0;
}
return tmp;
}
def code(i, n): t_0 = n * (100.0 + (i * 50.0)) tmp = 0 if n <= -5.2e+205: tmp = t_0 elif n <= -3.8e-198: tmp = 10000.0 * (n / (100.0 - (i * 50.0))) elif n <= 1.75e-166: tmp = 0.0 else: tmp = t_0 return tmp
function code(i, n) t_0 = Float64(n * Float64(100.0 + Float64(i * 50.0))) tmp = 0.0 if (n <= -5.2e+205) tmp = t_0; elseif (n <= -3.8e-198) tmp = Float64(10000.0 * Float64(n / Float64(100.0 - Float64(i * 50.0)))); elseif (n <= 1.75e-166) tmp = 0.0; else tmp = t_0; end return tmp end
function tmp_2 = code(i, n) t_0 = n * (100.0 + (i * 50.0)); tmp = 0.0; if (n <= -5.2e+205) tmp = t_0; elseif (n <= -3.8e-198) tmp = 10000.0 * (n / (100.0 - (i * 50.0))); elseif (n <= 1.75e-166) tmp = 0.0; else tmp = t_0; end tmp_2 = tmp; end
code[i_, n_] := Block[{t$95$0 = N[(n * N[(100.0 + N[(i * 50.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[n, -5.2e+205], t$95$0, If[LessEqual[n, -3.8e-198], N[(10000.0 * N[(n / N[(100.0 - N[(i * 50.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 1.75e-166], 0.0, t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := n \cdot \left(100 + i \cdot 50\right)\\
\mathbf{if}\;n \leq -5.2 \cdot 10^{+205}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;n \leq -3.8 \cdot 10^{-198}:\\
\;\;\;\;10000 \cdot \frac{n}{100 - i \cdot 50}\\
\mathbf{elif}\;n \leq 1.75 \cdot 10^{-166}:\\
\;\;\;\;0\\
\mathbf{else}:\\
\;\;\;\;t_0\\
\end{array}
\end{array}
if n < -5.1999999999999998e205 or 1.75e-166 < n Initial program 16.0%
Taylor expanded in n around inf 33.5%
*-commutative33.5%
associate-/l*33.5%
expm1-def89.5%
Simplified89.5%
Taylor expanded in i around 0 71.6%
associate-*r*71.6%
distribute-rgt-out71.7%
Simplified71.7%
if -5.1999999999999998e205 < n < -3.8000000000000002e-198Initial program 25.0%
Taylor expanded in i around 0 58.3%
sub-neg58.3%
associate-*r/58.3%
metadata-eval58.3%
distribute-neg-frac58.3%
metadata-eval58.3%
Simplified58.3%
distribute-rgt-in58.3%
flip-+44.8%
*-commutative44.8%
*-commutative44.8%
swap-sqr44.0%
metadata-eval44.0%
associate-*l*44.0%
associate-*l*44.0%
associate-*l*44.0%
Applied egg-rr44.0%
Taylor expanded in i around 0 52.9%
*-commutative52.9%
unpow252.9%
associate-*l*53.5%
Simplified53.5%
Taylor expanded in n around inf 65.4%
cancel-sign-sub-inv65.4%
metadata-eval65.4%
metadata-eval65.4%
cancel-sign-sub-inv65.4%
*-commutative65.4%
Simplified65.4%
if -3.8000000000000002e-198 < n < 1.75e-166Initial program 62.3%
*-commutative62.3%
associate-/r/62.6%
associate-*l*62.6%
sub-neg62.6%
metadata-eval62.6%
Simplified62.6%
Taylor expanded in i around 0 81.7%
Taylor expanded in i around 0 81.7%
Final simplification71.4%
(FPCore (i n) :precision binary64 (if (or (<= i -0.45) (not (<= i 4e-9))) (* 200.0 (/ (* n n) i)) (* 100.0 (+ n (* i -0.5)))))
double code(double i, double n) {
double tmp;
if ((i <= -0.45) || !(i <= 4e-9)) {
tmp = 200.0 * ((n * n) / i);
} else {
tmp = 100.0 * (n + (i * -0.5));
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if ((i <= (-0.45d0)) .or. (.not. (i <= 4d-9))) then
tmp = 200.0d0 * ((n * n) / i)
else
tmp = 100.0d0 * (n + (i * (-0.5d0)))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if ((i <= -0.45) || !(i <= 4e-9)) {
tmp = 200.0 * ((n * n) / i);
} else {
tmp = 100.0 * (n + (i * -0.5));
}
return tmp;
}
def code(i, n): tmp = 0 if (i <= -0.45) or not (i <= 4e-9): tmp = 200.0 * ((n * n) / i) else: tmp = 100.0 * (n + (i * -0.5)) return tmp
function code(i, n) tmp = 0.0 if ((i <= -0.45) || !(i <= 4e-9)) tmp = Float64(200.0 * Float64(Float64(n * n) / i)); else tmp = Float64(100.0 * Float64(n + Float64(i * -0.5))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if ((i <= -0.45) || ~((i <= 4e-9))) tmp = 200.0 * ((n * n) / i); else tmp = 100.0 * (n + (i * -0.5)); end tmp_2 = tmp; end
code[i_, n_] := If[Or[LessEqual[i, -0.45], N[Not[LessEqual[i, 4e-9]], $MachinePrecision]], N[(200.0 * N[(N[(n * n), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision], N[(100.0 * N[(n + N[(i * -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -0.45 \lor \neg \left(i \leq 4 \cdot 10^{-9}\right):\\
\;\;\;\;200 \cdot \frac{n \cdot n}{i}\\
\mathbf{else}:\\
\;\;\;\;100 \cdot \left(n + i \cdot -0.5\right)\\
\end{array}
\end{array}
if i < -0.450000000000000011 or 4.00000000000000025e-9 < i Initial program 46.7%
Taylor expanded in i around 0 20.3%
sub-neg20.3%
associate-*r/20.3%
metadata-eval20.3%
distribute-neg-frac20.3%
metadata-eval20.3%
Simplified20.3%
distribute-rgt-in20.3%
flip-+7.8%
*-commutative7.8%
*-commutative7.8%
swap-sqr7.8%
metadata-eval7.8%
associate-*l*7.8%
associate-*l*7.8%
associate-*l*7.8%
Applied egg-rr7.8%
Taylor expanded in i around 0 29.2%
*-commutative29.2%
unpow229.2%
associate-*l*29.2%
Simplified29.2%
Taylor expanded in n around 0 36.5%
unpow236.5%
Simplified36.5%
if -0.450000000000000011 < i < 4.00000000000000025e-9Initial program 10.3%
Taylor expanded in i around 0 86.6%
sub-neg86.6%
associate-*r/86.6%
metadata-eval86.6%
distribute-neg-frac86.6%
metadata-eval86.6%
Simplified86.6%
Taylor expanded in n around 0 86.1%
Final simplification66.3%
(FPCore (i n) :precision binary64 (if (or (<= n -7.6e-197) (not (<= n 2e-166))) (* n (+ 100.0 (* i 50.0))) 0.0))
double code(double i, double n) {
double tmp;
if ((n <= -7.6e-197) || !(n <= 2e-166)) {
tmp = n * (100.0 + (i * 50.0));
} else {
tmp = 0.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.6d-197)) .or. (.not. (n <= 2d-166))) then
tmp = n * (100.0d0 + (i * 50.0d0))
else
tmp = 0.0d0
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if ((n <= -7.6e-197) || !(n <= 2e-166)) {
tmp = n * (100.0 + (i * 50.0));
} else {
tmp = 0.0;
}
return tmp;
}
def code(i, n): tmp = 0 if (n <= -7.6e-197) or not (n <= 2e-166): tmp = n * (100.0 + (i * 50.0)) else: tmp = 0.0 return tmp
function code(i, n) tmp = 0.0 if ((n <= -7.6e-197) || !(n <= 2e-166)) tmp = Float64(n * Float64(100.0 + Float64(i * 50.0))); else tmp = 0.0; end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if ((n <= -7.6e-197) || ~((n <= 2e-166))) tmp = n * (100.0 + (i * 50.0)); else tmp = 0.0; end tmp_2 = tmp; end
code[i_, n_] := If[Or[LessEqual[n, -7.6e-197], N[Not[LessEqual[n, 2e-166]], $MachinePrecision]], N[(n * N[(100.0 + N[(i * 50.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.0]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -7.6 \cdot 10^{-197} \lor \neg \left(n \leq 2 \cdot 10^{-166}\right):\\
\;\;\;\;n \cdot \left(100 + i \cdot 50\right)\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if n < -7.5999999999999998e-197 or 2.00000000000000008e-166 < n Initial program 18.7%
Taylor expanded in n around inf 30.9%
*-commutative30.9%
associate-/l*30.9%
expm1-def86.6%
Simplified86.6%
Taylor expanded in i around 0 67.6%
associate-*r*67.6%
distribute-rgt-out67.6%
Simplified67.6%
if -7.5999999999999998e-197 < n < 2.00000000000000008e-166Initial program 62.3%
*-commutative62.3%
associate-/r/62.6%
associate-*l*62.6%
sub-neg62.6%
metadata-eval62.6%
Simplified62.6%
Taylor expanded in i around 0 81.7%
Taylor expanded in i around 0 81.7%
Final simplification69.6%
(FPCore (i n) :precision binary64 (if (<= n -9e-197) (* n 100.0) (if (<= n 1.35e-164) 0.0 (* n 100.0))))
double code(double i, double n) {
double tmp;
if (n <= -9e-197) {
tmp = n * 100.0;
} else if (n <= 1.35e-164) {
tmp = 0.0;
} else {
tmp = n * 100.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-197)) then
tmp = n * 100.0d0
else if (n <= 1.35d-164) then
tmp = 0.0d0
else
tmp = n * 100.0d0
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if (n <= -9e-197) {
tmp = n * 100.0;
} else if (n <= 1.35e-164) {
tmp = 0.0;
} else {
tmp = n * 100.0;
}
return tmp;
}
def code(i, n): tmp = 0 if n <= -9e-197: tmp = n * 100.0 elif n <= 1.35e-164: tmp = 0.0 else: tmp = n * 100.0 return tmp
function code(i, n) tmp = 0.0 if (n <= -9e-197) tmp = Float64(n * 100.0); elseif (n <= 1.35e-164) tmp = 0.0; else tmp = Float64(n * 100.0); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if (n <= -9e-197) tmp = n * 100.0; elseif (n <= 1.35e-164) tmp = 0.0; else tmp = n * 100.0; end tmp_2 = tmp; end
code[i_, n_] := If[LessEqual[n, -9e-197], N[(n * 100.0), $MachinePrecision], If[LessEqual[n, 1.35e-164], 0.0, N[(n * 100.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -9 \cdot 10^{-197}:\\
\;\;\;\;n \cdot 100\\
\mathbf{elif}\;n \leq 1.35 \cdot 10^{-164}:\\
\;\;\;\;0\\
\mathbf{else}:\\
\;\;\;\;n \cdot 100\\
\end{array}
\end{array}
if n < -9.0000000000000002e-197 or 1.3500000000000001e-164 < n Initial program 18.7%
Taylor expanded in i around 0 59.9%
*-commutative59.9%
Simplified59.9%
if -9.0000000000000002e-197 < n < 1.3500000000000001e-164Initial program 62.3%
*-commutative62.3%
associate-/r/62.6%
associate-*l*62.6%
sub-neg62.6%
metadata-eval62.6%
Simplified62.6%
Taylor expanded in i around 0 81.7%
Taylor expanded in i around 0 81.7%
Final simplification63.0%
(FPCore (i n) :precision binary64 0.0)
double code(double i, double n) {
return 0.0;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
code = 0.0d0
end function
public static double code(double i, double n) {
return 0.0;
}
def code(i, n): return 0.0
function code(i, n) return 0.0 end
function tmp = code(i, n) tmp = 0.0; end
code[i_, n_] := 0.0
\begin{array}{l}
\\
0
\end{array}
Initial program 24.8%
*-commutative24.8%
associate-/r/25.1%
associate-*l*25.0%
sub-neg25.0%
metadata-eval25.0%
Simplified25.0%
Taylor expanded in i around 0 17.3%
Taylor expanded in i around 0 17.3%
Final simplification17.3%
(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 2023275
(FPCore (i n)
:name "Compound Interest"
:precision binary64
:herbie-target
(* 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))))