
(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
(let* ((t_0 (/ (+ (pow (+ 1.0 (/ i n)) n) -1.0) (/ i n))))
(if (<= t_0 5e-292)
(/ 100.0 (/ (/ i n) (expm1 (* n (log1p (/ i n))))))
(if (<= t_0 INFINITY)
(/ (+ (* 100.0 (pow (/ i n) n)) -100.0) (/ i n))
(/ 100.0 (+ (* (/ i n) -0.5) (/ 1.0 n)))))))
double code(double i, double n) {
double t_0 = (pow((1.0 + (i / n)), n) + -1.0) / (i / n);
double tmp;
if (t_0 <= 5e-292) {
tmp = 100.0 / ((i / n) / expm1((n * log1p((i / n)))));
} else if (t_0 <= ((double) INFINITY)) {
tmp = ((100.0 * pow((i / n), n)) + -100.0) / (i / n);
} else {
tmp = 100.0 / (((i / n) * -0.5) + (1.0 / n));
}
return tmp;
}
public static double code(double i, double n) {
double t_0 = (Math.pow((1.0 + (i / n)), n) + -1.0) / (i / n);
double tmp;
if (t_0 <= 5e-292) {
tmp = 100.0 / ((i / n) / Math.expm1((n * Math.log1p((i / n)))));
} else if (t_0 <= Double.POSITIVE_INFINITY) {
tmp = ((100.0 * Math.pow((i / n), n)) + -100.0) / (i / n);
} else {
tmp = 100.0 / (((i / n) * -0.5) + (1.0 / n));
}
return tmp;
}
def code(i, n): t_0 = (math.pow((1.0 + (i / n)), n) + -1.0) / (i / n) tmp = 0 if t_0 <= 5e-292: tmp = 100.0 / ((i / n) / math.expm1((n * math.log1p((i / n))))) elif t_0 <= math.inf: tmp = ((100.0 * math.pow((i / n), n)) + -100.0) / (i / n) else: tmp = 100.0 / (((i / n) * -0.5) + (1.0 / n)) return tmp
function code(i, n) t_0 = Float64(Float64((Float64(1.0 + Float64(i / n)) ^ n) + -1.0) / Float64(i / n)) tmp = 0.0 if (t_0 <= 5e-292) tmp = Float64(100.0 / Float64(Float64(i / n) / expm1(Float64(n * log1p(Float64(i / n)))))); elseif (t_0 <= Inf) tmp = Float64(Float64(Float64(100.0 * (Float64(i / n) ^ n)) + -100.0) / Float64(i / n)); else tmp = Float64(100.0 / Float64(Float64(Float64(i / n) * -0.5) + Float64(1.0 / n))); end return tmp end
code[i_, n_] := Block[{t$95$0 = N[(N[(N[Power[N[(1.0 + N[(i / n), $MachinePrecision]), $MachinePrecision], n], $MachinePrecision] + -1.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, 5e-292], N[(100.0 / N[(N[(i / n), $MachinePrecision] / N[(Exp[N[(n * N[Log[1 + N[(i / n), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, Infinity], N[(N[(N[(100.0 * N[Power[N[(i / n), $MachinePrecision], n], $MachinePrecision]), $MachinePrecision] + -100.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision], N[(100.0 / N[(N[(N[(i / n), $MachinePrecision] * -0.5), $MachinePrecision] + N[(1.0 / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{{\left(1 + \frac{i}{n}\right)}^{n} + -1}{\frac{i}{n}}\\
\mathbf{if}\;t\_0 \leq 5 \cdot 10^{-292}:\\
\;\;\;\;\frac{100}{\frac{\frac{i}{n}}{\mathsf{expm1}\left(n \cdot \mathsf{log1p}\left(\frac{i}{n}\right)\right)}}\\
\mathbf{elif}\;t\_0 \leq \infty:\\
\;\;\;\;\frac{100 \cdot {\left(\frac{i}{n}\right)}^{n} + -100}{\frac{i}{n}}\\
\mathbf{else}:\\
\;\;\;\;\frac{100}{\frac{i}{n} \cdot -0.5 + \frac{1}{n}}\\
\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)) < 4.99999999999999981e-292Initial program 22.4%
associate-/r/22.0%
associate-*r*22.0%
*-commutative22.0%
associate-*r/22.0%
sub-neg22.0%
distribute-lft-in22.0%
metadata-eval22.0%
metadata-eval22.0%
metadata-eval22.0%
fma-define22.0%
metadata-eval22.0%
Simplified22.0%
*-commutative22.0%
fma-undefine22.0%
*-commutative22.0%
associate-/r/22.4%
metadata-eval22.4%
metadata-eval22.4%
distribute-rgt-in22.4%
sub-neg22.4%
associate-*r/22.4%
clear-num22.4%
un-div-inv22.4%
add-exp-log22.4%
expm1-define22.4%
log-pow32.3%
log1p-define97.3%
Applied egg-rr97.3%
if 4.99999999999999981e-292 < (/.f64 (-.f64 (pow.f64 (+.f64 #s(literal 1 binary64) (/.f64 i n)) n) #s(literal 1 binary64)) (/.f64 i n)) < +inf.0Initial program 97.7%
associate-*r/97.8%
sub-neg97.8%
distribute-rgt-in97.8%
metadata-eval97.8%
metadata-eval97.8%
Simplified97.8%
Taylor expanded in i around inf 97.8%
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%
*-commutative1.8%
fma-undefine1.8%
*-commutative1.8%
associate-/r/0.0%
metadata-eval0.0%
metadata-eval0.0%
distribute-rgt-in0.0%
sub-neg0.0%
associate-*r/0.0%
clear-num0.0%
un-div-inv0.0%
add-exp-log0.0%
expm1-define0.0%
log-pow0.0%
log1p-define0.0%
Applied egg-rr0.0%
Taylor expanded in n around inf 0.0%
expm1-define5.3%
Simplified5.3%
Taylor expanded in i around 0 99.5%
Final simplification97.8%
(FPCore (i n)
:precision binary64
(let* ((t_0 (+ (pow (+ 1.0 (/ i n)) n) -1.0)) (t_1 (/ t_0 (/ i n))))
(if (<= t_1 0.0)
(* n (* 100.0 (/ (expm1 i) i)))
(if (<= t_1 INFINITY)
(/ 100.0 (/ (/ i n) t_0))
(/ 100.0 (+ (* (/ i n) -0.5) (/ 1.0 n)))))))
double code(double i, double n) {
double t_0 = pow((1.0 + (i / n)), n) + -1.0;
double t_1 = t_0 / (i / n);
double tmp;
if (t_1 <= 0.0) {
tmp = n * (100.0 * (expm1(i) / i));
} else if (t_1 <= ((double) INFINITY)) {
tmp = 100.0 / ((i / n) / t_0);
} else {
tmp = 100.0 / (((i / n) * -0.5) + (1.0 / n));
}
return tmp;
}
public static double code(double i, double n) {
double t_0 = Math.pow((1.0 + (i / n)), n) + -1.0;
double t_1 = t_0 / (i / n);
double tmp;
if (t_1 <= 0.0) {
tmp = n * (100.0 * (Math.expm1(i) / i));
} else if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = 100.0 / ((i / n) / t_0);
} else {
tmp = 100.0 / (((i / n) * -0.5) + (1.0 / n));
}
return tmp;
}
def code(i, n): t_0 = math.pow((1.0 + (i / n)), n) + -1.0 t_1 = t_0 / (i / n) tmp = 0 if t_1 <= 0.0: tmp = n * (100.0 * (math.expm1(i) / i)) elif t_1 <= math.inf: tmp = 100.0 / ((i / n) / t_0) else: tmp = 100.0 / (((i / n) * -0.5) + (1.0 / n)) return tmp
function code(i, n) t_0 = Float64((Float64(1.0 + Float64(i / n)) ^ n) + -1.0) t_1 = Float64(t_0 / Float64(i / n)) tmp = 0.0 if (t_1 <= 0.0) tmp = Float64(n * Float64(100.0 * Float64(expm1(i) / i))); elseif (t_1 <= Inf) tmp = Float64(100.0 / Float64(Float64(i / n) / t_0)); else tmp = Float64(100.0 / Float64(Float64(Float64(i / n) * -0.5) + Float64(1.0 / n))); end return tmp end
code[i_, n_] := Block[{t$95$0 = N[(N[Power[N[(1.0 + N[(i / n), $MachinePrecision]), $MachinePrecision], n], $MachinePrecision] + -1.0), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 / N[(i / n), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 0.0], N[(n * N[(100.0 * N[(N[(Exp[i] - 1), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(100.0 / N[(N[(i / n), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision], N[(100.0 / N[(N[(N[(i / n), $MachinePrecision] * -0.5), $MachinePrecision] + N[(1.0 / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {\left(1 + \frac{i}{n}\right)}^{n} + -1\\
t_1 := \frac{t\_0}{\frac{i}{n}}\\
\mathbf{if}\;t\_1 \leq 0:\\
\;\;\;\;n \cdot \left(100 \cdot \frac{\mathsf{expm1}\left(i\right)}{i}\right)\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\frac{100}{\frac{\frac{i}{n}}{t\_0}}\\
\mathbf{else}:\\
\;\;\;\;\frac{100}{\frac{i}{n} \cdot -0.5 + \frac{1}{n}}\\
\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)) < 0.0Initial program 22.1%
associate-/r/21.7%
associate-*r*21.7%
*-commutative21.7%
associate-*r/21.7%
sub-neg21.7%
distribute-lft-in21.7%
metadata-eval21.7%
metadata-eval21.7%
metadata-eval21.7%
fma-define21.7%
metadata-eval21.7%
Simplified21.7%
Taylor expanded in n around inf 38.4%
associate-/l*38.4%
sub-neg38.4%
metadata-eval38.4%
metadata-eval38.4%
distribute-lft-in38.3%
metadata-eval38.3%
sub-neg38.3%
associate-*r/38.3%
*-commutative38.3%
expm1-define77.3%
Simplified77.3%
if 0.0 < (/.f64 (-.f64 (pow.f64 (+.f64 #s(literal 1 binary64) (/.f64 i n)) n) #s(literal 1 binary64)) (/.f64 i n)) < +inf.0Initial program 96.5%
associate-/r/96.6%
associate-*r*96.5%
*-commutative96.5%
associate-*r/96.5%
sub-neg96.5%
distribute-lft-in96.2%
metadata-eval96.2%
metadata-eval96.2%
metadata-eval96.2%
fma-define96.5%
metadata-eval96.5%
Simplified96.5%
*-commutative96.5%
fma-undefine96.2%
*-commutative96.2%
associate-/r/96.3%
metadata-eval96.3%
metadata-eval96.3%
distribute-rgt-in96.6%
sub-neg96.6%
associate-*r/96.5%
clear-num96.5%
un-div-inv96.6%
add-exp-log96.6%
expm1-define96.6%
log-pow60.7%
log1p-define60.7%
Applied egg-rr60.7%
expm1-undefine57.7%
*-commutative57.7%
log1p-undefine57.7%
pow-to-exp96.6%
+-commutative96.6%
Applied egg-rr96.6%
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%
*-commutative1.8%
fma-undefine1.8%
*-commutative1.8%
associate-/r/0.0%
metadata-eval0.0%
metadata-eval0.0%
distribute-rgt-in0.0%
sub-neg0.0%
associate-*r/0.0%
clear-num0.0%
un-div-inv0.0%
add-exp-log0.0%
expm1-define0.0%
log-pow0.0%
log1p-define0.0%
Applied egg-rr0.0%
Taylor expanded in n around inf 0.0%
expm1-define5.3%
Simplified5.3%
Taylor expanded in i around 0 99.5%
Final simplification83.4%
(FPCore (i n)
:precision binary64
(let* ((t_0 (/ (+ (pow (+ 1.0 (/ i n)) n) -1.0) (/ i n))))
(if (<= t_0 5e-292)
(* n (/ (* 100.0 (expm1 (* n (log1p (/ i n))))) i))
(if (<= t_0 INFINITY)
(/ (+ (* 100.0 (pow (/ i n) n)) -100.0) (/ i n))
(/ 100.0 (+ (* (/ i n) -0.5) (/ 1.0 n)))))))
double code(double i, double n) {
double t_0 = (pow((1.0 + (i / n)), n) + -1.0) / (i / n);
double tmp;
if (t_0 <= 5e-292) {
tmp = n * ((100.0 * expm1((n * log1p((i / n))))) / i);
} else if (t_0 <= ((double) INFINITY)) {
tmp = ((100.0 * pow((i / n), n)) + -100.0) / (i / n);
} else {
tmp = 100.0 / (((i / n) * -0.5) + (1.0 / n));
}
return tmp;
}
public static double code(double i, double n) {
double t_0 = (Math.pow((1.0 + (i / n)), n) + -1.0) / (i / n);
double tmp;
if (t_0 <= 5e-292) {
tmp = n * ((100.0 * Math.expm1((n * Math.log1p((i / n))))) / i);
} else if (t_0 <= Double.POSITIVE_INFINITY) {
tmp = ((100.0 * Math.pow((i / n), n)) + -100.0) / (i / n);
} else {
tmp = 100.0 / (((i / n) * -0.5) + (1.0 / n));
}
return tmp;
}
def code(i, n): t_0 = (math.pow((1.0 + (i / n)), n) + -1.0) / (i / n) tmp = 0 if t_0 <= 5e-292: tmp = n * ((100.0 * math.expm1((n * math.log1p((i / n))))) / i) elif t_0 <= math.inf: tmp = ((100.0 * math.pow((i / n), n)) + -100.0) / (i / n) else: tmp = 100.0 / (((i / n) * -0.5) + (1.0 / n)) return tmp
function code(i, n) t_0 = Float64(Float64((Float64(1.0 + Float64(i / n)) ^ n) + -1.0) / Float64(i / n)) tmp = 0.0 if (t_0 <= 5e-292) tmp = Float64(n * Float64(Float64(100.0 * expm1(Float64(n * log1p(Float64(i / n))))) / i)); elseif (t_0 <= Inf) tmp = Float64(Float64(Float64(100.0 * (Float64(i / n) ^ n)) + -100.0) / Float64(i / n)); else tmp = Float64(100.0 / Float64(Float64(Float64(i / n) * -0.5) + Float64(1.0 / n))); end return tmp end
code[i_, n_] := Block[{t$95$0 = N[(N[(N[Power[N[(1.0 + N[(i / n), $MachinePrecision]), $MachinePrecision], n], $MachinePrecision] + -1.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, 5e-292], N[(n * N[(N[(100.0 * N[(Exp[N[(n * N[Log[1 + N[(i / n), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, Infinity], N[(N[(N[(100.0 * N[Power[N[(i / n), $MachinePrecision], n], $MachinePrecision]), $MachinePrecision] + -100.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision], N[(100.0 / N[(N[(N[(i / n), $MachinePrecision] * -0.5), $MachinePrecision] + N[(1.0 / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{{\left(1 + \frac{i}{n}\right)}^{n} + -1}{\frac{i}{n}}\\
\mathbf{if}\;t\_0 \leq 5 \cdot 10^{-292}:\\
\;\;\;\;n \cdot \frac{100 \cdot \mathsf{expm1}\left(n \cdot \mathsf{log1p}\left(\frac{i}{n}\right)\right)}{i}\\
\mathbf{elif}\;t\_0 \leq \infty:\\
\;\;\;\;\frac{100 \cdot {\left(\frac{i}{n}\right)}^{n} + -100}{\frac{i}{n}}\\
\mathbf{else}:\\
\;\;\;\;\frac{100}{\frac{i}{n} \cdot -0.5 + \frac{1}{n}}\\
\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)) < 4.99999999999999981e-292Initial program 22.4%
associate-/r/22.0%
associate-*r*22.0%
*-commutative22.0%
associate-*r/22.0%
sub-neg22.0%
distribute-lft-in22.0%
metadata-eval22.0%
metadata-eval22.0%
metadata-eval22.0%
fma-define22.0%
metadata-eval22.0%
Simplified22.0%
fma-undefine22.0%
metadata-eval22.0%
metadata-eval22.0%
distribute-lft-in22.0%
sub-neg22.0%
*-commutative22.0%
add-exp-log22.0%
expm1-define22.0%
log-pow32.7%
log1p-define96.6%
Applied egg-rr96.6%
if 4.99999999999999981e-292 < (/.f64 (-.f64 (pow.f64 (+.f64 #s(literal 1 binary64) (/.f64 i n)) n) #s(literal 1 binary64)) (/.f64 i n)) < +inf.0Initial program 97.7%
associate-*r/97.8%
sub-neg97.8%
distribute-rgt-in97.8%
metadata-eval97.8%
metadata-eval97.8%
Simplified97.8%
Taylor expanded in i around inf 97.8%
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%
*-commutative1.8%
fma-undefine1.8%
*-commutative1.8%
associate-/r/0.0%
metadata-eval0.0%
metadata-eval0.0%
distribute-rgt-in0.0%
sub-neg0.0%
associate-*r/0.0%
clear-num0.0%
un-div-inv0.0%
add-exp-log0.0%
expm1-define0.0%
log-pow0.0%
log1p-define0.0%
Applied egg-rr0.0%
Taylor expanded in n around inf 0.0%
expm1-define5.3%
Simplified5.3%
Taylor expanded in i around 0 99.5%
Final simplification97.2%
(FPCore (i n)
:precision binary64
(let* ((t_0 (/ (+ (pow (+ 1.0 (/ i n)) n) -1.0) (/ i n))))
(if (<= t_0 0.0)
(* n (* 100.0 (/ (expm1 i) i)))
(if (<= t_0 INFINITY)
(* 100.0 (/ (* n (+ (pow (/ i n) n) -1.0)) i))
(/ 100.0 (+ (* (/ i n) -0.5) (/ 1.0 n)))))))
double code(double i, double n) {
double t_0 = (pow((1.0 + (i / n)), n) + -1.0) / (i / n);
double tmp;
if (t_0 <= 0.0) {
tmp = n * (100.0 * (expm1(i) / i));
} else if (t_0 <= ((double) INFINITY)) {
tmp = 100.0 * ((n * (pow((i / n), n) + -1.0)) / i);
} else {
tmp = 100.0 / (((i / n) * -0.5) + (1.0 / n));
}
return tmp;
}
public static double code(double i, double n) {
double t_0 = (Math.pow((1.0 + (i / n)), n) + -1.0) / (i / n);
double tmp;
if (t_0 <= 0.0) {
tmp = n * (100.0 * (Math.expm1(i) / i));
} else if (t_0 <= Double.POSITIVE_INFINITY) {
tmp = 100.0 * ((n * (Math.pow((i / n), n) + -1.0)) / i);
} else {
tmp = 100.0 / (((i / n) * -0.5) + (1.0 / n));
}
return tmp;
}
def code(i, n): t_0 = (math.pow((1.0 + (i / n)), n) + -1.0) / (i / n) tmp = 0 if t_0 <= 0.0: tmp = n * (100.0 * (math.expm1(i) / i)) elif t_0 <= math.inf: tmp = 100.0 * ((n * (math.pow((i / n), n) + -1.0)) / i) else: tmp = 100.0 / (((i / n) * -0.5) + (1.0 / n)) return tmp
function code(i, n) t_0 = Float64(Float64((Float64(1.0 + Float64(i / n)) ^ n) + -1.0) / Float64(i / n)) tmp = 0.0 if (t_0 <= 0.0) tmp = Float64(n * Float64(100.0 * Float64(expm1(i) / i))); elseif (t_0 <= Inf) tmp = Float64(100.0 * Float64(Float64(n * Float64((Float64(i / n) ^ n) + -1.0)) / i)); else tmp = Float64(100.0 / Float64(Float64(Float64(i / n) * -0.5) + Float64(1.0 / n))); end return tmp end
code[i_, n_] := Block[{t$95$0 = N[(N[(N[Power[N[(1.0 + N[(i / n), $MachinePrecision]), $MachinePrecision], n], $MachinePrecision] + -1.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, 0.0], N[(n * N[(100.0 * N[(N[(Exp[i] - 1), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, Infinity], N[(100.0 * N[(N[(n * N[(N[Power[N[(i / n), $MachinePrecision], n], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision], N[(100.0 / N[(N[(N[(i / n), $MachinePrecision] * -0.5), $MachinePrecision] + N[(1.0 / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{{\left(1 + \frac{i}{n}\right)}^{n} + -1}{\frac{i}{n}}\\
\mathbf{if}\;t\_0 \leq 0:\\
\;\;\;\;n \cdot \left(100 \cdot \frac{\mathsf{expm1}\left(i\right)}{i}\right)\\
\mathbf{elif}\;t\_0 \leq \infty:\\
\;\;\;\;100 \cdot \frac{n \cdot \left({\left(\frac{i}{n}\right)}^{n} + -1\right)}{i}\\
\mathbf{else}:\\
\;\;\;\;\frac{100}{\frac{i}{n} \cdot -0.5 + \frac{1}{n}}\\
\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)) < 0.0Initial program 22.1%
associate-/r/21.7%
associate-*r*21.7%
*-commutative21.7%
associate-*r/21.7%
sub-neg21.7%
distribute-lft-in21.7%
metadata-eval21.7%
metadata-eval21.7%
metadata-eval21.7%
fma-define21.7%
metadata-eval21.7%
Simplified21.7%
Taylor expanded in n around inf 38.4%
associate-/l*38.4%
sub-neg38.4%
metadata-eval38.4%
metadata-eval38.4%
distribute-lft-in38.3%
metadata-eval38.3%
sub-neg38.3%
associate-*r/38.3%
*-commutative38.3%
expm1-define77.3%
Simplified77.3%
if 0.0 < (/.f64 (-.f64 (pow.f64 (+.f64 #s(literal 1 binary64) (/.f64 i n)) n) #s(literal 1 binary64)) (/.f64 i n)) < +inf.0Initial program 96.5%
clear-num96.5%
inv-pow96.5%
Applied egg-rr96.5%
unpow-196.5%
Simplified96.5%
Taylor expanded in i around inf 96.5%
Taylor expanded in n around inf 96.6%
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%
*-commutative1.8%
fma-undefine1.8%
*-commutative1.8%
associate-/r/0.0%
metadata-eval0.0%
metadata-eval0.0%
distribute-rgt-in0.0%
sub-neg0.0%
associate-*r/0.0%
clear-num0.0%
un-div-inv0.0%
add-exp-log0.0%
expm1-define0.0%
log-pow0.0%
log1p-define0.0%
Applied egg-rr0.0%
Taylor expanded in n around inf 0.0%
expm1-define5.3%
Simplified5.3%
Taylor expanded in i around 0 99.5%
Final simplification83.4%
(FPCore (i n)
:precision binary64
(let* ((t_0 (/ (+ (pow (+ 1.0 (/ i n)) n) -1.0) (/ i n))))
(if (<= t_0 0.0)
(* n (* 100.0 (/ (expm1 i) i)))
(if (<= t_0 INFINITY)
(* 100.0 (- (pow (/ i n) (+ n -1.0)) (/ n i)))
(/ 100.0 (+ (* (/ i n) -0.5) (/ 1.0 n)))))))
double code(double i, double n) {
double t_0 = (pow((1.0 + (i / n)), n) + -1.0) / (i / n);
double tmp;
if (t_0 <= 0.0) {
tmp = n * (100.0 * (expm1(i) / i));
} else if (t_0 <= ((double) INFINITY)) {
tmp = 100.0 * (pow((i / n), (n + -1.0)) - (n / i));
} else {
tmp = 100.0 / (((i / n) * -0.5) + (1.0 / n));
}
return tmp;
}
public static double code(double i, double n) {
double t_0 = (Math.pow((1.0 + (i / n)), n) + -1.0) / (i / n);
double tmp;
if (t_0 <= 0.0) {
tmp = n * (100.0 * (Math.expm1(i) / i));
} else if (t_0 <= Double.POSITIVE_INFINITY) {
tmp = 100.0 * (Math.pow((i / n), (n + -1.0)) - (n / i));
} else {
tmp = 100.0 / (((i / n) * -0.5) + (1.0 / n));
}
return tmp;
}
def code(i, n): t_0 = (math.pow((1.0 + (i / n)), n) + -1.0) / (i / n) tmp = 0 if t_0 <= 0.0: tmp = n * (100.0 * (math.expm1(i) / i)) elif t_0 <= math.inf: tmp = 100.0 * (math.pow((i / n), (n + -1.0)) - (n / i)) else: tmp = 100.0 / (((i / n) * -0.5) + (1.0 / n)) return tmp
function code(i, n) t_0 = Float64(Float64((Float64(1.0 + Float64(i / n)) ^ n) + -1.0) / Float64(i / n)) tmp = 0.0 if (t_0 <= 0.0) tmp = Float64(n * Float64(100.0 * Float64(expm1(i) / i))); elseif (t_0 <= Inf) tmp = Float64(100.0 * Float64((Float64(i / n) ^ Float64(n + -1.0)) - Float64(n / i))); else tmp = Float64(100.0 / Float64(Float64(Float64(i / n) * -0.5) + Float64(1.0 / n))); end return tmp end
code[i_, n_] := Block[{t$95$0 = N[(N[(N[Power[N[(1.0 + N[(i / n), $MachinePrecision]), $MachinePrecision], n], $MachinePrecision] + -1.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, 0.0], N[(n * N[(100.0 * N[(N[(Exp[i] - 1), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, Infinity], N[(100.0 * N[(N[Power[N[(i / n), $MachinePrecision], N[(n + -1.0), $MachinePrecision]], $MachinePrecision] - N[(n / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(100.0 / N[(N[(N[(i / n), $MachinePrecision] * -0.5), $MachinePrecision] + N[(1.0 / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{{\left(1 + \frac{i}{n}\right)}^{n} + -1}{\frac{i}{n}}\\
\mathbf{if}\;t\_0 \leq 0:\\
\;\;\;\;n \cdot \left(100 \cdot \frac{\mathsf{expm1}\left(i\right)}{i}\right)\\
\mathbf{elif}\;t\_0 \leq \infty:\\
\;\;\;\;100 \cdot \left({\left(\frac{i}{n}\right)}^{\left(n + -1\right)} - \frac{n}{i}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{100}{\frac{i}{n} \cdot -0.5 + \frac{1}{n}}\\
\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)) < 0.0Initial program 22.1%
associate-/r/21.7%
associate-*r*21.7%
*-commutative21.7%
associate-*r/21.7%
sub-neg21.7%
distribute-lft-in21.7%
metadata-eval21.7%
metadata-eval21.7%
metadata-eval21.7%
fma-define21.7%
metadata-eval21.7%
Simplified21.7%
Taylor expanded in n around inf 38.4%
associate-/l*38.4%
sub-neg38.4%
metadata-eval38.4%
metadata-eval38.4%
distribute-lft-in38.3%
metadata-eval38.3%
sub-neg38.3%
associate-*r/38.3%
*-commutative38.3%
expm1-define77.3%
Simplified77.3%
if 0.0 < (/.f64 (-.f64 (pow.f64 (+.f64 #s(literal 1 binary64) (/.f64 i n)) n) #s(literal 1 binary64)) (/.f64 i n)) < +inf.0Initial program 96.5%
clear-num96.5%
inv-pow96.5%
Applied egg-rr96.5%
unpow-196.5%
Simplified96.5%
Taylor expanded in i around inf 96.5%
div-sub96.2%
clear-num96.0%
pow196.0%
pow-div94.9%
remove-double-div94.9%
Applied egg-rr94.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%
*-commutative1.8%
fma-undefine1.8%
*-commutative1.8%
associate-/r/0.0%
metadata-eval0.0%
metadata-eval0.0%
distribute-rgt-in0.0%
sub-neg0.0%
associate-*r/0.0%
clear-num0.0%
un-div-inv0.0%
add-exp-log0.0%
expm1-define0.0%
log-pow0.0%
log1p-define0.0%
Applied egg-rr0.0%
Taylor expanded in n around inf 0.0%
expm1-define5.3%
Simplified5.3%
Taylor expanded in i around 0 99.5%
Final simplification83.2%
(FPCore (i n) :precision binary64 (if (<= (/ (+ (pow (+ 1.0 (/ i n)) n) -1.0) (/ i n)) INFINITY) (* 100.0 (/ (expm1 i) (/ i n))) (/ 100.0 (+ (* (/ i n) -0.5) (/ 1.0 n)))))
double code(double i, double n) {
double tmp;
if (((pow((1.0 + (i / n)), n) + -1.0) / (i / n)) <= ((double) INFINITY)) {
tmp = 100.0 * (expm1(i) / (i / n));
} else {
tmp = 100.0 / (((i / n) * -0.5) + (1.0 / n));
}
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 = 100.0 * (Math.expm1(i) / (i / n));
} else {
tmp = 100.0 / (((i / n) * -0.5) + (1.0 / n));
}
return tmp;
}
def code(i, n): tmp = 0 if ((math.pow((1.0 + (i / n)), n) + -1.0) / (i / n)) <= math.inf: tmp = 100.0 * (math.expm1(i) / (i / n)) else: tmp = 100.0 / (((i / n) * -0.5) + (1.0 / n)) 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(100.0 * Float64(expm1(i) / Float64(i / n))); else tmp = Float64(100.0 / Float64(Float64(Float64(i / n) * -0.5) + Float64(1.0 / n))); 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[(100.0 * N[(N[(Exp[i] - 1), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(100.0 / N[(N[(N[(i / n), $MachinePrecision] * -0.5), $MachinePrecision] + N[(1.0 / n), $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:\\
\;\;\;\;100 \cdot \frac{\mathsf{expm1}\left(i\right)}{\frac{i}{n}}\\
\mathbf{else}:\\
\;\;\;\;\frac{100}{\frac{i}{n} \cdot -0.5 + \frac{1}{n}}\\
\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 30.4%
Taylor expanded in n around inf 39.8%
expm1-define73.3%
Simplified73.3%
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%
*-commutative1.8%
fma-undefine1.8%
*-commutative1.8%
associate-/r/0.0%
metadata-eval0.0%
metadata-eval0.0%
distribute-rgt-in0.0%
sub-neg0.0%
associate-*r/0.0%
clear-num0.0%
un-div-inv0.0%
add-exp-log0.0%
expm1-define0.0%
log-pow0.0%
log1p-define0.0%
Applied egg-rr0.0%
Taylor expanded in n around inf 0.0%
expm1-define5.3%
Simplified5.3%
Taylor expanded in i around 0 99.5%
Final simplification78.4%
(FPCore (i n)
:precision binary64
(if (or (<= n -3.1e-25) (not (<= n 1.35)))
(* n (* 100.0 (/ (expm1 i) i)))
(/
100.0
(+
(/ 1.0 n)
(* i (+ (* (/ i n) 0.08333333333333333) (* 0.5 (/ -1.0 n))))))))
double code(double i, double n) {
double tmp;
if ((n <= -3.1e-25) || !(n <= 1.35)) {
tmp = n * (100.0 * (expm1(i) / i));
} else {
tmp = 100.0 / ((1.0 / n) + (i * (((i / n) * 0.08333333333333333) + (0.5 * (-1.0 / n)))));
}
return tmp;
}
public static double code(double i, double n) {
double tmp;
if ((n <= -3.1e-25) || !(n <= 1.35)) {
tmp = n * (100.0 * (Math.expm1(i) / i));
} else {
tmp = 100.0 / ((1.0 / n) + (i * (((i / n) * 0.08333333333333333) + (0.5 * (-1.0 / n)))));
}
return tmp;
}
def code(i, n): tmp = 0 if (n <= -3.1e-25) or not (n <= 1.35): tmp = n * (100.0 * (math.expm1(i) / i)) else: tmp = 100.0 / ((1.0 / n) + (i * (((i / n) * 0.08333333333333333) + (0.5 * (-1.0 / n))))) return tmp
function code(i, n) tmp = 0.0 if ((n <= -3.1e-25) || !(n <= 1.35)) tmp = Float64(n * Float64(100.0 * Float64(expm1(i) / i))); else tmp = Float64(100.0 / Float64(Float64(1.0 / n) + Float64(i * Float64(Float64(Float64(i / n) * 0.08333333333333333) + Float64(0.5 * Float64(-1.0 / n)))))); end return tmp end
code[i_, n_] := If[Or[LessEqual[n, -3.1e-25], N[Not[LessEqual[n, 1.35]], $MachinePrecision]], N[(n * N[(100.0 * N[(N[(Exp[i] - 1), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(100.0 / N[(N[(1.0 / n), $MachinePrecision] + N[(i * N[(N[(N[(i / n), $MachinePrecision] * 0.08333333333333333), $MachinePrecision] + N[(0.5 * N[(-1.0 / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -3.1 \cdot 10^{-25} \lor \neg \left(n \leq 1.35\right):\\
\;\;\;\;n \cdot \left(100 \cdot \frac{\mathsf{expm1}\left(i\right)}{i}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{100}{\frac{1}{n} + i \cdot \left(\frac{i}{n} \cdot 0.08333333333333333 + 0.5 \cdot \frac{-1}{n}\right)}\\
\end{array}
\end{array}
if n < -3.09999999999999995e-25 or 1.3500000000000001 < n Initial program 20.0%
associate-/r/20.4%
associate-*r*20.4%
*-commutative20.4%
associate-*r/20.4%
sub-neg20.4%
distribute-lft-in20.4%
metadata-eval20.4%
metadata-eval20.4%
metadata-eval20.4%
fma-define20.4%
metadata-eval20.4%
Simplified20.4%
Taylor expanded in n around inf 38.7%
associate-/l*38.7%
sub-neg38.7%
metadata-eval38.7%
metadata-eval38.7%
distribute-lft-in38.6%
metadata-eval38.6%
sub-neg38.6%
associate-*r/38.5%
*-commutative38.5%
expm1-define91.4%
Simplified91.4%
if -3.09999999999999995e-25 < n < 1.3500000000000001Initial program 32.1%
associate-/r/31.6%
associate-*r*31.6%
*-commutative31.6%
associate-*r/31.6%
sub-neg31.6%
distribute-lft-in31.5%
metadata-eval31.5%
metadata-eval31.5%
metadata-eval31.5%
fma-define31.6%
metadata-eval31.6%
Simplified31.6%
*-commutative31.6%
fma-undefine31.5%
*-commutative31.5%
associate-/r/32.1%
metadata-eval32.1%
metadata-eval32.1%
distribute-rgt-in32.1%
sub-neg32.1%
associate-*r/32.1%
clear-num32.1%
un-div-inv32.1%
add-exp-log32.1%
expm1-define32.1%
log-pow53.7%
log1p-define85.5%
Applied egg-rr85.5%
Taylor expanded in n around inf 21.7%
expm1-define46.5%
Simplified46.5%
Taylor expanded in i around 0 66.6%
Final simplification82.2%
(FPCore (i n)
:precision binary64
(if (or (<= n -1.15e+49) (not (<= n 0.66)))
(* n (* (expm1 i) (/ 100.0 i)))
(/
100.0
(+
(/ 1.0 n)
(* i (+ (* (/ i n) 0.08333333333333333) (* 0.5 (/ -1.0 n))))))))
double code(double i, double n) {
double tmp;
if ((n <= -1.15e+49) || !(n <= 0.66)) {
tmp = n * (expm1(i) * (100.0 / i));
} else {
tmp = 100.0 / ((1.0 / n) + (i * (((i / n) * 0.08333333333333333) + (0.5 * (-1.0 / n)))));
}
return tmp;
}
public static double code(double i, double n) {
double tmp;
if ((n <= -1.15e+49) || !(n <= 0.66)) {
tmp = n * (Math.expm1(i) * (100.0 / i));
} else {
tmp = 100.0 / ((1.0 / n) + (i * (((i / n) * 0.08333333333333333) + (0.5 * (-1.0 / n)))));
}
return tmp;
}
def code(i, n): tmp = 0 if (n <= -1.15e+49) or not (n <= 0.66): tmp = n * (math.expm1(i) * (100.0 / i)) else: tmp = 100.0 / ((1.0 / n) + (i * (((i / n) * 0.08333333333333333) + (0.5 * (-1.0 / n))))) return tmp
function code(i, n) tmp = 0.0 if ((n <= -1.15e+49) || !(n <= 0.66)) tmp = Float64(n * Float64(expm1(i) * Float64(100.0 / i))); else tmp = Float64(100.0 / Float64(Float64(1.0 / n) + Float64(i * Float64(Float64(Float64(i / n) * 0.08333333333333333) + Float64(0.5 * Float64(-1.0 / n)))))); end return tmp end
code[i_, n_] := If[Or[LessEqual[n, -1.15e+49], N[Not[LessEqual[n, 0.66]], $MachinePrecision]], N[(n * N[(N[(Exp[i] - 1), $MachinePrecision] * N[(100.0 / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(100.0 / N[(N[(1.0 / n), $MachinePrecision] + N[(i * N[(N[(N[(i / n), $MachinePrecision] * 0.08333333333333333), $MachinePrecision] + N[(0.5 * N[(-1.0 / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -1.15 \cdot 10^{+49} \lor \neg \left(n \leq 0.66\right):\\
\;\;\;\;n \cdot \left(\mathsf{expm1}\left(i\right) \cdot \frac{100}{i}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{100}{\frac{1}{n} + i \cdot \left(\frac{i}{n} \cdot 0.08333333333333333 + 0.5 \cdot \frac{-1}{n}\right)}\\
\end{array}
\end{array}
if n < -1.15000000000000001e49 or 0.660000000000000031 < n Initial program 19.8%
associate-/r/20.3%
associate-*r*20.3%
*-commutative20.3%
associate-*r/20.3%
sub-neg20.3%
distribute-lft-in20.3%
metadata-eval20.3%
metadata-eval20.3%
metadata-eval20.3%
fma-define20.3%
metadata-eval20.3%
Simplified20.3%
Taylor expanded in n around inf 41.6%
associate-/l*41.6%
sub-neg41.6%
metadata-eval41.6%
metadata-eval41.6%
distribute-lft-in41.5%
metadata-eval41.5%
sub-neg41.5%
associate-*r/41.5%
*-commutative41.5%
expm1-define93.1%
Simplified93.1%
pow193.1%
*-commutative93.1%
clear-num93.1%
un-div-inv93.1%
Applied egg-rr93.1%
unpow193.1%
associate-/r/93.0%
Simplified93.0%
if -1.15000000000000001e49 < n < 0.660000000000000031Initial program 30.6%
associate-/r/30.2%
associate-*r*30.2%
*-commutative30.2%
associate-*r/30.1%
sub-neg30.1%
distribute-lft-in30.1%
metadata-eval30.1%
metadata-eval30.1%
metadata-eval30.1%
fma-define30.1%
metadata-eval30.1%
Simplified30.1%
*-commutative30.1%
fma-undefine30.1%
*-commutative30.1%
associate-/r/30.6%
metadata-eval30.6%
metadata-eval30.6%
distribute-rgt-in30.6%
sub-neg30.6%
associate-*r/30.6%
clear-num30.6%
un-div-inv30.6%
add-exp-log30.6%
expm1-define30.6%
log-pow48.3%
log1p-define84.9%
Applied egg-rr84.9%
Taylor expanded in n around inf 20.3%
expm1-define49.8%
Simplified49.8%
Taylor expanded in i around 0 67.9%
Final simplification82.1%
(FPCore (i n)
:precision binary64
(if (or (<= n -3.6e+105) (not (<= n 0.66)))
(*
n
(+
100.0
(* i (+ 50.0 (* i (+ 16.666666666666668 (* i 4.166666666666667)))))))
(/
100.0
(+
(/ 1.0 n)
(* i (+ (* (/ i n) 0.08333333333333333) (* 0.5 (/ -1.0 n))))))))
double code(double i, double n) {
double tmp;
if ((n <= -3.6e+105) || !(n <= 0.66)) {
tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667))))));
} else {
tmp = 100.0 / ((1.0 / n) + (i * (((i / n) * 0.08333333333333333) + (0.5 * (-1.0 / n)))));
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if ((n <= (-3.6d+105)) .or. (.not. (n <= 0.66d0))) then
tmp = n * (100.0d0 + (i * (50.0d0 + (i * (16.666666666666668d0 + (i * 4.166666666666667d0))))))
else
tmp = 100.0d0 / ((1.0d0 / n) + (i * (((i / n) * 0.08333333333333333d0) + (0.5d0 * ((-1.0d0) / n)))))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if ((n <= -3.6e+105) || !(n <= 0.66)) {
tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667))))));
} else {
tmp = 100.0 / ((1.0 / n) + (i * (((i / n) * 0.08333333333333333) + (0.5 * (-1.0 / n)))));
}
return tmp;
}
def code(i, n): tmp = 0 if (n <= -3.6e+105) or not (n <= 0.66): tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667)))))) else: tmp = 100.0 / ((1.0 / n) + (i * (((i / n) * 0.08333333333333333) + (0.5 * (-1.0 / n))))) return tmp
function code(i, n) tmp = 0.0 if ((n <= -3.6e+105) || !(n <= 0.66)) tmp = Float64(n * Float64(100.0 + Float64(i * Float64(50.0 + Float64(i * Float64(16.666666666666668 + Float64(i * 4.166666666666667))))))); else tmp = Float64(100.0 / Float64(Float64(1.0 / n) + Float64(i * Float64(Float64(Float64(i / n) * 0.08333333333333333) + Float64(0.5 * Float64(-1.0 / n)))))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if ((n <= -3.6e+105) || ~((n <= 0.66))) tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667)))))); else tmp = 100.0 / ((1.0 / n) + (i * (((i / n) * 0.08333333333333333) + (0.5 * (-1.0 / n))))); end tmp_2 = tmp; end
code[i_, n_] := If[Or[LessEqual[n, -3.6e+105], N[Not[LessEqual[n, 0.66]], $MachinePrecision]], 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], N[(100.0 / N[(N[(1.0 / n), $MachinePrecision] + N[(i * N[(N[(N[(i / n), $MachinePrecision] * 0.08333333333333333), $MachinePrecision] + N[(0.5 * N[(-1.0 / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -3.6 \cdot 10^{+105} \lor \neg \left(n \leq 0.66\right):\\
\;\;\;\;n \cdot \left(100 + i \cdot \left(50 + i \cdot \left(16.666666666666668 + i \cdot 4.166666666666667\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{100}{\frac{1}{n} + i \cdot \left(\frac{i}{n} \cdot 0.08333333333333333 + 0.5 \cdot \frac{-1}{n}\right)}\\
\end{array}
\end{array}
if n < -3.5999999999999999e105 or 0.660000000000000031 < n Initial program 16.6%
associate-/r/17.1%
associate-*r*17.1%
*-commutative17.1%
associate-*r/17.1%
sub-neg17.1%
distribute-lft-in17.1%
metadata-eval17.1%
metadata-eval17.1%
metadata-eval17.1%
fma-define17.1%
metadata-eval17.1%
Simplified17.1%
Taylor expanded in n around inf 43.1%
associate-/l*43.1%
sub-neg43.1%
metadata-eval43.1%
metadata-eval43.1%
distribute-lft-in43.1%
metadata-eval43.1%
sub-neg43.1%
associate-*r/43.0%
*-commutative43.0%
expm1-define95.3%
Simplified95.3%
Taylor expanded in i around 0 82.5%
*-commutative82.5%
Simplified82.5%
if -3.5999999999999999e105 < n < 0.660000000000000031Initial program 32.6%
associate-/r/32.3%
associate-*r*32.3%
*-commutative32.3%
associate-*r/32.3%
sub-neg32.3%
distribute-lft-in32.2%
metadata-eval32.2%
metadata-eval32.2%
metadata-eval32.2%
fma-define32.3%
metadata-eval32.3%
Simplified32.3%
*-commutative32.3%
fma-undefine32.2%
*-commutative32.2%
associate-/r/32.6%
metadata-eval32.6%
metadata-eval32.6%
distribute-rgt-in32.7%
sub-neg32.7%
associate-*r/32.6%
clear-num32.6%
un-div-inv32.7%
add-exp-log32.7%
expm1-define32.7%
log-pow45.1%
log1p-define82.7%
Applied egg-rr82.7%
Taylor expanded in n around inf 21.2%
expm1-define51.3%
Simplified51.3%
Taylor expanded in i around 0 65.7%
Final simplification74.2%
(FPCore (i n)
:precision binary64
(if (or (<= n -8.6e-106) (not (<= n 1e-126)))
(*
n
(+
100.0
(* i (+ 50.0 (* i (+ 16.666666666666668 (* i 4.166666666666667)))))))
0.0))
double code(double i, double n) {
double tmp;
if ((n <= -8.6e-106) || !(n <= 1e-126)) {
tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667))))));
} 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 <= (-8.6d-106)) .or. (.not. (n <= 1d-126))) then
tmp = n * (100.0d0 + (i * (50.0d0 + (i * (16.666666666666668d0 + (i * 4.166666666666667d0))))))
else
tmp = 0.0d0
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if ((n <= -8.6e-106) || !(n <= 1e-126)) {
tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667))))));
} else {
tmp = 0.0;
}
return tmp;
}
def code(i, n): tmp = 0 if (n <= -8.6e-106) or not (n <= 1e-126): tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667)))))) else: tmp = 0.0 return tmp
function code(i, n) tmp = 0.0 if ((n <= -8.6e-106) || !(n <= 1e-126)) tmp = Float64(n * Float64(100.0 + Float64(i * Float64(50.0 + Float64(i * Float64(16.666666666666668 + Float64(i * 4.166666666666667))))))); else tmp = 0.0; end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if ((n <= -8.6e-106) || ~((n <= 1e-126))) tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667)))))); else tmp = 0.0; end tmp_2 = tmp; end
code[i_, n_] := If[Or[LessEqual[n, -8.6e-106], N[Not[LessEqual[n, 1e-126]], $MachinePrecision]], 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], 0.0]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -8.6 \cdot 10^{-106} \lor \neg \left(n \leq 10^{-126}\right):\\
\;\;\;\;n \cdot \left(100 + i \cdot \left(50 + i \cdot \left(16.666666666666668 + i \cdot 4.166666666666667\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if n < -8.6000000000000004e-106 or 9.9999999999999995e-127 < n Initial program 18.5%
associate-/r/18.9%
associate-*r*18.9%
*-commutative18.9%
associate-*r/18.9%
sub-neg18.9%
distribute-lft-in18.8%
metadata-eval18.8%
metadata-eval18.8%
metadata-eval18.8%
fma-define18.9%
metadata-eval18.9%
Simplified18.9%
Taylor expanded in n around inf 31.9%
associate-/l*32.0%
sub-neg32.0%
metadata-eval32.0%
metadata-eval32.0%
distribute-lft-in31.9%
metadata-eval31.9%
sub-neg31.9%
associate-*r/31.8%
*-commutative31.8%
expm1-define85.7%
Simplified85.7%
Taylor expanded in i around 0 75.2%
*-commutative75.2%
Simplified75.2%
if -8.6000000000000004e-106 < n < 9.9999999999999995e-127Initial program 45.4%
associate-*r/45.4%
sub-neg45.4%
distribute-rgt-in45.4%
metadata-eval45.4%
metadata-eval45.4%
Simplified45.4%
Taylor expanded in i around 0 63.0%
Taylor expanded in i around 0 63.0%
Final simplification72.5%
(FPCore (i n) :precision binary64 (if (<= n -8.6e-106) (* n (+ 100.0 (* i (+ 50.0 (* i 16.666666666666668))))) (if (<= n 1.85e-135) 0.0 (* n (* 100.0 (/ (* i (+ 1.0 (* i 0.5))) i))))))
double code(double i, double n) {
double tmp;
if (n <= -8.6e-106) {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
} else if (n <= 1.85e-135) {
tmp = 0.0;
} else {
tmp = n * (100.0 * ((i * (1.0 + (i * 0.5))) / i));
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if (n <= (-8.6d-106)) then
tmp = n * (100.0d0 + (i * (50.0d0 + (i * 16.666666666666668d0))))
else if (n <= 1.85d-135) then
tmp = 0.0d0
else
tmp = n * (100.0d0 * ((i * (1.0d0 + (i * 0.5d0))) / i))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if (n <= -8.6e-106) {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
} else if (n <= 1.85e-135) {
tmp = 0.0;
} else {
tmp = n * (100.0 * ((i * (1.0 + (i * 0.5))) / i));
}
return tmp;
}
def code(i, n): tmp = 0 if n <= -8.6e-106: tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))) elif n <= 1.85e-135: tmp = 0.0 else: tmp = n * (100.0 * ((i * (1.0 + (i * 0.5))) / i)) return tmp
function code(i, n) tmp = 0.0 if (n <= -8.6e-106) tmp = Float64(n * Float64(100.0 + Float64(i * Float64(50.0 + Float64(i * 16.666666666666668))))); elseif (n <= 1.85e-135) tmp = 0.0; else tmp = Float64(n * Float64(100.0 * Float64(Float64(i * Float64(1.0 + Float64(i * 0.5))) / i))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if (n <= -8.6e-106) tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))); elseif (n <= 1.85e-135) tmp = 0.0; else tmp = n * (100.0 * ((i * (1.0 + (i * 0.5))) / i)); end tmp_2 = tmp; end
code[i_, n_] := If[LessEqual[n, -8.6e-106], N[(n * N[(100.0 + N[(i * N[(50.0 + N[(i * 16.666666666666668), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 1.85e-135], 0.0, N[(n * N[(100.0 * N[(N[(i * N[(1.0 + N[(i * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -8.6 \cdot 10^{-106}:\\
\;\;\;\;n \cdot \left(100 + i \cdot \left(50 + i \cdot 16.666666666666668\right)\right)\\
\mathbf{elif}\;n \leq 1.85 \cdot 10^{-135}:\\
\;\;\;\;0\\
\mathbf{else}:\\
\;\;\;\;n \cdot \left(100 \cdot \frac{i \cdot \left(1 + i \cdot 0.5\right)}{i}\right)\\
\end{array}
\end{array}
if n < -8.6000000000000004e-106Initial program 18.8%
associate-/r/19.1%
associate-*r*19.0%
*-commutative19.0%
associate-*r/19.1%
sub-neg19.1%
distribute-lft-in19.1%
metadata-eval19.1%
metadata-eval19.1%
metadata-eval19.1%
fma-define19.1%
metadata-eval19.1%
Simplified19.1%
Taylor expanded in n around inf 39.0%
associate-/l*39.0%
sub-neg39.0%
metadata-eval39.0%
metadata-eval39.0%
distribute-lft-in38.8%
metadata-eval38.8%
sub-neg38.8%
associate-*r/38.8%
*-commutative38.8%
expm1-define84.4%
Simplified84.4%
Taylor expanded in i around 0 64.1%
*-commutative64.1%
Simplified64.1%
if -8.6000000000000004e-106 < n < 1.8499999999999999e-135Initial program 45.4%
associate-*r/45.4%
sub-neg45.4%
distribute-rgt-in45.4%
metadata-eval45.4%
metadata-eval45.4%
Simplified45.4%
Taylor expanded in i around 0 63.0%
Taylor expanded in i around 0 63.0%
if 1.8499999999999999e-135 < n Initial program 18.2%
associate-/r/18.7%
associate-*r*18.7%
*-commutative18.7%
associate-*r/18.7%
sub-neg18.7%
distribute-lft-in18.6%
metadata-eval18.6%
metadata-eval18.6%
metadata-eval18.6%
fma-define18.7%
metadata-eval18.7%
Simplified18.7%
Taylor expanded in n around inf 25.5%
associate-/l*25.5%
sub-neg25.5%
metadata-eval25.5%
metadata-eval25.5%
distribute-lft-in25.5%
metadata-eval25.5%
sub-neg25.5%
associate-*r/25.5%
*-commutative25.5%
expm1-define86.8%
Simplified86.8%
Taylor expanded in i around 0 79.7%
*-commutative79.7%
Simplified79.7%
Final simplification70.2%
(FPCore (i n) :precision binary64 (if (or (<= n -8.6e-106) (not (<= n 3.8e-130))) (* n (+ 100.0 (* i (+ 50.0 (* i 16.666666666666668))))) 0.0))
double code(double i, double n) {
double tmp;
if ((n <= -8.6e-106) || !(n <= 3.8e-130)) {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
} 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 <= (-8.6d-106)) .or. (.not. (n <= 3.8d-130))) then
tmp = n * (100.0d0 + (i * (50.0d0 + (i * 16.666666666666668d0))))
else
tmp = 0.0d0
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if ((n <= -8.6e-106) || !(n <= 3.8e-130)) {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
} else {
tmp = 0.0;
}
return tmp;
}
def code(i, n): tmp = 0 if (n <= -8.6e-106) or not (n <= 3.8e-130): tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))) else: tmp = 0.0 return tmp
function code(i, n) tmp = 0.0 if ((n <= -8.6e-106) || !(n <= 3.8e-130)) tmp = Float64(n * Float64(100.0 + Float64(i * Float64(50.0 + Float64(i * 16.666666666666668))))); else tmp = 0.0; end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if ((n <= -8.6e-106) || ~((n <= 3.8e-130))) tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))); else tmp = 0.0; end tmp_2 = tmp; end
code[i_, n_] := If[Or[LessEqual[n, -8.6e-106], N[Not[LessEqual[n, 3.8e-130]], $MachinePrecision]], N[(n * N[(100.0 + N[(i * N[(50.0 + N[(i * 16.666666666666668), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.0]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -8.6 \cdot 10^{-106} \lor \neg \left(n \leq 3.8 \cdot 10^{-130}\right):\\
\;\;\;\;n \cdot \left(100 + i \cdot \left(50 + i \cdot 16.666666666666668\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if n < -8.6000000000000004e-106 or 3.7999999999999998e-130 < n Initial program 18.5%
associate-/r/18.9%
associate-*r*18.9%
*-commutative18.9%
associate-*r/18.9%
sub-neg18.9%
distribute-lft-in18.8%
metadata-eval18.8%
metadata-eval18.8%
metadata-eval18.8%
fma-define18.9%
metadata-eval18.9%
Simplified18.9%
Taylor expanded in n around inf 31.9%
associate-/l*32.0%
sub-neg32.0%
metadata-eval32.0%
metadata-eval32.0%
distribute-lft-in31.9%
metadata-eval31.9%
sub-neg31.9%
associate-*r/31.8%
*-commutative31.8%
expm1-define85.7%
Simplified85.7%
Taylor expanded in i around 0 71.8%
*-commutative71.8%
Simplified71.8%
if -8.6000000000000004e-106 < n < 3.7999999999999998e-130Initial program 45.4%
associate-*r/45.4%
sub-neg45.4%
distribute-rgt-in45.4%
metadata-eval45.4%
metadata-eval45.4%
Simplified45.4%
Taylor expanded in i around 0 63.0%
Taylor expanded in i around 0 63.0%
Final simplification69.8%
(FPCore (i n) :precision binary64 (if (or (<= n -8.6e-106) (not (<= n 3e-132))) (* n (+ 100.0 (* i 50.0))) 0.0))
double code(double i, double n) {
double tmp;
if ((n <= -8.6e-106) || !(n <= 3e-132)) {
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 <= (-8.6d-106)) .or. (.not. (n <= 3d-132))) 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 <= -8.6e-106) || !(n <= 3e-132)) {
tmp = n * (100.0 + (i * 50.0));
} else {
tmp = 0.0;
}
return tmp;
}
def code(i, n): tmp = 0 if (n <= -8.6e-106) or not (n <= 3e-132): tmp = n * (100.0 + (i * 50.0)) else: tmp = 0.0 return tmp
function code(i, n) tmp = 0.0 if ((n <= -8.6e-106) || !(n <= 3e-132)) 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 <= -8.6e-106) || ~((n <= 3e-132))) tmp = n * (100.0 + (i * 50.0)); else tmp = 0.0; end tmp_2 = tmp; end
code[i_, n_] := If[Or[LessEqual[n, -8.6e-106], N[Not[LessEqual[n, 3e-132]], $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 -8.6 \cdot 10^{-106} \lor \neg \left(n \leq 3 \cdot 10^{-132}\right):\\
\;\;\;\;n \cdot \left(100 + i \cdot 50\right)\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if n < -8.6000000000000004e-106 or 3e-132 < n Initial program 18.5%
associate-/r/18.9%
associate-*r*18.9%
*-commutative18.9%
associate-*r/18.9%
sub-neg18.9%
distribute-lft-in18.8%
metadata-eval18.8%
metadata-eval18.8%
metadata-eval18.8%
fma-define18.9%
metadata-eval18.9%
Simplified18.9%
Taylor expanded in n around inf 31.9%
associate-/l*32.0%
sub-neg32.0%
metadata-eval32.0%
metadata-eval32.0%
distribute-lft-in31.9%
metadata-eval31.9%
sub-neg31.9%
associate-*r/31.8%
*-commutative31.8%
expm1-define85.7%
Simplified85.7%
Taylor expanded in i around 0 66.3%
*-commutative66.3%
Simplified66.3%
if -8.6000000000000004e-106 < n < 3e-132Initial program 45.4%
associate-*r/45.4%
sub-neg45.4%
distribute-rgt-in45.4%
metadata-eval45.4%
metadata-eval45.4%
Simplified45.4%
Taylor expanded in i around 0 63.0%
Taylor expanded in i around 0 63.0%
Final simplification65.6%
(FPCore (i n) :precision binary64 (if (<= i -7.6e+25) 0.0 (if (<= i 1.25e+22) (* n 100.0) 0.0)))
double code(double i, double n) {
double tmp;
if (i <= -7.6e+25) {
tmp = 0.0;
} else if (i <= 1.25e+22) {
tmp = n * 100.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 (i <= (-7.6d+25)) then
tmp = 0.0d0
else if (i <= 1.25d+22) then
tmp = n * 100.0d0
else
tmp = 0.0d0
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if (i <= -7.6e+25) {
tmp = 0.0;
} else if (i <= 1.25e+22) {
tmp = n * 100.0;
} else {
tmp = 0.0;
}
return tmp;
}
def code(i, n): tmp = 0 if i <= -7.6e+25: tmp = 0.0 elif i <= 1.25e+22: tmp = n * 100.0 else: tmp = 0.0 return tmp
function code(i, n) tmp = 0.0 if (i <= -7.6e+25) tmp = 0.0; elseif (i <= 1.25e+22) tmp = Float64(n * 100.0); else tmp = 0.0; end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if (i <= -7.6e+25) tmp = 0.0; elseif (i <= 1.25e+22) tmp = n * 100.0; else tmp = 0.0; end tmp_2 = tmp; end
code[i_, n_] := If[LessEqual[i, -7.6e+25], 0.0, If[LessEqual[i, 1.25e+22], N[(n * 100.0), $MachinePrecision], 0.0]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -7.6 \cdot 10^{+25}:\\
\;\;\;\;0\\
\mathbf{elif}\;i \leq 1.25 \cdot 10^{+22}:\\
\;\;\;\;n \cdot 100\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if i < -7.6000000000000001e25 or 1.2499999999999999e22 < i Initial program 50.3%
associate-*r/50.3%
sub-neg50.3%
distribute-rgt-in50.3%
metadata-eval50.3%
metadata-eval50.3%
Simplified50.3%
Taylor expanded in i around 0 31.8%
Taylor expanded in i around 0 31.8%
if -7.6000000000000001e25 < i < 1.2499999999999999e22Initial program 8.7%
associate-/r/9.2%
associate-*r*9.2%
*-commutative9.2%
associate-*r/9.2%
sub-neg9.2%
distribute-lft-in9.2%
metadata-eval9.2%
metadata-eval9.2%
metadata-eval9.2%
fma-define9.2%
metadata-eval9.2%
Simplified9.2%
Taylor expanded in i around 0 77.8%
*-commutative77.8%
Simplified77.8%
(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.5%
associate-*r/24.5%
sub-neg24.5%
distribute-rgt-in24.5%
metadata-eval24.5%
metadata-eval24.5%
Simplified24.5%
Taylor expanded in i around 0 17.0%
Taylor expanded in i around 0 17.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 2024191
(FPCore (i n)
:name "Compound Interest"
:precision binary64
:alt
(! :herbie-platform default (let ((lnbase (if (== (+ 1 (/ i n)) 1) (/ i n) (/ (* (/ i n) (log (+ 1 (/ i n)))) (- (+ (/ i n) 1) 1))))) (* 100 (/ (- (exp (* n lnbase)) 1) (/ i n)))))
(* 100.0 (/ (- (pow (+ 1.0 (/ i n)) n) 1.0) (/ i n))))