
(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 17 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 (* 100.0 (pow (/ i n) n)))
(t_1 (/ (+ (pow (+ 1.0 (/ i n)) n) -1.0) (/ i n))))
(if (<= t_1 -2e-27)
(/ (* n (- t_0 100.0)) i)
(if (<= t_1 0.0)
(* 100.0 (/ (expm1 (* n (log1p (/ i n)))) (/ i n)))
(if (<= t_1 INFINITY)
(/ (+ t_0 -100.0) (/ i n))
(* 100.0 (/ n (+ 1.0 (* i -0.5)))))))))
double code(double i, double n) {
double t_0 = 100.0 * pow((i / n), n);
double t_1 = (pow((1.0 + (i / n)), n) + -1.0) / (i / n);
double tmp;
if (t_1 <= -2e-27) {
tmp = (n * (t_0 - 100.0)) / i;
} else if (t_1 <= 0.0) {
tmp = 100.0 * (expm1((n * log1p((i / n)))) / (i / n));
} else if (t_1 <= ((double) INFINITY)) {
tmp = (t_0 + -100.0) / (i / n);
} else {
tmp = 100.0 * (n / (1.0 + (i * -0.5)));
}
return tmp;
}
public static double code(double i, double n) {
double t_0 = 100.0 * Math.pow((i / n), n);
double t_1 = (Math.pow((1.0 + (i / n)), n) + -1.0) / (i / n);
double tmp;
if (t_1 <= -2e-27) {
tmp = (n * (t_0 - 100.0)) / i;
} else if (t_1 <= 0.0) {
tmp = 100.0 * (Math.expm1((n * Math.log1p((i / n)))) / (i / n));
} else if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = (t_0 + -100.0) / (i / n);
} else {
tmp = 100.0 * (n / (1.0 + (i * -0.5)));
}
return tmp;
}
def code(i, n): t_0 = 100.0 * math.pow((i / n), n) t_1 = (math.pow((1.0 + (i / n)), n) + -1.0) / (i / n) tmp = 0 if t_1 <= -2e-27: tmp = (n * (t_0 - 100.0)) / i elif t_1 <= 0.0: tmp = 100.0 * (math.expm1((n * math.log1p((i / n)))) / (i / n)) elif t_1 <= math.inf: tmp = (t_0 + -100.0) / (i / n) else: tmp = 100.0 * (n / (1.0 + (i * -0.5))) return tmp
function code(i, n) t_0 = Float64(100.0 * (Float64(i / n) ^ n)) t_1 = Float64(Float64((Float64(1.0 + Float64(i / n)) ^ n) + -1.0) / Float64(i / n)) tmp = 0.0 if (t_1 <= -2e-27) tmp = Float64(Float64(n * Float64(t_0 - 100.0)) / i); elseif (t_1 <= 0.0) tmp = Float64(100.0 * Float64(expm1(Float64(n * log1p(Float64(i / n)))) / Float64(i / n))); elseif (t_1 <= Inf) tmp = Float64(Float64(t_0 + -100.0) / Float64(i / n)); else tmp = Float64(100.0 * Float64(n / Float64(1.0 + Float64(i * -0.5)))); end return tmp end
code[i_, n_] := Block[{t$95$0 = N[(100.0 * N[Power[N[(i / n), $MachinePrecision], n], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = 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$1, -2e-27], N[(N[(n * N[(t$95$0 - 100.0), $MachinePrecision]), $MachinePrecision] / i), $MachinePrecision], If[LessEqual[t$95$1, 0.0], N[(100.0 * N[(N[(Exp[N[(n * N[Log[1 + N[(i / n), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[(t$95$0 + -100.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision], N[(100.0 * N[(n / N[(1.0 + N[(i * -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 100 \cdot {\left(\frac{i}{n}\right)}^{n}\\
t_1 := \frac{{\left(1 + \frac{i}{n}\right)}^{n} + -1}{\frac{i}{n}}\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{-27}:\\
\;\;\;\;\frac{n \cdot \left(t\_0 - 100\right)}{i}\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;100 \cdot \frac{\mathsf{expm1}\left(n \cdot \mathsf{log1p}\left(\frac{i}{n}\right)\right)}{\frac{i}{n}}\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\frac{t\_0 + -100}{\frac{i}{n}}\\
\mathbf{else}:\\
\;\;\;\;100 \cdot \frac{n}{1 + i \cdot -0.5}\\
\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)) < -2.0000000000000001e-27Initial program 99.7%
associate-*r/99.7%
sub-neg99.7%
distribute-rgt-in99.7%
metadata-eval99.7%
metadata-eval99.7%
Simplified99.7%
Taylor expanded in i around inf 99.7%
Taylor expanded in n around inf 100.0%
if -2.0000000000000001e-27 < (/.f64 (-.f64 (pow.f64 (+.f64 #s(literal 1 binary64) (/.f64 i n)) n) #s(literal 1 binary64)) (/.f64 i n)) < -0.0Initial program 18.6%
sub-neg18.6%
metadata-eval18.6%
Applied egg-rr18.6%
metadata-eval18.6%
sub-neg18.6%
exp-to-pow18.6%
log1p-undefine41.5%
*-commutative41.5%
expm1-undefine99.7%
Simplified99.7%
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 99.2%
associate-*r/99.4%
sub-neg99.4%
distribute-rgt-in99.4%
metadata-eval99.4%
metadata-eval99.4%
Simplified99.4%
Taylor expanded in i around inf 99.4%
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.9%
associate-*r*1.9%
*-commutative1.9%
associate-*r/1.9%
sub-neg1.9%
distribute-lft-in1.9%
metadata-eval1.9%
metadata-eval1.9%
metadata-eval1.9%
fma-define1.9%
metadata-eval1.9%
Simplified1.9%
Taylor expanded in n around inf 1.9%
sub-neg1.9%
metadata-eval1.9%
metadata-eval1.9%
distribute-lft-in1.9%
metadata-eval1.9%
sub-neg1.9%
expm1-define87.5%
Simplified87.5%
clear-num87.6%
un-div-inv87.4%
*-un-lft-identity87.4%
times-frac87.5%
metadata-eval87.5%
Applied egg-rr87.5%
*-rgt-identity87.5%
*-commutative87.5%
times-frac87.7%
metadata-eval87.7%
Simplified87.7%
Taylor expanded in i around 0 100.0%
*-commutative100.0%
Simplified100.0%
Final simplification99.8%
(FPCore (i n)
:precision binary64
(let* ((t_0 (pow (/ i n) n))
(t_1 (/ (+ (pow (+ 1.0 (/ i n)) n) -1.0) (/ i n))))
(if (<= t_1 -1e-89)
(* 100.0 (/ (+ t_0 -1.0) (/ i n)))
(if (<= t_1 0.0)
(* 100.0 (/ n (/ i (expm1 i))))
(if (<= t_1 INFINITY)
(/ (+ (* 100.0 t_0) -100.0) (/ i n))
(* 100.0 (/ n (+ 1.0 (* i -0.5)))))))))
double code(double i, double n) {
double t_0 = pow((i / n), n);
double t_1 = (pow((1.0 + (i / n)), n) + -1.0) / (i / n);
double tmp;
if (t_1 <= -1e-89) {
tmp = 100.0 * ((t_0 + -1.0) / (i / n));
} else if (t_1 <= 0.0) {
tmp = 100.0 * (n / (i / expm1(i)));
} else if (t_1 <= ((double) INFINITY)) {
tmp = ((100.0 * t_0) + -100.0) / (i / n);
} else {
tmp = 100.0 * (n / (1.0 + (i * -0.5)));
}
return tmp;
}
public static double code(double i, double n) {
double t_0 = Math.pow((i / n), n);
double t_1 = (Math.pow((1.0 + (i / n)), n) + -1.0) / (i / n);
double tmp;
if (t_1 <= -1e-89) {
tmp = 100.0 * ((t_0 + -1.0) / (i / n));
} else if (t_1 <= 0.0) {
tmp = 100.0 * (n / (i / Math.expm1(i)));
} else if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = ((100.0 * t_0) + -100.0) / (i / n);
} else {
tmp = 100.0 * (n / (1.0 + (i * -0.5)));
}
return tmp;
}
def code(i, n): t_0 = math.pow((i / n), n) t_1 = (math.pow((1.0 + (i / n)), n) + -1.0) / (i / n) tmp = 0 if t_1 <= -1e-89: tmp = 100.0 * ((t_0 + -1.0) / (i / n)) elif t_1 <= 0.0: tmp = 100.0 * (n / (i / math.expm1(i))) elif t_1 <= math.inf: tmp = ((100.0 * t_0) + -100.0) / (i / n) else: tmp = 100.0 * (n / (1.0 + (i * -0.5))) return tmp
function code(i, n) t_0 = Float64(i / n) ^ n t_1 = Float64(Float64((Float64(1.0 + Float64(i / n)) ^ n) + -1.0) / Float64(i / n)) tmp = 0.0 if (t_1 <= -1e-89) tmp = Float64(100.0 * Float64(Float64(t_0 + -1.0) / Float64(i / n))); elseif (t_1 <= 0.0) tmp = Float64(100.0 * Float64(n / Float64(i / expm1(i)))); elseif (t_1 <= Inf) tmp = Float64(Float64(Float64(100.0 * t_0) + -100.0) / Float64(i / n)); else tmp = Float64(100.0 * Float64(n / Float64(1.0 + Float64(i * -0.5)))); end return tmp end
code[i_, n_] := Block[{t$95$0 = N[Power[N[(i / n), $MachinePrecision], n], $MachinePrecision]}, Block[{t$95$1 = 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$1, -1e-89], N[(100.0 * N[(N[(t$95$0 + -1.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 0.0], N[(100.0 * N[(n / N[(i / N[(Exp[i] - 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[(N[(100.0 * t$95$0), $MachinePrecision] + -100.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision], N[(100.0 * N[(n / N[(1.0 + N[(i * -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {\left(\frac{i}{n}\right)}^{n}\\
t_1 := \frac{{\left(1 + \frac{i}{n}\right)}^{n} + -1}{\frac{i}{n}}\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{-89}:\\
\;\;\;\;100 \cdot \frac{t\_0 + -1}{\frac{i}{n}}\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;100 \cdot \frac{n}{\frac{i}{\mathsf{expm1}\left(i\right)}}\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\frac{100 \cdot t\_0 + -100}{\frac{i}{n}}\\
\mathbf{else}:\\
\;\;\;\;100 \cdot \frac{n}{1 + i \cdot -0.5}\\
\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)) < -1.00000000000000004e-89Initial program 91.8%
Taylor expanded in i around inf 91.8%
if -1.00000000000000004e-89 < (/.f64 (-.f64 (pow.f64 (+.f64 #s(literal 1 binary64) (/.f64 i n)) n) #s(literal 1 binary64)) (/.f64 i n)) < -0.0Initial program 17.2%
associate-/r/17.2%
associate-*r*17.2%
*-commutative17.2%
associate-*r/17.2%
sub-neg17.2%
distribute-lft-in17.2%
metadata-eval17.2%
metadata-eval17.2%
metadata-eval17.2%
fma-define17.2%
metadata-eval17.2%
Simplified17.2%
Taylor expanded in n around inf 35.3%
sub-neg35.3%
metadata-eval35.3%
metadata-eval35.3%
distribute-lft-in35.3%
metadata-eval35.3%
sub-neg35.3%
expm1-define81.2%
Simplified81.2%
clear-num81.3%
un-div-inv81.2%
*-un-lft-identity81.2%
times-frac81.2%
metadata-eval81.2%
Applied egg-rr81.2%
*-rgt-identity81.2%
*-commutative81.2%
times-frac81.3%
metadata-eval81.3%
Simplified81.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 99.2%
associate-*r/99.4%
sub-neg99.4%
distribute-rgt-in99.4%
metadata-eval99.4%
metadata-eval99.4%
Simplified99.4%
Taylor expanded in i around inf 99.4%
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.9%
associate-*r*1.9%
*-commutative1.9%
associate-*r/1.9%
sub-neg1.9%
distribute-lft-in1.9%
metadata-eval1.9%
metadata-eval1.9%
metadata-eval1.9%
fma-define1.9%
metadata-eval1.9%
Simplified1.9%
Taylor expanded in n around inf 1.9%
sub-neg1.9%
metadata-eval1.9%
metadata-eval1.9%
distribute-lft-in1.9%
metadata-eval1.9%
sub-neg1.9%
expm1-define87.5%
Simplified87.5%
clear-num87.6%
un-div-inv87.4%
*-un-lft-identity87.4%
times-frac87.5%
metadata-eval87.5%
Applied egg-rr87.5%
*-rgt-identity87.5%
*-commutative87.5%
times-frac87.7%
metadata-eval87.7%
Simplified87.7%
Taylor expanded in i around 0 100.0%
*-commutative100.0%
Simplified100.0%
Final simplification86.9%
(FPCore (i n) :precision binary64 (if (or (<= n -5.5e-33) (not (<= n 1.25))) (* 100.0 (/ n (/ i (expm1 i)))) (* 100.0 (/ n (+ 1.0 (* i (* i 0.08333333333333333)))))))
double code(double i, double n) {
double tmp;
if ((n <= -5.5e-33) || !(n <= 1.25)) {
tmp = 100.0 * (n / (i / expm1(i)));
} else {
tmp = 100.0 * (n / (1.0 + (i * (i * 0.08333333333333333))));
}
return tmp;
}
public static double code(double i, double n) {
double tmp;
if ((n <= -5.5e-33) || !(n <= 1.25)) {
tmp = 100.0 * (n / (i / Math.expm1(i)));
} else {
tmp = 100.0 * (n / (1.0 + (i * (i * 0.08333333333333333))));
}
return tmp;
}
def code(i, n): tmp = 0 if (n <= -5.5e-33) or not (n <= 1.25): tmp = 100.0 * (n / (i / math.expm1(i))) else: tmp = 100.0 * (n / (1.0 + (i * (i * 0.08333333333333333)))) return tmp
function code(i, n) tmp = 0.0 if ((n <= -5.5e-33) || !(n <= 1.25)) tmp = Float64(100.0 * Float64(n / Float64(i / expm1(i)))); else tmp = Float64(100.0 * Float64(n / Float64(1.0 + Float64(i * Float64(i * 0.08333333333333333))))); end return tmp end
code[i_, n_] := If[Or[LessEqual[n, -5.5e-33], N[Not[LessEqual[n, 1.25]], $MachinePrecision]], N[(100.0 * N[(n / N[(i / N[(Exp[i] - 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(100.0 * N[(n / N[(1.0 + N[(i * N[(i * 0.08333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -5.5 \cdot 10^{-33} \lor \neg \left(n \leq 1.25\right):\\
\;\;\;\;100 \cdot \frac{n}{\frac{i}{\mathsf{expm1}\left(i\right)}}\\
\mathbf{else}:\\
\;\;\;\;100 \cdot \frac{n}{1 + i \cdot \left(i \cdot 0.08333333333333333\right)}\\
\end{array}
\end{array}
if n < -5.5e-33 or 1.25 < n Initial program 23.7%
associate-/r/24.2%
associate-*r*24.2%
*-commutative24.2%
associate-*r/24.2%
sub-neg24.2%
distribute-lft-in24.2%
metadata-eval24.2%
metadata-eval24.2%
metadata-eval24.2%
fma-define24.2%
metadata-eval24.2%
Simplified24.2%
Taylor expanded in n around inf 39.7%
sub-neg39.7%
metadata-eval39.7%
metadata-eval39.7%
distribute-lft-in39.7%
metadata-eval39.7%
sub-neg39.7%
expm1-define89.5%
Simplified89.5%
clear-num89.5%
un-div-inv89.4%
*-un-lft-identity89.4%
times-frac89.5%
metadata-eval89.5%
Applied egg-rr89.5%
*-rgt-identity89.5%
*-commutative89.5%
times-frac89.6%
metadata-eval89.6%
Simplified89.6%
if -5.5e-33 < n < 1.25Initial program 26.3%
associate-/r/26.4%
associate-*r*26.4%
*-commutative26.4%
associate-*r/26.4%
sub-neg26.4%
distribute-lft-in26.4%
metadata-eval26.4%
metadata-eval26.4%
metadata-eval26.4%
fma-define26.4%
metadata-eval26.4%
Simplified26.4%
Taylor expanded in n around inf 14.4%
sub-neg14.4%
metadata-eval14.4%
metadata-eval14.4%
distribute-lft-in14.4%
metadata-eval14.4%
sub-neg14.4%
expm1-define56.9%
Simplified56.9%
clear-num56.9%
un-div-inv56.8%
*-un-lft-identity56.8%
times-frac56.8%
metadata-eval56.8%
Applied egg-rr56.8%
*-rgt-identity56.8%
*-commutative56.8%
times-frac56.9%
metadata-eval56.9%
Simplified56.9%
Taylor expanded in i around 0 69.5%
Taylor expanded in i around inf 69.5%
*-commutative69.5%
Simplified69.5%
Final simplification82.8%
(FPCore (i n) :precision binary64 (if (<= i 1.3e+116) (* 100.0 (/ n (/ i (expm1 i)))) (/ (* n (- (* 100.0 (pow (/ i n) n)) 100.0)) i)))
double code(double i, double n) {
double tmp;
if (i <= 1.3e+116) {
tmp = 100.0 * (n / (i / expm1(i)));
} else {
tmp = (n * ((100.0 * pow((i / n), n)) - 100.0)) / i;
}
return tmp;
}
public static double code(double i, double n) {
double tmp;
if (i <= 1.3e+116) {
tmp = 100.0 * (n / (i / Math.expm1(i)));
} else {
tmp = (n * ((100.0 * Math.pow((i / n), n)) - 100.0)) / i;
}
return tmp;
}
def code(i, n): tmp = 0 if i <= 1.3e+116: tmp = 100.0 * (n / (i / math.expm1(i))) else: tmp = (n * ((100.0 * math.pow((i / n), n)) - 100.0)) / i return tmp
function code(i, n) tmp = 0.0 if (i <= 1.3e+116) tmp = Float64(100.0 * Float64(n / Float64(i / expm1(i)))); else tmp = Float64(Float64(n * Float64(Float64(100.0 * (Float64(i / n) ^ n)) - 100.0)) / i); end return tmp end
code[i_, n_] := If[LessEqual[i, 1.3e+116], N[(100.0 * N[(n / N[(i / N[(Exp[i] - 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(n * N[(N[(100.0 * N[Power[N[(i / n), $MachinePrecision], n], $MachinePrecision]), $MachinePrecision] - 100.0), $MachinePrecision]), $MachinePrecision] / i), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq 1.3 \cdot 10^{+116}:\\
\;\;\;\;100 \cdot \frac{n}{\frac{i}{\mathsf{expm1}\left(i\right)}}\\
\mathbf{else}:\\
\;\;\;\;\frac{n \cdot \left(100 \cdot {\left(\frac{i}{n}\right)}^{n} - 100\right)}{i}\\
\end{array}
\end{array}
if i < 1.29999999999999993e116Initial program 18.2%
associate-/r/18.6%
associate-*r*18.6%
*-commutative18.6%
associate-*r/18.6%
sub-neg18.6%
distribute-lft-in18.6%
metadata-eval18.6%
metadata-eval18.6%
metadata-eval18.6%
fma-define18.6%
metadata-eval18.6%
Simplified18.6%
Taylor expanded in n around inf 27.6%
sub-neg27.6%
metadata-eval27.6%
metadata-eval27.6%
distribute-lft-in27.6%
metadata-eval27.6%
sub-neg27.6%
expm1-define82.8%
Simplified82.8%
clear-num82.9%
un-div-inv82.8%
*-un-lft-identity82.8%
times-frac82.8%
metadata-eval82.8%
Applied egg-rr82.8%
*-rgt-identity82.8%
*-commutative82.8%
times-frac83.0%
metadata-eval83.0%
Simplified83.0%
if 1.29999999999999993e116 < i Initial program 62.3%
associate-*r/62.4%
sub-neg62.4%
distribute-rgt-in62.4%
metadata-eval62.4%
metadata-eval62.4%
Simplified62.4%
Taylor expanded in i around inf 78.3%
Taylor expanded in n around inf 78.5%
(FPCore (i n) :precision binary64 (if (<= i 1.32e+116) (* 100.0 (/ n (/ i (expm1 i)))) (* 100.0 (/ (+ (pow (/ i n) n) -1.0) (/ i n)))))
double code(double i, double n) {
double tmp;
if (i <= 1.32e+116) {
tmp = 100.0 * (n / (i / expm1(i)));
} else {
tmp = 100.0 * ((pow((i / n), n) + -1.0) / (i / n));
}
return tmp;
}
public static double code(double i, double n) {
double tmp;
if (i <= 1.32e+116) {
tmp = 100.0 * (n / (i / Math.expm1(i)));
} else {
tmp = 100.0 * ((Math.pow((i / n), n) + -1.0) / (i / n));
}
return tmp;
}
def code(i, n): tmp = 0 if i <= 1.32e+116: tmp = 100.0 * (n / (i / math.expm1(i))) else: tmp = 100.0 * ((math.pow((i / n), n) + -1.0) / (i / n)) return tmp
function code(i, n) tmp = 0.0 if (i <= 1.32e+116) tmp = Float64(100.0 * Float64(n / Float64(i / expm1(i)))); else tmp = Float64(100.0 * Float64(Float64((Float64(i / n) ^ n) + -1.0) / Float64(i / n))); end return tmp end
code[i_, n_] := If[LessEqual[i, 1.32e+116], N[(100.0 * N[(n / N[(i / N[(Exp[i] - 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(100.0 * N[(N[(N[Power[N[(i / n), $MachinePrecision], n], $MachinePrecision] + -1.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq 1.32 \cdot 10^{+116}:\\
\;\;\;\;100 \cdot \frac{n}{\frac{i}{\mathsf{expm1}\left(i\right)}}\\
\mathbf{else}:\\
\;\;\;\;100 \cdot \frac{{\left(\frac{i}{n}\right)}^{n} + -1}{\frac{i}{n}}\\
\end{array}
\end{array}
if i < 1.32000000000000002e116Initial program 18.2%
associate-/r/18.6%
associate-*r*18.6%
*-commutative18.6%
associate-*r/18.6%
sub-neg18.6%
distribute-lft-in18.6%
metadata-eval18.6%
metadata-eval18.6%
metadata-eval18.6%
fma-define18.6%
metadata-eval18.6%
Simplified18.6%
Taylor expanded in n around inf 27.6%
sub-neg27.6%
metadata-eval27.6%
metadata-eval27.6%
distribute-lft-in27.6%
metadata-eval27.6%
sub-neg27.6%
expm1-define82.8%
Simplified82.8%
clear-num82.9%
un-div-inv82.8%
*-un-lft-identity82.8%
times-frac82.8%
metadata-eval82.8%
Applied egg-rr82.8%
*-rgt-identity82.8%
*-commutative82.8%
times-frac83.0%
metadata-eval83.0%
Simplified83.0%
if 1.32000000000000002e116 < i Initial program 62.3%
Taylor expanded in i around inf 78.2%
Final simplification82.3%
(FPCore (i n) :precision binary64 (if (<= i 5e+198) (* 100.0 (/ n (/ i (expm1 i)))) (* 100.0 (- (pow (/ i n) (+ n -1.0)) (/ n i)))))
double code(double i, double n) {
double tmp;
if (i <= 5e+198) {
tmp = 100.0 * (n / (i / expm1(i)));
} else {
tmp = 100.0 * (pow((i / n), (n + -1.0)) - (n / i));
}
return tmp;
}
public static double code(double i, double n) {
double tmp;
if (i <= 5e+198) {
tmp = 100.0 * (n / (i / Math.expm1(i)));
} else {
tmp = 100.0 * (Math.pow((i / n), (n + -1.0)) - (n / i));
}
return tmp;
}
def code(i, n): tmp = 0 if i <= 5e+198: tmp = 100.0 * (n / (i / math.expm1(i))) else: tmp = 100.0 * (math.pow((i / n), (n + -1.0)) - (n / i)) return tmp
function code(i, n) tmp = 0.0 if (i <= 5e+198) tmp = Float64(100.0 * Float64(n / Float64(i / expm1(i)))); else tmp = Float64(100.0 * Float64((Float64(i / n) ^ Float64(n + -1.0)) - Float64(n / i))); end return tmp end
code[i_, n_] := If[LessEqual[i, 5e+198], N[(100.0 * N[(n / N[(i / N[(Exp[i] - 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(100.0 * N[(N[Power[N[(i / n), $MachinePrecision], N[(n + -1.0), $MachinePrecision]], $MachinePrecision] - N[(n / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq 5 \cdot 10^{+198}:\\
\;\;\;\;100 \cdot \frac{n}{\frac{i}{\mathsf{expm1}\left(i\right)}}\\
\mathbf{else}:\\
\;\;\;\;100 \cdot \left({\left(\frac{i}{n}\right)}^{\left(n + -1\right)} - \frac{n}{i}\right)\\
\end{array}
\end{array}
if i < 5.00000000000000049e198Initial program 20.5%
associate-/r/20.8%
associate-*r*20.9%
*-commutative20.9%
associate-*r/20.9%
sub-neg20.9%
distribute-lft-in20.9%
metadata-eval20.9%
metadata-eval20.9%
metadata-eval20.9%
fma-define20.9%
metadata-eval20.9%
Simplified20.9%
Taylor expanded in n around inf 29.3%
sub-neg29.3%
metadata-eval29.3%
metadata-eval29.3%
distribute-lft-in29.3%
metadata-eval29.3%
sub-neg29.3%
expm1-define81.0%
Simplified81.0%
clear-num81.1%
un-div-inv80.9%
*-un-lft-identity80.9%
times-frac81.0%
metadata-eval81.0%
Applied egg-rr81.0%
*-rgt-identity81.0%
*-commutative81.0%
times-frac81.1%
metadata-eval81.1%
Simplified81.1%
if 5.00000000000000049e198 < i Initial program 68.2%
Taylor expanded in i around inf 72.6%
div-sub72.6%
pow172.6%
pow-div90.8%
clear-num90.7%
Applied egg-rr90.7%
Final simplification81.9%
(FPCore (i n)
:precision binary64
(if (<= n -4.8e+181)
(*
n
(+
100.0
(* i (+ 50.0 (* i (+ 16.666666666666668 (* i 4.166666666666667)))))))
(if (<= n 1.3)
(* 100.0 (/ n (+ 1.0 (* i (- (* i 0.08333333333333333) 0.5)))))
(*
(* n 100.0)
(+
1.0
(*
i
(+ 0.5 (* i (+ 0.16666666666666666 (* i 0.041666666666666664))))))))))
double code(double i, double n) {
double tmp;
if (n <= -4.8e+181) {
tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667))))));
} else if (n <= 1.3) {
tmp = 100.0 * (n / (1.0 + (i * ((i * 0.08333333333333333) - 0.5))));
} else {
tmp = (n * 100.0) * (1.0 + (i * (0.5 + (i * (0.16666666666666666 + (i * 0.041666666666666664))))));
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if (n <= (-4.8d+181)) then
tmp = n * (100.0d0 + (i * (50.0d0 + (i * (16.666666666666668d0 + (i * 4.166666666666667d0))))))
else if (n <= 1.3d0) then
tmp = 100.0d0 * (n / (1.0d0 + (i * ((i * 0.08333333333333333d0) - 0.5d0))))
else
tmp = (n * 100.0d0) * (1.0d0 + (i * (0.5d0 + (i * (0.16666666666666666d0 + (i * 0.041666666666666664d0))))))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if (n <= -4.8e+181) {
tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667))))));
} else if (n <= 1.3) {
tmp = 100.0 * (n / (1.0 + (i * ((i * 0.08333333333333333) - 0.5))));
} else {
tmp = (n * 100.0) * (1.0 + (i * (0.5 + (i * (0.16666666666666666 + (i * 0.041666666666666664))))));
}
return tmp;
}
def code(i, n): tmp = 0 if n <= -4.8e+181: tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667)))))) elif n <= 1.3: tmp = 100.0 * (n / (1.0 + (i * ((i * 0.08333333333333333) - 0.5)))) else: tmp = (n * 100.0) * (1.0 + (i * (0.5 + (i * (0.16666666666666666 + (i * 0.041666666666666664)))))) return tmp
function code(i, n) tmp = 0.0 if (n <= -4.8e+181) tmp = Float64(n * Float64(100.0 + Float64(i * Float64(50.0 + Float64(i * Float64(16.666666666666668 + Float64(i * 4.166666666666667))))))); elseif (n <= 1.3) tmp = Float64(100.0 * Float64(n / Float64(1.0 + Float64(i * Float64(Float64(i * 0.08333333333333333) - 0.5))))); else tmp = Float64(Float64(n * 100.0) * Float64(1.0 + Float64(i * Float64(0.5 + Float64(i * Float64(0.16666666666666666 + Float64(i * 0.041666666666666664))))))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if (n <= -4.8e+181) tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667)))))); elseif (n <= 1.3) tmp = 100.0 * (n / (1.0 + (i * ((i * 0.08333333333333333) - 0.5)))); else tmp = (n * 100.0) * (1.0 + (i * (0.5 + (i * (0.16666666666666666 + (i * 0.041666666666666664)))))); end tmp_2 = tmp; end
code[i_, n_] := If[LessEqual[n, -4.8e+181], N[(n * N[(100.0 + N[(i * N[(50.0 + N[(i * N[(16.666666666666668 + N[(i * 4.166666666666667), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 1.3], N[(100.0 * N[(n / N[(1.0 + N[(i * N[(N[(i * 0.08333333333333333), $MachinePrecision] - 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(n * 100.0), $MachinePrecision] * N[(1.0 + N[(i * N[(0.5 + N[(i * N[(0.16666666666666666 + N[(i * 0.041666666666666664), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -4.8 \cdot 10^{+181}:\\
\;\;\;\;n \cdot \left(100 + i \cdot \left(50 + i \cdot \left(16.666666666666668 + i \cdot 4.166666666666667\right)\right)\right)\\
\mathbf{elif}\;n \leq 1.3:\\
\;\;\;\;100 \cdot \frac{n}{1 + i \cdot \left(i \cdot 0.08333333333333333 - 0.5\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(n \cdot 100\right) \cdot \left(1 + i \cdot \left(0.5 + i \cdot \left(0.16666666666666666 + i \cdot 0.041666666666666664\right)\right)\right)\\
\end{array}
\end{array}
if n < -4.80000000000000004e181Initial program 7.6%
associate-/r/8.3%
associate-*r*8.3%
*-commutative8.3%
associate-*r/8.3%
sub-neg8.3%
distribute-lft-in8.3%
metadata-eval8.3%
metadata-eval8.3%
metadata-eval8.3%
fma-define8.3%
metadata-eval8.3%
Simplified8.3%
Taylor expanded in n around inf 45.3%
sub-neg45.3%
metadata-eval45.3%
metadata-eval45.3%
distribute-lft-in45.3%
metadata-eval45.3%
sub-neg45.3%
expm1-define95.4%
Simplified95.4%
Taylor expanded in i around 0 78.0%
*-commutative78.0%
Simplified78.0%
if -4.80000000000000004e181 < n < 1.30000000000000004Initial program 28.6%
associate-/r/28.8%
associate-*r*28.8%
*-commutative28.8%
associate-*r/28.9%
sub-neg28.9%
distribute-lft-in28.8%
metadata-eval28.8%
metadata-eval28.8%
metadata-eval28.8%
fma-define28.9%
metadata-eval28.9%
Simplified28.9%
Taylor expanded in n around inf 19.6%
sub-neg19.6%
metadata-eval19.6%
metadata-eval19.6%
distribute-lft-in19.6%
metadata-eval19.6%
sub-neg19.6%
expm1-define66.3%
Simplified66.3%
clear-num66.4%
un-div-inv66.3%
*-un-lft-identity66.3%
times-frac66.3%
metadata-eval66.3%
Applied egg-rr66.3%
*-rgt-identity66.3%
*-commutative66.3%
times-frac66.4%
metadata-eval66.4%
Simplified66.4%
Taylor expanded in i around 0 64.9%
if 1.30000000000000004 < n Initial program 27.2%
associate-/r/27.7%
associate-*r*27.7%
*-commutative27.7%
associate-*r/27.7%
sub-neg27.7%
distribute-lft-in27.7%
metadata-eval27.7%
metadata-eval27.7%
metadata-eval27.7%
fma-define27.7%
metadata-eval27.7%
Simplified27.7%
Taylor expanded in n around inf 47.1%
sub-neg47.1%
metadata-eval47.1%
metadata-eval47.1%
distribute-lft-in47.1%
metadata-eval47.1%
sub-neg47.1%
expm1-define93.7%
Simplified93.7%
clear-num93.7%
un-div-inv93.6%
*-un-lft-identity93.6%
times-frac93.7%
metadata-eval93.7%
Applied egg-rr93.7%
*-rgt-identity93.7%
*-commutative93.7%
times-frac93.8%
metadata-eval93.8%
Simplified93.8%
Taylor expanded in n around 0 47.1%
expm1-define93.8%
associate-*r/93.8%
associate-*l*93.7%
Simplified93.7%
Taylor expanded in i around 0 80.5%
*-commutative80.5%
Simplified80.5%
Final simplification71.2%
(FPCore (i n)
:precision binary64
(if (or (<= n -7.2e+180) (not (<= n 1.05)))
(*
n
(+
100.0
(* i (+ 50.0 (* i (+ 16.666666666666668 (* i 4.166666666666667)))))))
(* 100.0 (/ n (+ 1.0 (* i (- (* i 0.08333333333333333) 0.5)))))))
double code(double i, double n) {
double tmp;
if ((n <= -7.2e+180) || !(n <= 1.05)) {
tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667))))));
} else {
tmp = 100.0 * (n / (1.0 + (i * ((i * 0.08333333333333333) - 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 <= (-7.2d+180)) .or. (.not. (n <= 1.05d0))) then
tmp = n * (100.0d0 + (i * (50.0d0 + (i * (16.666666666666668d0 + (i * 4.166666666666667d0))))))
else
tmp = 100.0d0 * (n / (1.0d0 + (i * ((i * 0.08333333333333333d0) - 0.5d0))))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if ((n <= -7.2e+180) || !(n <= 1.05)) {
tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667))))));
} else {
tmp = 100.0 * (n / (1.0 + (i * ((i * 0.08333333333333333) - 0.5))));
}
return tmp;
}
def code(i, n): tmp = 0 if (n <= -7.2e+180) or not (n <= 1.05): tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667)))))) else: tmp = 100.0 * (n / (1.0 + (i * ((i * 0.08333333333333333) - 0.5)))) return tmp
function code(i, n) tmp = 0.0 if ((n <= -7.2e+180) || !(n <= 1.05)) 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(n / Float64(1.0 + Float64(i * Float64(Float64(i * 0.08333333333333333) - 0.5))))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if ((n <= -7.2e+180) || ~((n <= 1.05))) tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667)))))); else tmp = 100.0 * (n / (1.0 + (i * ((i * 0.08333333333333333) - 0.5)))); end tmp_2 = tmp; end
code[i_, n_] := If[Or[LessEqual[n, -7.2e+180], N[Not[LessEqual[n, 1.05]], $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 / N[(1.0 + N[(i * N[(N[(i * 0.08333333333333333), $MachinePrecision] - 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -7.2 \cdot 10^{+180} \lor \neg \left(n \leq 1.05\right):\\
\;\;\;\;n \cdot \left(100 + i \cdot \left(50 + i \cdot \left(16.666666666666668 + i \cdot 4.166666666666667\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;100 \cdot \frac{n}{1 + i \cdot \left(i \cdot 0.08333333333333333 - 0.5\right)}\\
\end{array}
\end{array}
if n < -7.2000000000000004e180 or 1.05000000000000004 < n Initial program 19.2%
associate-/r/19.8%
associate-*r*19.8%
*-commutative19.8%
associate-*r/19.8%
sub-neg19.8%
distribute-lft-in19.8%
metadata-eval19.8%
metadata-eval19.8%
metadata-eval19.8%
fma-define19.8%
metadata-eval19.8%
Simplified19.8%
Taylor expanded in n around inf 46.4%
sub-neg46.4%
metadata-eval46.4%
metadata-eval46.4%
distribute-lft-in46.3%
metadata-eval46.3%
sub-neg46.3%
expm1-define94.4%
Simplified94.4%
Taylor expanded in i around 0 79.5%
*-commutative79.5%
Simplified79.5%
if -7.2000000000000004e180 < n < 1.05000000000000004Initial program 28.6%
associate-/r/28.8%
associate-*r*28.8%
*-commutative28.8%
associate-*r/28.9%
sub-neg28.9%
distribute-lft-in28.8%
metadata-eval28.8%
metadata-eval28.8%
metadata-eval28.8%
fma-define28.9%
metadata-eval28.9%
Simplified28.9%
Taylor expanded in n around inf 19.6%
sub-neg19.6%
metadata-eval19.6%
metadata-eval19.6%
distribute-lft-in19.6%
metadata-eval19.6%
sub-neg19.6%
expm1-define66.3%
Simplified66.3%
clear-num66.4%
un-div-inv66.3%
*-un-lft-identity66.3%
times-frac66.3%
metadata-eval66.3%
Applied egg-rr66.3%
*-rgt-identity66.3%
*-commutative66.3%
times-frac66.4%
metadata-eval66.4%
Simplified66.4%
Taylor expanded in i around 0 64.9%
Final simplification71.2%
(FPCore (i n) :precision binary64 (if (or (<= n -5.2e+153) (not (<= n 1.0))) (* n (+ 100.0 (* i (+ 50.0 (* i 16.666666666666668))))) (* 100.0 (/ n (+ 1.0 (* i (- (* i 0.08333333333333333) 0.5)))))))
double code(double i, double n) {
double tmp;
if ((n <= -5.2e+153) || !(n <= 1.0)) {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
} else {
tmp = 100.0 * (n / (1.0 + (i * ((i * 0.08333333333333333) - 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 <= (-5.2d+153)) .or. (.not. (n <= 1.0d0))) then
tmp = n * (100.0d0 + (i * (50.0d0 + (i * 16.666666666666668d0))))
else
tmp = 100.0d0 * (n / (1.0d0 + (i * ((i * 0.08333333333333333d0) - 0.5d0))))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if ((n <= -5.2e+153) || !(n <= 1.0)) {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
} else {
tmp = 100.0 * (n / (1.0 + (i * ((i * 0.08333333333333333) - 0.5))));
}
return tmp;
}
def code(i, n): tmp = 0 if (n <= -5.2e+153) or not (n <= 1.0): tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))) else: tmp = 100.0 * (n / (1.0 + (i * ((i * 0.08333333333333333) - 0.5)))) return tmp
function code(i, n) tmp = 0.0 if ((n <= -5.2e+153) || !(n <= 1.0)) tmp = Float64(n * Float64(100.0 + Float64(i * Float64(50.0 + Float64(i * 16.666666666666668))))); else tmp = Float64(100.0 * Float64(n / Float64(1.0 + Float64(i * Float64(Float64(i * 0.08333333333333333) - 0.5))))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if ((n <= -5.2e+153) || ~((n <= 1.0))) tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))); else tmp = 100.0 * (n / (1.0 + (i * ((i * 0.08333333333333333) - 0.5)))); end tmp_2 = tmp; end
code[i_, n_] := If[Or[LessEqual[n, -5.2e+153], N[Not[LessEqual[n, 1.0]], $MachinePrecision]], N[(n * N[(100.0 + N[(i * N[(50.0 + N[(i * 16.666666666666668), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(100.0 * N[(n / N[(1.0 + N[(i * N[(N[(i * 0.08333333333333333), $MachinePrecision] - 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -5.2 \cdot 10^{+153} \lor \neg \left(n \leq 1\right):\\
\;\;\;\;n \cdot \left(100 + i \cdot \left(50 + i \cdot 16.666666666666668\right)\right)\\
\mathbf{else}:\\
\;\;\;\;100 \cdot \frac{n}{1 + i \cdot \left(i \cdot 0.08333333333333333 - 0.5\right)}\\
\end{array}
\end{array}
if n < -5.1999999999999998e153 or 1 < n Initial program 18.8%
associate-/r/19.4%
associate-*r*19.4%
*-commutative19.4%
associate-*r/19.4%
sub-neg19.4%
distribute-lft-in19.4%
metadata-eval19.4%
metadata-eval19.4%
metadata-eval19.4%
fma-define19.4%
metadata-eval19.4%
Simplified19.4%
Taylor expanded in n around inf 46.7%
sub-neg46.7%
metadata-eval46.7%
metadata-eval46.7%
distribute-lft-in46.7%
metadata-eval46.7%
sub-neg46.7%
expm1-define94.8%
Simplified94.8%
Taylor expanded in i around 0 74.1%
*-commutative74.1%
Simplified74.1%
if -5.1999999999999998e153 < n < 1Initial program 29.5%
associate-/r/29.6%
associate-*r*29.7%
*-commutative29.7%
associate-*r/29.7%
sub-neg29.7%
distribute-lft-in29.7%
metadata-eval29.7%
metadata-eval29.7%
metadata-eval29.7%
fma-define29.7%
metadata-eval29.7%
Simplified29.7%
Taylor expanded in n around inf 17.8%
sub-neg17.8%
metadata-eval17.8%
metadata-eval17.8%
distribute-lft-in17.8%
metadata-eval17.8%
sub-neg17.8%
expm1-define64.4%
Simplified64.4%
clear-num64.4%
un-div-inv64.3%
*-un-lft-identity64.3%
times-frac64.4%
metadata-eval64.4%
Applied egg-rr64.4%
*-rgt-identity64.4%
*-commutative64.4%
times-frac64.5%
metadata-eval64.5%
Simplified64.5%
Taylor expanded in i around 0 65.6%
Final simplification69.5%
(FPCore (i n)
:precision binary64
(let* ((t_0 (+ 50.0 (* i 16.666666666666668))))
(if (<= n -4.1e+154)
(* n (+ 100.0 (* i t_0)))
(if (<= n 1.0)
(* 100.0 (/ n (+ 1.0 (* i (- (* i 0.08333333333333333) 0.5)))))
(+ (* n 100.0) (* i (* n t_0)))))))
double code(double i, double n) {
double t_0 = 50.0 + (i * 16.666666666666668);
double tmp;
if (n <= -4.1e+154) {
tmp = n * (100.0 + (i * t_0));
} else if (n <= 1.0) {
tmp = 100.0 * (n / (1.0 + (i * ((i * 0.08333333333333333) - 0.5))));
} else {
tmp = (n * 100.0) + (i * (n * 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 = 50.0d0 + (i * 16.666666666666668d0)
if (n <= (-4.1d+154)) then
tmp = n * (100.0d0 + (i * t_0))
else if (n <= 1.0d0) then
tmp = 100.0d0 * (n / (1.0d0 + (i * ((i * 0.08333333333333333d0) - 0.5d0))))
else
tmp = (n * 100.0d0) + (i * (n * t_0))
end if
code = tmp
end function
public static double code(double i, double n) {
double t_0 = 50.0 + (i * 16.666666666666668);
double tmp;
if (n <= -4.1e+154) {
tmp = n * (100.0 + (i * t_0));
} else if (n <= 1.0) {
tmp = 100.0 * (n / (1.0 + (i * ((i * 0.08333333333333333) - 0.5))));
} else {
tmp = (n * 100.0) + (i * (n * t_0));
}
return tmp;
}
def code(i, n): t_0 = 50.0 + (i * 16.666666666666668) tmp = 0 if n <= -4.1e+154: tmp = n * (100.0 + (i * t_0)) elif n <= 1.0: tmp = 100.0 * (n / (1.0 + (i * ((i * 0.08333333333333333) - 0.5)))) else: tmp = (n * 100.0) + (i * (n * t_0)) return tmp
function code(i, n) t_0 = Float64(50.0 + Float64(i * 16.666666666666668)) tmp = 0.0 if (n <= -4.1e+154) tmp = Float64(n * Float64(100.0 + Float64(i * t_0))); elseif (n <= 1.0) tmp = Float64(100.0 * Float64(n / Float64(1.0 + Float64(i * Float64(Float64(i * 0.08333333333333333) - 0.5))))); else tmp = Float64(Float64(n * 100.0) + Float64(i * Float64(n * t_0))); end return tmp end
function tmp_2 = code(i, n) t_0 = 50.0 + (i * 16.666666666666668); tmp = 0.0; if (n <= -4.1e+154) tmp = n * (100.0 + (i * t_0)); elseif (n <= 1.0) tmp = 100.0 * (n / (1.0 + (i * ((i * 0.08333333333333333) - 0.5)))); else tmp = (n * 100.0) + (i * (n * t_0)); end tmp_2 = tmp; end
code[i_, n_] := Block[{t$95$0 = N[(50.0 + N[(i * 16.666666666666668), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[n, -4.1e+154], N[(n * N[(100.0 + N[(i * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 1.0], N[(100.0 * N[(n / N[(1.0 + N[(i * N[(N[(i * 0.08333333333333333), $MachinePrecision] - 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(n * 100.0), $MachinePrecision] + N[(i * N[(n * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 50 + i \cdot 16.666666666666668\\
\mathbf{if}\;n \leq -4.1 \cdot 10^{+154}:\\
\;\;\;\;n \cdot \left(100 + i \cdot t\_0\right)\\
\mathbf{elif}\;n \leq 1:\\
\;\;\;\;100 \cdot \frac{n}{1 + i \cdot \left(i \cdot 0.08333333333333333 - 0.5\right)}\\
\mathbf{else}:\\
\;\;\;\;n \cdot 100 + i \cdot \left(n \cdot t\_0\right)\\
\end{array}
\end{array}
if n < -4.1e154Initial program 8.5%
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 n around inf 46.2%
sub-neg46.2%
metadata-eval46.2%
metadata-eval46.2%
distribute-lft-in46.2%
metadata-eval46.2%
sub-neg46.2%
expm1-define96.1%
Simplified96.1%
Taylor expanded in i around 0 73.1%
*-commutative73.1%
Simplified73.1%
if -4.1e154 < n < 1Initial program 29.5%
associate-/r/29.6%
associate-*r*29.7%
*-commutative29.7%
associate-*r/29.7%
sub-neg29.7%
distribute-lft-in29.7%
metadata-eval29.7%
metadata-eval29.7%
metadata-eval29.7%
fma-define29.7%
metadata-eval29.7%
Simplified29.7%
Taylor expanded in n around inf 17.8%
sub-neg17.8%
metadata-eval17.8%
metadata-eval17.8%
distribute-lft-in17.8%
metadata-eval17.8%
sub-neg17.8%
expm1-define64.4%
Simplified64.4%
clear-num64.4%
un-div-inv64.3%
*-un-lft-identity64.3%
times-frac64.4%
metadata-eval64.4%
Applied egg-rr64.4%
*-rgt-identity64.4%
*-commutative64.4%
times-frac64.5%
metadata-eval64.5%
Simplified64.5%
Taylor expanded in i around 0 65.6%
if 1 < n Initial program 27.2%
associate-/r/27.7%
associate-*r*27.7%
*-commutative27.7%
associate-*r/27.7%
sub-neg27.7%
distribute-lft-in27.7%
metadata-eval27.7%
metadata-eval27.7%
metadata-eval27.7%
fma-define27.7%
metadata-eval27.7%
Simplified27.7%
Taylor expanded in n around inf 47.1%
sub-neg47.1%
metadata-eval47.1%
metadata-eval47.1%
distribute-lft-in47.1%
metadata-eval47.1%
sub-neg47.1%
expm1-define93.7%
Simplified93.7%
Taylor expanded in i around 0 80.5%
Taylor expanded in i around 0 74.9%
associate-*r*74.9%
distribute-rgt-out74.9%
*-commutative74.9%
Simplified74.9%
Final simplification69.5%
(FPCore (i n) :precision binary64 (if (or (<= n -8.5e+126) (not (<= n 1.1))) (* n (+ 100.0 (* i (+ 50.0 (* i 16.666666666666668))))) (* 100.0 (/ n (+ 1.0 (* i (* i 0.08333333333333333)))))))
double code(double i, double n) {
double tmp;
if ((n <= -8.5e+126) || !(n <= 1.1)) {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
} else {
tmp = 100.0 * (n / (1.0 + (i * (i * 0.08333333333333333))));
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if ((n <= (-8.5d+126)) .or. (.not. (n <= 1.1d0))) then
tmp = n * (100.0d0 + (i * (50.0d0 + (i * 16.666666666666668d0))))
else
tmp = 100.0d0 * (n / (1.0d0 + (i * (i * 0.08333333333333333d0))))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if ((n <= -8.5e+126) || !(n <= 1.1)) {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
} else {
tmp = 100.0 * (n / (1.0 + (i * (i * 0.08333333333333333))));
}
return tmp;
}
def code(i, n): tmp = 0 if (n <= -8.5e+126) or not (n <= 1.1): tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))) else: tmp = 100.0 * (n / (1.0 + (i * (i * 0.08333333333333333)))) return tmp
function code(i, n) tmp = 0.0 if ((n <= -8.5e+126) || !(n <= 1.1)) tmp = Float64(n * Float64(100.0 + Float64(i * Float64(50.0 + Float64(i * 16.666666666666668))))); else tmp = Float64(100.0 * Float64(n / Float64(1.0 + Float64(i * Float64(i * 0.08333333333333333))))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if ((n <= -8.5e+126) || ~((n <= 1.1))) tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))); else tmp = 100.0 * (n / (1.0 + (i * (i * 0.08333333333333333)))); end tmp_2 = tmp; end
code[i_, n_] := If[Or[LessEqual[n, -8.5e+126], N[Not[LessEqual[n, 1.1]], $MachinePrecision]], N[(n * N[(100.0 + N[(i * N[(50.0 + N[(i * 16.666666666666668), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(100.0 * N[(n / N[(1.0 + N[(i * N[(i * 0.08333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -8.5 \cdot 10^{+126} \lor \neg \left(n \leq 1.1\right):\\
\;\;\;\;n \cdot \left(100 + i \cdot \left(50 + i \cdot 16.666666666666668\right)\right)\\
\mathbf{else}:\\
\;\;\;\;100 \cdot \frac{n}{1 + i \cdot \left(i \cdot 0.08333333333333333\right)}\\
\end{array}
\end{array}
if n < -8.49999999999999944e126 or 1.1000000000000001 < n Initial program 20.4%
associate-/r/21.0%
associate-*r*21.0%
*-commutative21.0%
associate-*r/21.0%
sub-neg21.0%
distribute-lft-in21.0%
metadata-eval21.0%
metadata-eval21.0%
metadata-eval21.0%
fma-define21.0%
metadata-eval21.0%
Simplified21.0%
Taylor expanded in n around inf 47.3%
sub-neg47.3%
metadata-eval47.3%
metadata-eval47.3%
distribute-lft-in47.3%
metadata-eval47.3%
sub-neg47.3%
expm1-define94.4%
Simplified94.4%
Taylor expanded in i around 0 71.7%
*-commutative71.7%
Simplified71.7%
if -8.49999999999999944e126 < n < 1.1000000000000001Initial program 28.8%
associate-/r/28.9%
associate-*r*29.0%
*-commutative29.0%
associate-*r/29.0%
sub-neg29.0%
distribute-lft-in29.0%
metadata-eval29.0%
metadata-eval29.0%
metadata-eval29.0%
fma-define29.0%
metadata-eval29.0%
Simplified29.0%
Taylor expanded in n around inf 14.7%
sub-neg14.7%
metadata-eval14.7%
metadata-eval14.7%
distribute-lft-in14.7%
metadata-eval14.7%
sub-neg14.7%
expm1-define62.1%
Simplified62.1%
clear-num62.1%
un-div-inv62.0%
*-un-lft-identity62.0%
times-frac62.1%
metadata-eval62.1%
Applied egg-rr62.1%
*-rgt-identity62.1%
*-commutative62.1%
times-frac62.2%
metadata-eval62.2%
Simplified62.2%
Taylor expanded in i around 0 67.2%
Taylor expanded in i around inf 67.2%
*-commutative67.2%
Simplified67.2%
Final simplification69.4%
(FPCore (i n)
:precision binary64
(if (<= n -6.2e+180)
(* n (+ 100.0 (* i 50.0)))
(if (<= n 0.7)
(* 100.0 (/ n (+ 1.0 (* i (* i 0.08333333333333333)))))
(+ (* n 100.0) (* 50.0 (* i n))))))
double code(double i, double n) {
double tmp;
if (n <= -6.2e+180) {
tmp = n * (100.0 + (i * 50.0));
} else if (n <= 0.7) {
tmp = 100.0 * (n / (1.0 + (i * (i * 0.08333333333333333))));
} else {
tmp = (n * 100.0) + (50.0 * (i * n));
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if (n <= (-6.2d+180)) then
tmp = n * (100.0d0 + (i * 50.0d0))
else if (n <= 0.7d0) then
tmp = 100.0d0 * (n / (1.0d0 + (i * (i * 0.08333333333333333d0))))
else
tmp = (n * 100.0d0) + (50.0d0 * (i * n))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if (n <= -6.2e+180) {
tmp = n * (100.0 + (i * 50.0));
} else if (n <= 0.7) {
tmp = 100.0 * (n / (1.0 + (i * (i * 0.08333333333333333))));
} else {
tmp = (n * 100.0) + (50.0 * (i * n));
}
return tmp;
}
def code(i, n): tmp = 0 if n <= -6.2e+180: tmp = n * (100.0 + (i * 50.0)) elif n <= 0.7: tmp = 100.0 * (n / (1.0 + (i * (i * 0.08333333333333333)))) else: tmp = (n * 100.0) + (50.0 * (i * n)) return tmp
function code(i, n) tmp = 0.0 if (n <= -6.2e+180) tmp = Float64(n * Float64(100.0 + Float64(i * 50.0))); elseif (n <= 0.7) tmp = Float64(100.0 * Float64(n / Float64(1.0 + Float64(i * Float64(i * 0.08333333333333333))))); else tmp = Float64(Float64(n * 100.0) + Float64(50.0 * Float64(i * n))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if (n <= -6.2e+180) tmp = n * (100.0 + (i * 50.0)); elseif (n <= 0.7) tmp = 100.0 * (n / (1.0 + (i * (i * 0.08333333333333333)))); else tmp = (n * 100.0) + (50.0 * (i * n)); end tmp_2 = tmp; end
code[i_, n_] := If[LessEqual[n, -6.2e+180], N[(n * N[(100.0 + N[(i * 50.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 0.7], N[(100.0 * N[(n / N[(1.0 + N[(i * N[(i * 0.08333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(n * 100.0), $MachinePrecision] + N[(50.0 * N[(i * n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -6.2 \cdot 10^{+180}:\\
\;\;\;\;n \cdot \left(100 + i \cdot 50\right)\\
\mathbf{elif}\;n \leq 0.7:\\
\;\;\;\;100 \cdot \frac{n}{1 + i \cdot \left(i \cdot 0.08333333333333333\right)}\\
\mathbf{else}:\\
\;\;\;\;n \cdot 100 + 50 \cdot \left(i \cdot n\right)\\
\end{array}
\end{array}
if n < -6.19999999999999997e180Initial program 7.6%
associate-/r/8.3%
associate-*r*8.3%
*-commutative8.3%
associate-*r/8.3%
sub-neg8.3%
distribute-lft-in8.3%
metadata-eval8.3%
metadata-eval8.3%
metadata-eval8.3%
fma-define8.3%
metadata-eval8.3%
Simplified8.3%
Taylor expanded in n around inf 45.3%
sub-neg45.3%
metadata-eval45.3%
metadata-eval45.3%
distribute-lft-in45.3%
metadata-eval45.3%
sub-neg45.3%
expm1-define95.4%
Simplified95.4%
Taylor expanded in i around 0 69.8%
+-commutative69.8%
associate-*r*69.8%
distribute-rgt-in69.8%
*-commutative69.8%
Simplified69.8%
if -6.19999999999999997e180 < n < 0.69999999999999996Initial program 28.6%
associate-/r/28.8%
associate-*r*28.8%
*-commutative28.8%
associate-*r/28.9%
sub-neg28.9%
distribute-lft-in28.8%
metadata-eval28.8%
metadata-eval28.8%
metadata-eval28.8%
fma-define28.9%
metadata-eval28.9%
Simplified28.9%
Taylor expanded in n around inf 19.6%
sub-neg19.6%
metadata-eval19.6%
metadata-eval19.6%
distribute-lft-in19.6%
metadata-eval19.6%
sub-neg19.6%
expm1-define66.3%
Simplified66.3%
clear-num66.4%
un-div-inv66.3%
*-un-lft-identity66.3%
times-frac66.3%
metadata-eval66.3%
Applied egg-rr66.3%
*-rgt-identity66.3%
*-commutative66.3%
times-frac66.4%
metadata-eval66.4%
Simplified66.4%
Taylor expanded in i around 0 64.9%
Taylor expanded in i around inf 64.5%
*-commutative64.5%
Simplified64.5%
if 0.69999999999999996 < n Initial program 27.2%
associate-/r/27.7%
associate-*r*27.7%
*-commutative27.7%
associate-*r/27.7%
sub-neg27.7%
distribute-lft-in27.7%
metadata-eval27.7%
metadata-eval27.7%
metadata-eval27.7%
fma-define27.7%
metadata-eval27.7%
Simplified27.7%
Taylor expanded in n around inf 47.1%
sub-neg47.1%
metadata-eval47.1%
metadata-eval47.1%
distribute-lft-in47.1%
metadata-eval47.1%
sub-neg47.1%
expm1-define93.7%
Simplified93.7%
Taylor expanded in i around 0 73.2%
Final simplification67.7%
(FPCore (i n) :precision binary64 (if (or (<= n -6.5e+180) (not (<= n 6.2e-62))) (* n (+ 100.0 (* i 50.0))) (* 100.0 (/ n (+ 1.0 (* i -0.5))))))
double code(double i, double n) {
double tmp;
if ((n <= -6.5e+180) || !(n <= 6.2e-62)) {
tmp = n * (100.0 + (i * 50.0));
} else {
tmp = 100.0 * (n / (1.0 + (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 ((n <= (-6.5d+180)) .or. (.not. (n <= 6.2d-62))) then
tmp = n * (100.0d0 + (i * 50.0d0))
else
tmp = 100.0d0 * (n / (1.0d0 + (i * (-0.5d0))))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if ((n <= -6.5e+180) || !(n <= 6.2e-62)) {
tmp = n * (100.0 + (i * 50.0));
} else {
tmp = 100.0 * (n / (1.0 + (i * -0.5)));
}
return tmp;
}
def code(i, n): tmp = 0 if (n <= -6.5e+180) or not (n <= 6.2e-62): tmp = n * (100.0 + (i * 50.0)) else: tmp = 100.0 * (n / (1.0 + (i * -0.5))) return tmp
function code(i, n) tmp = 0.0 if ((n <= -6.5e+180) || !(n <= 6.2e-62)) tmp = Float64(n * Float64(100.0 + Float64(i * 50.0))); else tmp = Float64(100.0 * Float64(n / Float64(1.0 + Float64(i * -0.5)))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if ((n <= -6.5e+180) || ~((n <= 6.2e-62))) tmp = n * (100.0 + (i * 50.0)); else tmp = 100.0 * (n / (1.0 + (i * -0.5))); end tmp_2 = tmp; end
code[i_, n_] := If[Or[LessEqual[n, -6.5e+180], N[Not[LessEqual[n, 6.2e-62]], $MachinePrecision]], N[(n * N[(100.0 + N[(i * 50.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(100.0 * N[(n / N[(1.0 + N[(i * -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -6.5 \cdot 10^{+180} \lor \neg \left(n \leq 6.2 \cdot 10^{-62}\right):\\
\;\;\;\;n \cdot \left(100 + i \cdot 50\right)\\
\mathbf{else}:\\
\;\;\;\;100 \cdot \frac{n}{1 + i \cdot -0.5}\\
\end{array}
\end{array}
if n < -6.5e180 or 6.1999999999999999e-62 < n Initial program 18.5%
associate-/r/19.0%
associate-*r*19.0%
*-commutative19.0%
associate-*r/19.0%
sub-neg19.0%
distribute-lft-in19.0%
metadata-eval19.0%
metadata-eval19.0%
metadata-eval19.0%
fma-define19.0%
metadata-eval19.0%
Simplified19.0%
Taylor expanded in n around inf 42.4%
sub-neg42.4%
metadata-eval42.4%
metadata-eval42.4%
distribute-lft-in42.4%
metadata-eval42.4%
sub-neg42.4%
expm1-define93.4%
Simplified93.4%
Taylor expanded in i around 0 72.9%
+-commutative72.9%
associate-*r*72.9%
distribute-rgt-in72.9%
*-commutative72.9%
Simplified72.9%
if -6.5e180 < n < 6.1999999999999999e-62Initial program 30.1%
associate-/r/30.2%
associate-*r*30.3%
*-commutative30.3%
associate-*r/30.3%
sub-neg30.3%
distribute-lft-in30.3%
metadata-eval30.3%
metadata-eval30.3%
metadata-eval30.3%
fma-define30.3%
metadata-eval30.3%
Simplified30.3%
Taylor expanded in n around inf 20.9%
sub-neg20.9%
metadata-eval20.9%
metadata-eval20.9%
distribute-lft-in20.9%
metadata-eval20.9%
sub-neg20.9%
expm1-define65.0%
Simplified65.0%
clear-num65.0%
un-div-inv64.9%
*-un-lft-identity64.9%
times-frac65.0%
metadata-eval65.0%
Applied egg-rr65.0%
*-rgt-identity65.0%
*-commutative65.0%
times-frac65.1%
metadata-eval65.1%
Simplified65.1%
Taylor expanded in i around 0 61.9%
*-commutative61.9%
Simplified61.9%
Final simplification67.1%
(FPCore (i n)
:precision binary64
(if (<= n -6.6e+180)
(* n (+ 100.0 (* i 50.0)))
(if (<= n 7.2e-62)
(* 100.0 (/ n (+ 1.0 (* i -0.5))))
(+ (* n 100.0) (* 50.0 (* i n))))))
double code(double i, double n) {
double tmp;
if (n <= -6.6e+180) {
tmp = n * (100.0 + (i * 50.0));
} else if (n <= 7.2e-62) {
tmp = 100.0 * (n / (1.0 + (i * -0.5)));
} else {
tmp = (n * 100.0) + (50.0 * (i * n));
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if (n <= (-6.6d+180)) then
tmp = n * (100.0d0 + (i * 50.0d0))
else if (n <= 7.2d-62) then
tmp = 100.0d0 * (n / (1.0d0 + (i * (-0.5d0))))
else
tmp = (n * 100.0d0) + (50.0d0 * (i * n))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if (n <= -6.6e+180) {
tmp = n * (100.0 + (i * 50.0));
} else if (n <= 7.2e-62) {
tmp = 100.0 * (n / (1.0 + (i * -0.5)));
} else {
tmp = (n * 100.0) + (50.0 * (i * n));
}
return tmp;
}
def code(i, n): tmp = 0 if n <= -6.6e+180: tmp = n * (100.0 + (i * 50.0)) elif n <= 7.2e-62: tmp = 100.0 * (n / (1.0 + (i * -0.5))) else: tmp = (n * 100.0) + (50.0 * (i * n)) return tmp
function code(i, n) tmp = 0.0 if (n <= -6.6e+180) tmp = Float64(n * Float64(100.0 + Float64(i * 50.0))); elseif (n <= 7.2e-62) tmp = Float64(100.0 * Float64(n / Float64(1.0 + Float64(i * -0.5)))); else tmp = Float64(Float64(n * 100.0) + Float64(50.0 * Float64(i * n))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if (n <= -6.6e+180) tmp = n * (100.0 + (i * 50.0)); elseif (n <= 7.2e-62) tmp = 100.0 * (n / (1.0 + (i * -0.5))); else tmp = (n * 100.0) + (50.0 * (i * n)); end tmp_2 = tmp; end
code[i_, n_] := If[LessEqual[n, -6.6e+180], N[(n * N[(100.0 + N[(i * 50.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 7.2e-62], N[(100.0 * N[(n / N[(1.0 + N[(i * -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(n * 100.0), $MachinePrecision] + N[(50.0 * N[(i * n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -6.6 \cdot 10^{+180}:\\
\;\;\;\;n \cdot \left(100 + i \cdot 50\right)\\
\mathbf{elif}\;n \leq 7.2 \cdot 10^{-62}:\\
\;\;\;\;100 \cdot \frac{n}{1 + i \cdot -0.5}\\
\mathbf{else}:\\
\;\;\;\;n \cdot 100 + 50 \cdot \left(i \cdot n\right)\\
\end{array}
\end{array}
if n < -6.59999999999999978e180Initial program 7.6%
associate-/r/8.3%
associate-*r*8.3%
*-commutative8.3%
associate-*r/8.3%
sub-neg8.3%
distribute-lft-in8.3%
metadata-eval8.3%
metadata-eval8.3%
metadata-eval8.3%
fma-define8.3%
metadata-eval8.3%
Simplified8.3%
Taylor expanded in n around inf 45.3%
sub-neg45.3%
metadata-eval45.3%
metadata-eval45.3%
distribute-lft-in45.3%
metadata-eval45.3%
sub-neg45.3%
expm1-define95.4%
Simplified95.4%
Taylor expanded in i around 0 69.8%
+-commutative69.8%
associate-*r*69.8%
distribute-rgt-in69.8%
*-commutative69.8%
Simplified69.8%
if -6.59999999999999978e180 < n < 7.1999999999999999e-62Initial program 30.1%
associate-/r/30.2%
associate-*r*30.3%
*-commutative30.3%
associate-*r/30.3%
sub-neg30.3%
distribute-lft-in30.3%
metadata-eval30.3%
metadata-eval30.3%
metadata-eval30.3%
fma-define30.3%
metadata-eval30.3%
Simplified30.3%
Taylor expanded in n around inf 20.9%
sub-neg20.9%
metadata-eval20.9%
metadata-eval20.9%
distribute-lft-in20.9%
metadata-eval20.9%
sub-neg20.9%
expm1-define65.0%
Simplified65.0%
clear-num65.0%
un-div-inv64.9%
*-un-lft-identity64.9%
times-frac65.0%
metadata-eval65.0%
Applied egg-rr65.0%
*-rgt-identity65.0%
*-commutative65.0%
times-frac65.1%
metadata-eval65.1%
Simplified65.1%
Taylor expanded in i around 0 61.9%
*-commutative61.9%
Simplified61.9%
if 7.1999999999999999e-62 < n Initial program 24.9%
associate-/r/25.3%
associate-*r*25.3%
*-commutative25.3%
associate-*r/25.3%
sub-neg25.3%
distribute-lft-in25.3%
metadata-eval25.3%
metadata-eval25.3%
metadata-eval25.3%
fma-define25.3%
metadata-eval25.3%
Simplified25.3%
Taylor expanded in n around inf 40.7%
sub-neg40.7%
metadata-eval40.7%
metadata-eval40.7%
distribute-lft-in40.7%
metadata-eval40.7%
sub-neg40.7%
expm1-define92.1%
Simplified92.1%
Taylor expanded in i around 0 74.7%
Final simplification67.1%
(FPCore (i n) :precision binary64 (if (or (<= n -1.15e-122) (not (<= n 8.6e-190))) (* n (+ 100.0 (* i 50.0))) 0.0))
double code(double i, double n) {
double tmp;
if ((n <= -1.15e-122) || !(n <= 8.6e-190)) {
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 <= (-1.15d-122)) .or. (.not. (n <= 8.6d-190))) 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 <= -1.15e-122) || !(n <= 8.6e-190)) {
tmp = n * (100.0 + (i * 50.0));
} else {
tmp = 0.0;
}
return tmp;
}
def code(i, n): tmp = 0 if (n <= -1.15e-122) or not (n <= 8.6e-190): tmp = n * (100.0 + (i * 50.0)) else: tmp = 0.0 return tmp
function code(i, n) tmp = 0.0 if ((n <= -1.15e-122) || !(n <= 8.6e-190)) 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 <= -1.15e-122) || ~((n <= 8.6e-190))) tmp = n * (100.0 + (i * 50.0)); else tmp = 0.0; end tmp_2 = tmp; end
code[i_, n_] := If[Or[LessEqual[n, -1.15e-122], N[Not[LessEqual[n, 8.6e-190]], $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 -1.15 \cdot 10^{-122} \lor \neg \left(n \leq 8.6 \cdot 10^{-190}\right):\\
\;\;\;\;n \cdot \left(100 + i \cdot 50\right)\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if n < -1.15000000000000003e-122 or 8.5999999999999999e-190 < n Initial program 20.4%
associate-/r/20.8%
associate-*r*20.8%
*-commutative20.8%
associate-*r/20.8%
sub-neg20.8%
distribute-lft-in20.8%
metadata-eval20.8%
metadata-eval20.8%
metadata-eval20.8%
fma-define20.8%
metadata-eval20.8%
Simplified20.8%
Taylor expanded in n around inf 31.3%
sub-neg31.3%
metadata-eval31.3%
metadata-eval31.3%
distribute-lft-in31.3%
metadata-eval31.3%
sub-neg31.3%
expm1-define84.7%
Simplified84.7%
Taylor expanded in i around 0 67.0%
+-commutative67.0%
associate-*r*67.0%
distribute-rgt-in67.0%
*-commutative67.0%
Simplified67.0%
if -1.15000000000000003e-122 < n < 8.5999999999999999e-190Initial program 50.2%
associate-*r/50.2%
sub-neg50.2%
distribute-rgt-in50.2%
metadata-eval50.2%
metadata-eval50.2%
Simplified50.2%
Taylor expanded in i around 0 61.3%
Taylor expanded in i around 0 61.3%
Final simplification66.2%
(FPCore (i n) :precision binary64 (if (<= i -7.5e-7) 0.0 (if (<= i 1e-14) (* n 100.0) 0.0)))
double code(double i, double n) {
double tmp;
if (i <= -7.5e-7) {
tmp = 0.0;
} else if (i <= 1e-14) {
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.5d-7)) then
tmp = 0.0d0
else if (i <= 1d-14) 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.5e-7) {
tmp = 0.0;
} else if (i <= 1e-14) {
tmp = n * 100.0;
} else {
tmp = 0.0;
}
return tmp;
}
def code(i, n): tmp = 0 if i <= -7.5e-7: tmp = 0.0 elif i <= 1e-14: tmp = n * 100.0 else: tmp = 0.0 return tmp
function code(i, n) tmp = 0.0 if (i <= -7.5e-7) tmp = 0.0; elseif (i <= 1e-14) 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.5e-7) tmp = 0.0; elseif (i <= 1e-14) tmp = n * 100.0; else tmp = 0.0; end tmp_2 = tmp; end
code[i_, n_] := If[LessEqual[i, -7.5e-7], 0.0, If[LessEqual[i, 1e-14], N[(n * 100.0), $MachinePrecision], 0.0]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -7.5 \cdot 10^{-7}:\\
\;\;\;\;0\\
\mathbf{elif}\;i \leq 10^{-14}:\\
\;\;\;\;n \cdot 100\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if i < -7.5000000000000002e-7 or 9.99999999999999999e-15 < i Initial program 50.9%
associate-*r/51.0%
sub-neg51.0%
distribute-rgt-in51.0%
metadata-eval51.0%
metadata-eval51.0%
Simplified51.0%
Taylor expanded in i around 0 21.6%
Taylor expanded in i around 0 21.6%
if -7.5000000000000002e-7 < i < 9.99999999999999999e-15Initial program 5.3%
Taylor expanded in i around 0 88.0%
*-commutative88.0%
Simplified88.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.6%
associate-*r/24.6%
sub-neg24.6%
distribute-rgt-in24.6%
metadata-eval24.6%
metadata-eval24.6%
Simplified24.6%
Taylor expanded in i around 0 12.2%
Taylor expanded in i around 0 12.5%
(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 2024137
(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))))