
(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 16 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (i n) :precision binary64 (* 100.0 (/ (- (pow (+ 1.0 (/ i n)) n) 1.0) (/ i n))))
double code(double i, double n) {
return 100.0 * ((pow((1.0 + (i / n)), n) - 1.0) / (i / n));
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
code = 100.0d0 * ((((1.0d0 + (i / n)) ** n) - 1.0d0) / (i / n))
end function
public static double code(double i, double n) {
return 100.0 * ((Math.pow((1.0 + (i / n)), n) - 1.0) / (i / n));
}
def code(i, n): return 100.0 * ((math.pow((1.0 + (i / n)), n) - 1.0) / (i / n))
function code(i, n) return Float64(100.0 * Float64(Float64((Float64(1.0 + Float64(i / n)) ^ n) - 1.0) / Float64(i / n))) end
function tmp = code(i, n) tmp = 100.0 * ((((1.0 + (i / n)) ^ n) - 1.0) / (i / n)); end
code[i_, n_] := N[(100.0 * N[(N[(N[Power[N[(1.0 + N[(i / n), $MachinePrecision]), $MachinePrecision], n], $MachinePrecision] - 1.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
100 \cdot \frac{{\left(1 + \frac{i}{n}\right)}^{n} - 1}{\frac{i}{n}}
\end{array}
(FPCore (i n)
:precision binary64
(let* ((t_0 (pow (+ 1.0 (/ i n)) n)) (t_1 (/ (+ t_0 -1.0) (/ i n))))
(if (<= t_1 0.0)
(/ n (/ i (* (expm1 (* n (log1p (/ i n)))) 100.0)))
(if (<= t_1 INFINITY)
(/ (+ (* 100.0 (+ (+ 1.0 t_0) -1.0)) -100.0) (/ i n))
(* 100.0 (/ n (+ 1.0 (* i -0.5))))))))
double code(double i, double n) {
double t_0 = pow((1.0 + (i / n)), n);
double t_1 = (t_0 + -1.0) / (i / n);
double tmp;
if (t_1 <= 0.0) {
tmp = n / (i / (expm1((n * log1p((i / n)))) * 100.0));
} else if (t_1 <= ((double) INFINITY)) {
tmp = ((100.0 * ((1.0 + t_0) + -1.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((1.0 + (i / n)), n);
double t_1 = (t_0 + -1.0) / (i / n);
double tmp;
if (t_1 <= 0.0) {
tmp = n / (i / (Math.expm1((n * Math.log1p((i / n)))) * 100.0));
} else if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = ((100.0 * ((1.0 + t_0) + -1.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((1.0 + (i / n)), n) t_1 = (t_0 + -1.0) / (i / n) tmp = 0 if t_1 <= 0.0: tmp = n / (i / (math.expm1((n * math.log1p((i / n)))) * 100.0)) elif t_1 <= math.inf: tmp = ((100.0 * ((1.0 + t_0) + -1.0)) + -100.0) / (i / n) else: tmp = 100.0 * (n / (1.0 + (i * -0.5))) return tmp
function code(i, n) t_0 = Float64(1.0 + Float64(i / n)) ^ n t_1 = Float64(Float64(t_0 + -1.0) / Float64(i / n)) tmp = 0.0 if (t_1 <= 0.0) tmp = Float64(n / Float64(i / Float64(expm1(Float64(n * log1p(Float64(i / n)))) * 100.0))); elseif (t_1 <= Inf) tmp = Float64(Float64(Float64(100.0 * Float64(Float64(1.0 + t_0) + -1.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[(1.0 + N[(i / n), $MachinePrecision]), $MachinePrecision], n], $MachinePrecision]}, Block[{t$95$1 = N[(N[(t$95$0 + -1.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 0.0], N[(n / N[(i / N[(N[(Exp[N[(n * N[Log[1 + N[(i / n), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision] * 100.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[(N[(100.0 * N[(N[(1.0 + t$95$0), $MachinePrecision] + -1.0), $MachinePrecision]), $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(1 + \frac{i}{n}\right)}^{n}\\
t_1 := \frac{t\_0 + -1}{\frac{i}{n}}\\
\mathbf{if}\;t\_1 \leq 0:\\
\;\;\;\;\frac{n}{\frac{i}{\mathsf{expm1}\left(n \cdot \mathsf{log1p}\left(\frac{i}{n}\right)\right) \cdot 100}}\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\frac{100 \cdot \left(\left(1 + t\_0\right) + -1\right) + -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)) < 0.0Initial program 25.1%
associate-/r/24.8%
associate-*r*24.8%
*-commutative24.8%
associate-*r/24.8%
sub-neg24.8%
distribute-lft-in24.8%
metadata-eval24.8%
metadata-eval24.8%
metadata-eval24.8%
fma-define24.8%
metadata-eval24.8%
Simplified24.8%
fma-undefine24.8%
metadata-eval24.8%
metadata-eval24.8%
distribute-lft-in24.8%
sub-neg24.8%
*-commutative24.8%
add-exp-log24.8%
expm1-define24.8%
log-pow37.3%
log1p-define98.1%
Applied egg-rr98.1%
clear-num98.1%
un-div-inv98.2%
Applied egg-rr98.2%
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 95.8%
associate-*r/96.0%
sub-neg96.0%
distribute-rgt-in96.1%
metadata-eval96.1%
metadata-eval96.1%
Simplified96.1%
expm1-log1p-u96.1%
expm1-undefine95.9%
log1p-undefine96.1%
+-commutative96.1%
add-exp-log96.1%
+-commutative96.1%
Applied egg-rr96.1%
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/2.0%
associate-*r*2.0%
*-commutative2.0%
associate-*r/2.0%
sub-neg2.0%
distribute-lft-in2.0%
metadata-eval2.0%
metadata-eval2.0%
metadata-eval2.0%
fma-define2.0%
metadata-eval2.0%
Simplified2.0%
Taylor expanded in n around inf 2.0%
associate-/l*2.0%
sub-neg2.0%
metadata-eval2.0%
metadata-eval2.0%
distribute-lft-in2.0%
metadata-eval2.0%
sub-neg2.0%
associate-*r/2.0%
*-commutative2.0%
expm1-define88.6%
Simplified88.6%
pow188.6%
*-commutative88.6%
clear-num88.6%
un-div-inv88.6%
Applied egg-rr88.6%
unpow188.6%
associate-*r/88.6%
*-commutative88.6%
Simplified88.6%
Taylor expanded in i around 0 100.0%
*-commutative100.0%
Simplified100.0%
Taylor expanded in n around 0 100.0%
Final simplification98.3%
(FPCore (i n)
:precision binary64
(let* ((t_0 (pow (+ 1.0 (/ i n)) n)) (t_1 (/ (+ t_0 -1.0) (/ i n))))
(if (<= t_1 0.0)
(* n (/ (* (expm1 (* n (log1p (/ i n)))) 100.0) i))
(if (<= t_1 INFINITY)
(/ (+ (* 100.0 (+ (+ 1.0 t_0) -1.0)) -100.0) (/ i n))
(* 100.0 (/ n (+ 1.0 (* i -0.5))))))))
double code(double i, double n) {
double t_0 = pow((1.0 + (i / n)), n);
double t_1 = (t_0 + -1.0) / (i / n);
double tmp;
if (t_1 <= 0.0) {
tmp = n * ((expm1((n * log1p((i / n)))) * 100.0) / i);
} else if (t_1 <= ((double) INFINITY)) {
tmp = ((100.0 * ((1.0 + t_0) + -1.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((1.0 + (i / n)), n);
double t_1 = (t_0 + -1.0) / (i / n);
double tmp;
if (t_1 <= 0.0) {
tmp = n * ((Math.expm1((n * Math.log1p((i / n)))) * 100.0) / i);
} else if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = ((100.0 * ((1.0 + t_0) + -1.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((1.0 + (i / n)), n) t_1 = (t_0 + -1.0) / (i / n) tmp = 0 if t_1 <= 0.0: tmp = n * ((math.expm1((n * math.log1p((i / n)))) * 100.0) / i) elif t_1 <= math.inf: tmp = ((100.0 * ((1.0 + t_0) + -1.0)) + -100.0) / (i / n) else: tmp = 100.0 * (n / (1.0 + (i * -0.5))) return tmp
function code(i, n) t_0 = Float64(1.0 + Float64(i / n)) ^ n t_1 = Float64(Float64(t_0 + -1.0) / Float64(i / n)) tmp = 0.0 if (t_1 <= 0.0) tmp = Float64(n * Float64(Float64(expm1(Float64(n * log1p(Float64(i / n)))) * 100.0) / i)); elseif (t_1 <= Inf) tmp = Float64(Float64(Float64(100.0 * Float64(Float64(1.0 + t_0) + -1.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[(1.0 + N[(i / n), $MachinePrecision]), $MachinePrecision], n], $MachinePrecision]}, Block[{t$95$1 = N[(N[(t$95$0 + -1.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 0.0], N[(n * N[(N[(N[(Exp[N[(n * N[Log[1 + N[(i / n), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision] * 100.0), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[(N[(100.0 * N[(N[(1.0 + t$95$0), $MachinePrecision] + -1.0), $MachinePrecision]), $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(1 + \frac{i}{n}\right)}^{n}\\
t_1 := \frac{t\_0 + -1}{\frac{i}{n}}\\
\mathbf{if}\;t\_1 \leq 0:\\
\;\;\;\;n \cdot \frac{\mathsf{expm1}\left(n \cdot \mathsf{log1p}\left(\frac{i}{n}\right)\right) \cdot 100}{i}\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\frac{100 \cdot \left(\left(1 + t\_0\right) + -1\right) + -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)) < 0.0Initial program 25.1%
associate-/r/24.8%
associate-*r*24.8%
*-commutative24.8%
associate-*r/24.8%
sub-neg24.8%
distribute-lft-in24.8%
metadata-eval24.8%
metadata-eval24.8%
metadata-eval24.8%
fma-define24.8%
metadata-eval24.8%
Simplified24.8%
fma-undefine24.8%
metadata-eval24.8%
metadata-eval24.8%
distribute-lft-in24.8%
sub-neg24.8%
*-commutative24.8%
add-exp-log24.8%
expm1-define24.8%
log-pow37.3%
log1p-define98.1%
Applied egg-rr98.1%
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 95.8%
associate-*r/96.0%
sub-neg96.0%
distribute-rgt-in96.1%
metadata-eval96.1%
metadata-eval96.1%
Simplified96.1%
expm1-log1p-u96.1%
expm1-undefine95.9%
log1p-undefine96.1%
+-commutative96.1%
add-exp-log96.1%
+-commutative96.1%
Applied egg-rr96.1%
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/2.0%
associate-*r*2.0%
*-commutative2.0%
associate-*r/2.0%
sub-neg2.0%
distribute-lft-in2.0%
metadata-eval2.0%
metadata-eval2.0%
metadata-eval2.0%
fma-define2.0%
metadata-eval2.0%
Simplified2.0%
Taylor expanded in n around inf 2.0%
associate-/l*2.0%
sub-neg2.0%
metadata-eval2.0%
metadata-eval2.0%
distribute-lft-in2.0%
metadata-eval2.0%
sub-neg2.0%
associate-*r/2.0%
*-commutative2.0%
expm1-define88.6%
Simplified88.6%
pow188.6%
*-commutative88.6%
clear-num88.6%
un-div-inv88.6%
Applied egg-rr88.6%
unpow188.6%
associate-*r/88.6%
*-commutative88.6%
Simplified88.6%
Taylor expanded in i around 0 100.0%
*-commutative100.0%
Simplified100.0%
Taylor expanded in n around 0 100.0%
Final simplification98.3%
(FPCore (i n)
:precision binary64
(let* ((t_0 (pow (+ 1.0 (/ i n)) n)) (t_1 (/ (+ t_0 -1.0) (/ i n))))
(if (<= t_1 0.0)
(* n (* (expm1 (* n (log1p (/ i n)))) (/ 100.0 i)))
(if (<= t_1 INFINITY)
(/ (+ (* 100.0 (+ (+ 1.0 t_0) -1.0)) -100.0) (/ i n))
(* 100.0 (/ n (+ 1.0 (* i -0.5))))))))
double code(double i, double n) {
double t_0 = pow((1.0 + (i / n)), n);
double t_1 = (t_0 + -1.0) / (i / n);
double tmp;
if (t_1 <= 0.0) {
tmp = n * (expm1((n * log1p((i / n)))) * (100.0 / i));
} else if (t_1 <= ((double) INFINITY)) {
tmp = ((100.0 * ((1.0 + t_0) + -1.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((1.0 + (i / n)), n);
double t_1 = (t_0 + -1.0) / (i / n);
double tmp;
if (t_1 <= 0.0) {
tmp = n * (Math.expm1((n * Math.log1p((i / n)))) * (100.0 / i));
} else if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = ((100.0 * ((1.0 + t_0) + -1.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((1.0 + (i / n)), n) t_1 = (t_0 + -1.0) / (i / n) tmp = 0 if t_1 <= 0.0: tmp = n * (math.expm1((n * math.log1p((i / n)))) * (100.0 / i)) elif t_1 <= math.inf: tmp = ((100.0 * ((1.0 + t_0) + -1.0)) + -100.0) / (i / n) else: tmp = 100.0 * (n / (1.0 + (i * -0.5))) return tmp
function code(i, n) t_0 = Float64(1.0 + Float64(i / n)) ^ n t_1 = Float64(Float64(t_0 + -1.0) / Float64(i / n)) tmp = 0.0 if (t_1 <= 0.0) tmp = Float64(n * Float64(expm1(Float64(n * log1p(Float64(i / n)))) * Float64(100.0 / i))); elseif (t_1 <= Inf) tmp = Float64(Float64(Float64(100.0 * Float64(Float64(1.0 + t_0) + -1.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[(1.0 + N[(i / n), $MachinePrecision]), $MachinePrecision], n], $MachinePrecision]}, Block[{t$95$1 = N[(N[(t$95$0 + -1.0), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 0.0], N[(n * N[(N[(Exp[N[(n * N[Log[1 + N[(i / n), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision] * N[(100.0 / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[(N[(100.0 * N[(N[(1.0 + t$95$0), $MachinePrecision] + -1.0), $MachinePrecision]), $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(1 + \frac{i}{n}\right)}^{n}\\
t_1 := \frac{t\_0 + -1}{\frac{i}{n}}\\
\mathbf{if}\;t\_1 \leq 0:\\
\;\;\;\;n \cdot \left(\mathsf{expm1}\left(n \cdot \mathsf{log1p}\left(\frac{i}{n}\right)\right) \cdot \frac{100}{i}\right)\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\frac{100 \cdot \left(\left(1 + t\_0\right) + -1\right) + -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)) < 0.0Initial program 25.1%
associate-/r/24.8%
associate-*r*24.8%
*-commutative24.8%
associate-*r/24.8%
sub-neg24.8%
distribute-lft-in24.8%
metadata-eval24.8%
metadata-eval24.8%
metadata-eval24.8%
fma-define24.8%
metadata-eval24.8%
Simplified24.8%
fma-undefine24.8%
metadata-eval24.8%
metadata-eval24.8%
distribute-lft-in24.8%
sub-neg24.8%
*-commutative24.8%
add-exp-log24.8%
expm1-define24.8%
log-pow37.3%
log1p-define98.1%
Applied egg-rr98.1%
associate-/l*97.6%
Applied egg-rr97.6%
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 95.8%
associate-*r/96.0%
sub-neg96.0%
distribute-rgt-in96.1%
metadata-eval96.1%
metadata-eval96.1%
Simplified96.1%
expm1-log1p-u96.1%
expm1-undefine95.9%
log1p-undefine96.1%
+-commutative96.1%
add-exp-log96.1%
+-commutative96.1%
Applied egg-rr96.1%
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/2.0%
associate-*r*2.0%
*-commutative2.0%
associate-*r/2.0%
sub-neg2.0%
distribute-lft-in2.0%
metadata-eval2.0%
metadata-eval2.0%
metadata-eval2.0%
fma-define2.0%
metadata-eval2.0%
Simplified2.0%
Taylor expanded in n around inf 2.0%
associate-/l*2.0%
sub-neg2.0%
metadata-eval2.0%
metadata-eval2.0%
distribute-lft-in2.0%
metadata-eval2.0%
sub-neg2.0%
associate-*r/2.0%
*-commutative2.0%
expm1-define88.6%
Simplified88.6%
pow188.6%
*-commutative88.6%
clear-num88.6%
un-div-inv88.6%
Applied egg-rr88.6%
unpow188.6%
associate-*r/88.6%
*-commutative88.6%
Simplified88.6%
Taylor expanded in i around 0 100.0%
*-commutative100.0%
Simplified100.0%
Taylor expanded in n around 0 100.0%
Final simplification97.9%
(FPCore (i n) :precision binary64 (if (or (<= n -3.8e-5) (not (<= n 1.85))) (/ (* n 100.0) (/ i (expm1 i))) (/ n (+ 0.01 (* 0.01 (* i (+ -0.5 (/ 0.5 n))))))))
double code(double i, double n) {
double tmp;
if ((n <= -3.8e-5) || !(n <= 1.85)) {
tmp = (n * 100.0) / (i / expm1(i));
} else {
tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n)))));
}
return tmp;
}
public static double code(double i, double n) {
double tmp;
if ((n <= -3.8e-5) || !(n <= 1.85)) {
tmp = (n * 100.0) / (i / Math.expm1(i));
} else {
tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n)))));
}
return tmp;
}
def code(i, n): tmp = 0 if (n <= -3.8e-5) or not (n <= 1.85): tmp = (n * 100.0) / (i / math.expm1(i)) else: tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n))))) return tmp
function code(i, n) tmp = 0.0 if ((n <= -3.8e-5) || !(n <= 1.85)) tmp = Float64(Float64(n * 100.0) / Float64(i / expm1(i))); else tmp = Float64(n / Float64(0.01 + Float64(0.01 * Float64(i * Float64(-0.5 + Float64(0.5 / n)))))); end return tmp end
code[i_, n_] := If[Or[LessEqual[n, -3.8e-5], N[Not[LessEqual[n, 1.85]], $MachinePrecision]], N[(N[(n * 100.0), $MachinePrecision] / N[(i / N[(Exp[i] - 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(n / N[(0.01 + N[(0.01 * N[(i * N[(-0.5 + N[(0.5 / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -3.8 \cdot 10^{-5} \lor \neg \left(n \leq 1.85\right):\\
\;\;\;\;\frac{n \cdot 100}{\frac{i}{\mathsf{expm1}\left(i\right)}}\\
\mathbf{else}:\\
\;\;\;\;\frac{n}{0.01 + 0.01 \cdot \left(i \cdot \left(-0.5 + \frac{0.5}{n}\right)\right)}\\
\end{array}
\end{array}
if n < -3.8000000000000002e-5 or 1.8500000000000001 < n Initial program 24.2%
associate-/r/24.7%
associate-*r*24.7%
*-commutative24.7%
associate-*r/24.7%
sub-neg24.7%
distribute-lft-in24.7%
metadata-eval24.7%
metadata-eval24.7%
metadata-eval24.7%
fma-define24.7%
metadata-eval24.7%
Simplified24.7%
Taylor expanded in n around inf 37.3%
associate-/l*37.2%
sub-neg37.2%
metadata-eval37.2%
metadata-eval37.2%
distribute-lft-in37.3%
metadata-eval37.3%
sub-neg37.3%
associate-*r/37.3%
*-commutative37.3%
expm1-define92.4%
Simplified92.4%
pow192.4%
*-commutative92.4%
clear-num92.4%
un-div-inv92.4%
Applied egg-rr92.4%
unpow192.4%
associate-*r/92.4%
*-commutative92.4%
Simplified92.4%
if -3.8000000000000002e-5 < n < 1.8500000000000001Initial program 29.7%
associate-/r/29.3%
associate-*r*29.3%
*-commutative29.3%
associate-*r/29.3%
sub-neg29.3%
distribute-lft-in29.3%
metadata-eval29.3%
metadata-eval29.3%
metadata-eval29.3%
fma-define29.3%
metadata-eval29.3%
Simplified29.3%
fma-undefine29.3%
metadata-eval29.3%
metadata-eval29.3%
distribute-lft-in29.3%
sub-neg29.3%
*-commutative29.3%
add-exp-log29.3%
expm1-define29.3%
log-pow56.3%
log1p-define94.2%
Applied egg-rr94.2%
clear-num94.3%
un-div-inv94.3%
Applied egg-rr94.3%
Taylor expanded in i around 0 75.5%
sub-neg75.5%
associate-*r/75.5%
metadata-eval75.5%
metadata-eval75.5%
Simplified75.5%
Final simplification85.8%
(FPCore (i n) :precision binary64 (if (or (<= n -4.8e-5) (not (<= n 1.25))) (* n (* 100.0 (/ (expm1 i) i))) (/ n (+ 0.01 (* 0.01 (* i (+ -0.5 (/ 0.5 n))))))))
double code(double i, double n) {
double tmp;
if ((n <= -4.8e-5) || !(n <= 1.25)) {
tmp = n * (100.0 * (expm1(i) / i));
} else {
tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n)))));
}
return tmp;
}
public static double code(double i, double n) {
double tmp;
if ((n <= -4.8e-5) || !(n <= 1.25)) {
tmp = n * (100.0 * (Math.expm1(i) / i));
} else {
tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n)))));
}
return tmp;
}
def code(i, n): tmp = 0 if (n <= -4.8e-5) or not (n <= 1.25): tmp = n * (100.0 * (math.expm1(i) / i)) else: tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n))))) return tmp
function code(i, n) tmp = 0.0 if ((n <= -4.8e-5) || !(n <= 1.25)) tmp = Float64(n * Float64(100.0 * Float64(expm1(i) / i))); else tmp = Float64(n / Float64(0.01 + Float64(0.01 * Float64(i * Float64(-0.5 + Float64(0.5 / n)))))); end return tmp end
code[i_, n_] := If[Or[LessEqual[n, -4.8e-5], N[Not[LessEqual[n, 1.25]], $MachinePrecision]], N[(n * N[(100.0 * N[(N[(Exp[i] - 1), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(n / N[(0.01 + N[(0.01 * N[(i * N[(-0.5 + N[(0.5 / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -4.8 \cdot 10^{-5} \lor \neg \left(n \leq 1.25\right):\\
\;\;\;\;n \cdot \left(100 \cdot \frac{\mathsf{expm1}\left(i\right)}{i}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{n}{0.01 + 0.01 \cdot \left(i \cdot \left(-0.5 + \frac{0.5}{n}\right)\right)}\\
\end{array}
\end{array}
if n < -4.8000000000000001e-5 or 1.25 < n Initial program 24.2%
associate-/r/24.7%
associate-*r*24.7%
*-commutative24.7%
associate-*r/24.7%
sub-neg24.7%
distribute-lft-in24.7%
metadata-eval24.7%
metadata-eval24.7%
metadata-eval24.7%
fma-define24.7%
metadata-eval24.7%
Simplified24.7%
Taylor expanded in n around inf 37.3%
associate-/l*37.2%
sub-neg37.2%
metadata-eval37.2%
metadata-eval37.2%
distribute-lft-in37.3%
metadata-eval37.3%
sub-neg37.3%
associate-*r/37.3%
*-commutative37.3%
expm1-define92.4%
Simplified92.4%
if -4.8000000000000001e-5 < n < 1.25Initial program 29.7%
associate-/r/29.3%
associate-*r*29.3%
*-commutative29.3%
associate-*r/29.3%
sub-neg29.3%
distribute-lft-in29.3%
metadata-eval29.3%
metadata-eval29.3%
metadata-eval29.3%
fma-define29.3%
metadata-eval29.3%
Simplified29.3%
fma-undefine29.3%
metadata-eval29.3%
metadata-eval29.3%
distribute-lft-in29.3%
sub-neg29.3%
*-commutative29.3%
add-exp-log29.3%
expm1-define29.3%
log-pow56.3%
log1p-define94.2%
Applied egg-rr94.2%
clear-num94.3%
un-div-inv94.3%
Applied egg-rr94.3%
Taylor expanded in i around 0 75.5%
sub-neg75.5%
associate-*r/75.5%
metadata-eval75.5%
metadata-eval75.5%
Simplified75.5%
Final simplification85.8%
(FPCore (i n) :precision binary64 (if (or (<= i -4e-7) (not (<= i 7000000.0))) (* 100.0 (/ (expm1 i) (/ i n))) (/ n (+ 0.01 (* 0.01 (* i (+ -0.5 (/ 0.5 n))))))))
double code(double i, double n) {
double tmp;
if ((i <= -4e-7) || !(i <= 7000000.0)) {
tmp = 100.0 * (expm1(i) / (i / n));
} else {
tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n)))));
}
return tmp;
}
public static double code(double i, double n) {
double tmp;
if ((i <= -4e-7) || !(i <= 7000000.0)) {
tmp = 100.0 * (Math.expm1(i) / (i / n));
} else {
tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n)))));
}
return tmp;
}
def code(i, n): tmp = 0 if (i <= -4e-7) or not (i <= 7000000.0): tmp = 100.0 * (math.expm1(i) / (i / n)) else: tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n))))) return tmp
function code(i, n) tmp = 0.0 if ((i <= -4e-7) || !(i <= 7000000.0)) tmp = Float64(100.0 * Float64(expm1(i) / Float64(i / n))); else tmp = Float64(n / Float64(0.01 + Float64(0.01 * Float64(i * Float64(-0.5 + Float64(0.5 / n)))))); end return tmp end
code[i_, n_] := If[Or[LessEqual[i, -4e-7], N[Not[LessEqual[i, 7000000.0]], $MachinePrecision]], N[(100.0 * N[(N[(Exp[i] - 1), $MachinePrecision] / N[(i / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(n / N[(0.01 + N[(0.01 * N[(i * N[(-0.5 + N[(0.5 / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -4 \cdot 10^{-7} \lor \neg \left(i \leq 7000000\right):\\
\;\;\;\;100 \cdot \frac{\mathsf{expm1}\left(i\right)}{\frac{i}{n}}\\
\mathbf{else}:\\
\;\;\;\;\frac{n}{0.01 + 0.01 \cdot \left(i \cdot \left(-0.5 + \frac{0.5}{n}\right)\right)}\\
\end{array}
\end{array}
if i < -3.9999999999999998e-7 or 7e6 < i Initial program 53.5%
Taylor expanded in n around inf 63.2%
expm1-define63.5%
Simplified63.5%
if -3.9999999999999998e-7 < i < 7e6Initial program 7.8%
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%
fma-undefine8.3%
metadata-eval8.3%
metadata-eval8.3%
distribute-lft-in8.3%
sub-neg8.3%
*-commutative8.3%
add-exp-log8.3%
expm1-define8.3%
log-pow17.7%
log1p-define74.9%
Applied egg-rr74.9%
clear-num74.9%
un-div-inv74.9%
Applied egg-rr74.9%
Taylor expanded in i around 0 91.6%
sub-neg91.6%
associate-*r/91.6%
metadata-eval91.6%
metadata-eval91.6%
Simplified91.6%
Final simplification80.2%
(FPCore (i n)
:precision binary64
(let* ((t_0 (/ (expm1 i) i)))
(if (<= n -0.00043)
(* 100.0 (* n t_0))
(if (<= n 1.88)
(/ n (+ 0.01 (* 0.01 (* i (+ -0.5 (/ 0.5 n))))))
(* n (* 100.0 t_0))))))
double code(double i, double n) {
double t_0 = expm1(i) / i;
double tmp;
if (n <= -0.00043) {
tmp = 100.0 * (n * t_0);
} else if (n <= 1.88) {
tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n)))));
} else {
tmp = n * (100.0 * t_0);
}
return tmp;
}
public static double code(double i, double n) {
double t_0 = Math.expm1(i) / i;
double tmp;
if (n <= -0.00043) {
tmp = 100.0 * (n * t_0);
} else if (n <= 1.88) {
tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n)))));
} else {
tmp = n * (100.0 * t_0);
}
return tmp;
}
def code(i, n): t_0 = math.expm1(i) / i tmp = 0 if n <= -0.00043: tmp = 100.0 * (n * t_0) elif n <= 1.88: tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n))))) else: tmp = n * (100.0 * t_0) return tmp
function code(i, n) t_0 = Float64(expm1(i) / i) tmp = 0.0 if (n <= -0.00043) tmp = Float64(100.0 * Float64(n * t_0)); elseif (n <= 1.88) tmp = Float64(n / Float64(0.01 + Float64(0.01 * Float64(i * Float64(-0.5 + Float64(0.5 / n)))))); else tmp = Float64(n * Float64(100.0 * t_0)); end return tmp end
code[i_, n_] := Block[{t$95$0 = N[(N[(Exp[i] - 1), $MachinePrecision] / i), $MachinePrecision]}, If[LessEqual[n, -0.00043], N[(100.0 * N[(n * t$95$0), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 1.88], N[(n / N[(0.01 + N[(0.01 * N[(i * N[(-0.5 + N[(0.5 / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(n * N[(100.0 * t$95$0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\mathsf{expm1}\left(i\right)}{i}\\
\mathbf{if}\;n \leq -0.00043:\\
\;\;\;\;100 \cdot \left(n \cdot t\_0\right)\\
\mathbf{elif}\;n \leq 1.88:\\
\;\;\;\;\frac{n}{0.01 + 0.01 \cdot \left(i \cdot \left(-0.5 + \frac{0.5}{n}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;n \cdot \left(100 \cdot t\_0\right)\\
\end{array}
\end{array}
if n < -4.29999999999999989e-4Initial program 30.0%
Taylor expanded in n around inf 37.5%
*-commutative37.5%
associate-/l*37.4%
expm1-define88.6%
Simplified88.6%
if -4.29999999999999989e-4 < n < 1.8799999999999999Initial program 29.7%
associate-/r/29.3%
associate-*r*29.3%
*-commutative29.3%
associate-*r/29.3%
sub-neg29.3%
distribute-lft-in29.3%
metadata-eval29.3%
metadata-eval29.3%
metadata-eval29.3%
fma-define29.3%
metadata-eval29.3%
Simplified29.3%
fma-undefine29.3%
metadata-eval29.3%
metadata-eval29.3%
distribute-lft-in29.3%
sub-neg29.3%
*-commutative29.3%
add-exp-log29.3%
expm1-define29.3%
log-pow56.3%
log1p-define94.2%
Applied egg-rr94.2%
clear-num94.3%
un-div-inv94.3%
Applied egg-rr94.3%
Taylor expanded in i around 0 75.5%
sub-neg75.5%
associate-*r/75.5%
metadata-eval75.5%
metadata-eval75.5%
Simplified75.5%
if 1.8799999999999999 < n Initial program 17.2%
associate-/r/17.6%
associate-*r*17.6%
*-commutative17.6%
associate-*r/17.6%
sub-neg17.6%
distribute-lft-in17.6%
metadata-eval17.6%
metadata-eval17.6%
metadata-eval17.6%
fma-define17.6%
metadata-eval17.6%
Simplified17.6%
Taylor expanded in n around inf 37.2%
associate-/l*37.1%
sub-neg37.1%
metadata-eval37.1%
metadata-eval37.1%
distribute-lft-in37.1%
metadata-eval37.1%
sub-neg37.1%
associate-*r/37.1%
*-commutative37.1%
expm1-define97.1%
Simplified97.1%
Final simplification85.8%
(FPCore (i n)
:precision binary64
(if (<= n -3.5e+231)
(* n (+ 100.0 (* i (+ 50.0 (* i 16.666666666666668)))))
(if (<= n 1.32)
(/ n (+ 0.01 (* 0.01 (* i (+ -0.5 (/ 0.5 n))))))
(*
n
(*
100.0
(/
(*
i
(+
1.0
(*
i
(+ 0.5 (* i (+ 0.16666666666666666 (* i 0.041666666666666664)))))))
i))))))
double code(double i, double n) {
double tmp;
if (n <= -3.5e+231) {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
} else if (n <= 1.32) {
tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n)))));
} else {
tmp = n * (100.0 * ((i * (1.0 + (i * (0.5 + (i * (0.16666666666666666 + (i * 0.041666666666666664))))))) / i));
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if (n <= (-3.5d+231)) then
tmp = n * (100.0d0 + (i * (50.0d0 + (i * 16.666666666666668d0))))
else if (n <= 1.32d0) then
tmp = n / (0.01d0 + (0.01d0 * (i * ((-0.5d0) + (0.5d0 / n)))))
else
tmp = n * (100.0d0 * ((i * (1.0d0 + (i * (0.5d0 + (i * (0.16666666666666666d0 + (i * 0.041666666666666664d0))))))) / i))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if (n <= -3.5e+231) {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
} else if (n <= 1.32) {
tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n)))));
} else {
tmp = n * (100.0 * ((i * (1.0 + (i * (0.5 + (i * (0.16666666666666666 + (i * 0.041666666666666664))))))) / i));
}
return tmp;
}
def code(i, n): tmp = 0 if n <= -3.5e+231: tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))) elif n <= 1.32: tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n))))) else: tmp = n * (100.0 * ((i * (1.0 + (i * (0.5 + (i * (0.16666666666666666 + (i * 0.041666666666666664))))))) / i)) return tmp
function code(i, n) tmp = 0.0 if (n <= -3.5e+231) tmp = Float64(n * Float64(100.0 + Float64(i * Float64(50.0 + Float64(i * 16.666666666666668))))); elseif (n <= 1.32) tmp = Float64(n / Float64(0.01 + Float64(0.01 * Float64(i * Float64(-0.5 + Float64(0.5 / n)))))); else tmp = Float64(n * Float64(100.0 * Float64(Float64(i * Float64(1.0 + Float64(i * Float64(0.5 + Float64(i * Float64(0.16666666666666666 + Float64(i * 0.041666666666666664))))))) / i))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if (n <= -3.5e+231) tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))); elseif (n <= 1.32) tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n))))); else tmp = n * (100.0 * ((i * (1.0 + (i * (0.5 + (i * (0.16666666666666666 + (i * 0.041666666666666664))))))) / i)); end tmp_2 = tmp; end
code[i_, n_] := If[LessEqual[n, -3.5e+231], N[(n * N[(100.0 + N[(i * N[(50.0 + N[(i * 16.666666666666668), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 1.32], N[(n / N[(0.01 + N[(0.01 * N[(i * N[(-0.5 + N[(0.5 / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(n * N[(100.0 * N[(N[(i * N[(1.0 + N[(i * N[(0.5 + N[(i * N[(0.16666666666666666 + N[(i * 0.041666666666666664), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -3.5 \cdot 10^{+231}:\\
\;\;\;\;n \cdot \left(100 + i \cdot \left(50 + i \cdot 16.666666666666668\right)\right)\\
\mathbf{elif}\;n \leq 1.32:\\
\;\;\;\;\frac{n}{0.01 + 0.01 \cdot \left(i \cdot \left(-0.5 + \frac{0.5}{n}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;n \cdot \left(100 \cdot \frac{i \cdot \left(1 + i \cdot \left(0.5 + i \cdot \left(0.16666666666666666 + i \cdot 0.041666666666666664\right)\right)\right)}{i}\right)\\
\end{array}
\end{array}
if n < -3.4999999999999999e231Initial program 6.5%
associate-/r/7.0%
associate-*r*7.0%
*-commutative7.0%
associate-*r/6.9%
sub-neg6.9%
distribute-lft-in6.9%
metadata-eval6.9%
metadata-eval6.9%
metadata-eval6.9%
fma-define6.9%
metadata-eval6.9%
Simplified6.9%
Taylor expanded in n around inf 58.5%
associate-/l*58.4%
sub-neg58.4%
metadata-eval58.4%
metadata-eval58.4%
distribute-lft-in58.4%
metadata-eval58.4%
sub-neg58.4%
associate-*r/58.4%
*-commutative58.4%
expm1-define99.8%
Simplified99.8%
Taylor expanded in i around 0 70.7%
*-commutative70.7%
Simplified70.7%
if -3.4999999999999999e231 < n < 1.32000000000000006Initial program 32.5%
associate-/r/32.5%
associate-*r*32.5%
*-commutative32.5%
associate-*r/32.5%
sub-neg32.5%
distribute-lft-in32.5%
metadata-eval32.5%
metadata-eval32.5%
metadata-eval32.5%
fma-define32.5%
metadata-eval32.5%
Simplified32.5%
fma-undefine32.5%
metadata-eval32.5%
metadata-eval32.5%
distribute-lft-in32.5%
sub-neg32.5%
*-commutative32.5%
add-exp-log32.5%
expm1-define32.5%
log-pow43.2%
log1p-define81.7%
Applied egg-rr81.7%
clear-num81.7%
un-div-inv81.8%
Applied egg-rr81.8%
Taylor expanded in i around 0 70.8%
sub-neg70.8%
associate-*r/70.8%
metadata-eval70.8%
metadata-eval70.8%
Simplified70.8%
if 1.32000000000000006 < n Initial program 17.2%
associate-/r/17.6%
associate-*r*17.6%
*-commutative17.6%
associate-*r/17.6%
sub-neg17.6%
distribute-lft-in17.6%
metadata-eval17.6%
metadata-eval17.6%
metadata-eval17.6%
fma-define17.6%
metadata-eval17.6%
Simplified17.6%
Taylor expanded in n around inf 37.2%
associate-/l*37.1%
sub-neg37.1%
metadata-eval37.1%
metadata-eval37.1%
distribute-lft-in37.1%
metadata-eval37.1%
sub-neg37.1%
associate-*r/37.1%
*-commutative37.1%
expm1-define97.1%
Simplified97.1%
Taylor expanded in i around 0 81.9%
*-commutative81.9%
Simplified81.9%
Final simplification73.8%
(FPCore (i n)
:precision binary64
(if (<= n -3.1e+231)
(* n (+ 100.0 (* i (+ 50.0 (* i 16.666666666666668)))))
(if (<= n 1.85)
(/ n (+ 0.01 (* 0.01 (* i (+ -0.5 (/ 0.5 n))))))
(*
n
(+
100.0
(* i (+ 50.0 (* i (+ 16.666666666666668 (* i 4.166666666666667))))))))))
double code(double i, double n) {
double tmp;
if (n <= -3.1e+231) {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
} else if (n <= 1.85) {
tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n)))));
} else {
tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667))))));
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if (n <= (-3.1d+231)) then
tmp = n * (100.0d0 + (i * (50.0d0 + (i * 16.666666666666668d0))))
else if (n <= 1.85d0) then
tmp = n / (0.01d0 + (0.01d0 * (i * ((-0.5d0) + (0.5d0 / n)))))
else
tmp = n * (100.0d0 + (i * (50.0d0 + (i * (16.666666666666668d0 + (i * 4.166666666666667d0))))))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if (n <= -3.1e+231) {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
} else if (n <= 1.85) {
tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n)))));
} else {
tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667))))));
}
return tmp;
}
def code(i, n): tmp = 0 if n <= -3.1e+231: tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))) elif n <= 1.85: tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n))))) else: tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667)))))) return tmp
function code(i, n) tmp = 0.0 if (n <= -3.1e+231) tmp = Float64(n * Float64(100.0 + Float64(i * Float64(50.0 + Float64(i * 16.666666666666668))))); elseif (n <= 1.85) tmp = Float64(n / Float64(0.01 + Float64(0.01 * Float64(i * Float64(-0.5 + Float64(0.5 / n)))))); else tmp = Float64(n * Float64(100.0 + Float64(i * Float64(50.0 + Float64(i * Float64(16.666666666666668 + Float64(i * 4.166666666666667))))))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if (n <= -3.1e+231) tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))); elseif (n <= 1.85) tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n))))); else tmp = n * (100.0 + (i * (50.0 + (i * (16.666666666666668 + (i * 4.166666666666667)))))); end tmp_2 = tmp; end
code[i_, n_] := If[LessEqual[n, -3.1e+231], N[(n * N[(100.0 + N[(i * N[(50.0 + N[(i * 16.666666666666668), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 1.85], N[(n / N[(0.01 + N[(0.01 * N[(i * N[(-0.5 + N[(0.5 / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $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]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -3.1 \cdot 10^{+231}:\\
\;\;\;\;n \cdot \left(100 + i \cdot \left(50 + i \cdot 16.666666666666668\right)\right)\\
\mathbf{elif}\;n \leq 1.85:\\
\;\;\;\;\frac{n}{0.01 + 0.01 \cdot \left(i \cdot \left(-0.5 + \frac{0.5}{n}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;n \cdot \left(100 + i \cdot \left(50 + i \cdot \left(16.666666666666668 + i \cdot 4.166666666666667\right)\right)\right)\\
\end{array}
\end{array}
if n < -3.0999999999999999e231Initial program 6.5%
associate-/r/7.0%
associate-*r*7.0%
*-commutative7.0%
associate-*r/6.9%
sub-neg6.9%
distribute-lft-in6.9%
metadata-eval6.9%
metadata-eval6.9%
metadata-eval6.9%
fma-define6.9%
metadata-eval6.9%
Simplified6.9%
Taylor expanded in n around inf 58.5%
associate-/l*58.4%
sub-neg58.4%
metadata-eval58.4%
metadata-eval58.4%
distribute-lft-in58.4%
metadata-eval58.4%
sub-neg58.4%
associate-*r/58.4%
*-commutative58.4%
expm1-define99.8%
Simplified99.8%
Taylor expanded in i around 0 70.7%
*-commutative70.7%
Simplified70.7%
if -3.0999999999999999e231 < n < 1.8500000000000001Initial program 32.5%
associate-/r/32.5%
associate-*r*32.5%
*-commutative32.5%
associate-*r/32.5%
sub-neg32.5%
distribute-lft-in32.5%
metadata-eval32.5%
metadata-eval32.5%
metadata-eval32.5%
fma-define32.5%
metadata-eval32.5%
Simplified32.5%
fma-undefine32.5%
metadata-eval32.5%
metadata-eval32.5%
distribute-lft-in32.5%
sub-neg32.5%
*-commutative32.5%
add-exp-log32.5%
expm1-define32.5%
log-pow43.2%
log1p-define81.7%
Applied egg-rr81.7%
clear-num81.7%
un-div-inv81.8%
Applied egg-rr81.8%
Taylor expanded in i around 0 70.8%
sub-neg70.8%
associate-*r/70.8%
metadata-eval70.8%
metadata-eval70.8%
Simplified70.8%
if 1.8500000000000001 < n Initial program 17.2%
associate-/r/17.6%
associate-*r*17.6%
*-commutative17.6%
associate-*r/17.6%
sub-neg17.6%
distribute-lft-in17.6%
metadata-eval17.6%
metadata-eval17.6%
metadata-eval17.6%
fma-define17.6%
metadata-eval17.6%
Simplified17.6%
Taylor expanded in n around inf 37.2%
associate-/l*37.1%
sub-neg37.1%
metadata-eval37.1%
metadata-eval37.1%
distribute-lft-in37.1%
metadata-eval37.1%
sub-neg37.1%
associate-*r/37.1%
*-commutative37.1%
expm1-define97.1%
Simplified97.1%
Taylor expanded in i around 0 80.6%
*-commutative80.6%
Simplified80.6%
Final simplification73.5%
(FPCore (i n) :precision binary64 (if (or (<= n -3.1e+231) (not (<= n 1.95))) (* n (+ 100.0 (* i (+ 50.0 (* i 16.666666666666668))))) (/ n (+ 0.01 (* 0.01 (* i (+ -0.5 (/ 0.5 n))))))))
double code(double i, double n) {
double tmp;
if ((n <= -3.1e+231) || !(n <= 1.95)) {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
} else {
tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / 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.1d+231)) .or. (.not. (n <= 1.95d0))) then
tmp = n * (100.0d0 + (i * (50.0d0 + (i * 16.666666666666668d0))))
else
tmp = n / (0.01d0 + (0.01d0 * (i * ((-0.5d0) + (0.5d0 / n)))))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if ((n <= -3.1e+231) || !(n <= 1.95)) {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
} else {
tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n)))));
}
return tmp;
}
def code(i, n): tmp = 0 if (n <= -3.1e+231) or not (n <= 1.95): tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))) else: tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n))))) return tmp
function code(i, n) tmp = 0.0 if ((n <= -3.1e+231) || !(n <= 1.95)) tmp = Float64(n * Float64(100.0 + Float64(i * Float64(50.0 + Float64(i * 16.666666666666668))))); else tmp = Float64(n / Float64(0.01 + Float64(0.01 * Float64(i * Float64(-0.5 + Float64(0.5 / n)))))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if ((n <= -3.1e+231) || ~((n <= 1.95))) tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))); else tmp = n / (0.01 + (0.01 * (i * (-0.5 + (0.5 / n))))); end tmp_2 = tmp; end
code[i_, n_] := If[Or[LessEqual[n, -3.1e+231], N[Not[LessEqual[n, 1.95]], $MachinePrecision]], N[(n * N[(100.0 + N[(i * N[(50.0 + N[(i * 16.666666666666668), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(n / N[(0.01 + N[(0.01 * N[(i * N[(-0.5 + N[(0.5 / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -3.1 \cdot 10^{+231} \lor \neg \left(n \leq 1.95\right):\\
\;\;\;\;n \cdot \left(100 + i \cdot \left(50 + i \cdot 16.666666666666668\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{n}{0.01 + 0.01 \cdot \left(i \cdot \left(-0.5 + \frac{0.5}{n}\right)\right)}\\
\end{array}
\end{array}
if n < -3.0999999999999999e231 or 1.94999999999999996 < n Initial program 14.9%
associate-/r/15.4%
associate-*r*15.4%
*-commutative15.4%
associate-*r/15.4%
sub-neg15.4%
distribute-lft-in15.4%
metadata-eval15.4%
metadata-eval15.4%
metadata-eval15.4%
fma-define15.4%
metadata-eval15.4%
Simplified15.4%
Taylor expanded in n around inf 41.7%
associate-/l*41.7%
sub-neg41.7%
metadata-eval41.7%
metadata-eval41.7%
distribute-lft-in41.7%
metadata-eval41.7%
sub-neg41.7%
associate-*r/41.7%
*-commutative41.7%
expm1-define97.7%
Simplified97.7%
Taylor expanded in i around 0 75.7%
*-commutative75.7%
Simplified75.7%
if -3.0999999999999999e231 < n < 1.94999999999999996Initial program 32.5%
associate-/r/32.5%
associate-*r*32.5%
*-commutative32.5%
associate-*r/32.5%
sub-neg32.5%
distribute-lft-in32.5%
metadata-eval32.5%
metadata-eval32.5%
metadata-eval32.5%
fma-define32.5%
metadata-eval32.5%
Simplified32.5%
fma-undefine32.5%
metadata-eval32.5%
metadata-eval32.5%
distribute-lft-in32.5%
sub-neg32.5%
*-commutative32.5%
add-exp-log32.5%
expm1-define32.5%
log-pow43.2%
log1p-define81.7%
Applied egg-rr81.7%
clear-num81.7%
un-div-inv81.8%
Applied egg-rr81.8%
Taylor expanded in i around 0 70.8%
sub-neg70.8%
associate-*r/70.8%
metadata-eval70.8%
metadata-eval70.8%
Simplified70.8%
Final simplification72.5%
(FPCore (i n) :precision binary64 (if (<= i -2.3) (/ 0.0 (/ i n)) (* n (+ 100.0 (* i (+ 50.0 (* i 16.666666666666668)))))))
double code(double i, double n) {
double tmp;
if (i <= -2.3) {
tmp = 0.0 / (i / n);
} else {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if (i <= (-2.3d0)) then
tmp = 0.0d0 / (i / n)
else
tmp = n * (100.0d0 + (i * (50.0d0 + (i * 16.666666666666668d0))))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if (i <= -2.3) {
tmp = 0.0 / (i / n);
} else {
tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668))));
}
return tmp;
}
def code(i, n): tmp = 0 if i <= -2.3: tmp = 0.0 / (i / n) else: tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))) return tmp
function code(i, n) tmp = 0.0 if (i <= -2.3) tmp = Float64(0.0 / Float64(i / n)); else tmp = Float64(n * Float64(100.0 + Float64(i * Float64(50.0 + Float64(i * 16.666666666666668))))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if (i <= -2.3) tmp = 0.0 / (i / n); else tmp = n * (100.0 + (i * (50.0 + (i * 16.666666666666668)))); end tmp_2 = tmp; end
code[i_, n_] := If[LessEqual[i, -2.3], N[(0.0 / N[(i / n), $MachinePrecision]), $MachinePrecision], N[(n * N[(100.0 + N[(i * N[(50.0 + N[(i * 16.666666666666668), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -2.3:\\
\;\;\;\;\frac{0}{\frac{i}{n}}\\
\mathbf{else}:\\
\;\;\;\;n \cdot \left(100 + i \cdot \left(50 + i \cdot 16.666666666666668\right)\right)\\
\end{array}
\end{array}
if i < -2.2999999999999998Initial program 63.4%
associate-*r/63.4%
sub-neg63.4%
distribute-rgt-in63.4%
metadata-eval63.4%
metadata-eval63.4%
Simplified63.4%
Taylor expanded in i around 0 31.0%
if -2.2999999999999998 < i Initial program 16.7%
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 18.2%
associate-/l*18.2%
sub-neg18.2%
metadata-eval18.2%
metadata-eval18.2%
distribute-lft-in18.3%
metadata-eval18.3%
sub-neg18.3%
associate-*r/18.3%
*-commutative18.3%
expm1-define77.1%
Simplified77.1%
Taylor expanded in i around 0 73.3%
*-commutative73.3%
Simplified73.3%
Final simplification64.5%
(FPCore (i n) :precision binary64 (if (or (<= i -2.0) (not (<= i 3.35e+78))) (* -200.0 (/ n i)) (* n 100.0)))
double code(double i, double n) {
double tmp;
if ((i <= -2.0) || !(i <= 3.35e+78)) {
tmp = -200.0 * (n / i);
} else {
tmp = n * 100.0;
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if ((i <= (-2.0d0)) .or. (.not. (i <= 3.35d+78))) then
tmp = (-200.0d0) * (n / i)
else
tmp = n * 100.0d0
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if ((i <= -2.0) || !(i <= 3.35e+78)) {
tmp = -200.0 * (n / i);
} else {
tmp = n * 100.0;
}
return tmp;
}
def code(i, n): tmp = 0 if (i <= -2.0) or not (i <= 3.35e+78): tmp = -200.0 * (n / i) else: tmp = n * 100.0 return tmp
function code(i, n) tmp = 0.0 if ((i <= -2.0) || !(i <= 3.35e+78)) tmp = Float64(-200.0 * Float64(n / i)); else tmp = Float64(n * 100.0); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if ((i <= -2.0) || ~((i <= 3.35e+78))) tmp = -200.0 * (n / i); else tmp = n * 100.0; end tmp_2 = tmp; end
code[i_, n_] := If[Or[LessEqual[i, -2.0], N[Not[LessEqual[i, 3.35e+78]], $MachinePrecision]], N[(-200.0 * N[(n / i), $MachinePrecision]), $MachinePrecision], N[(n * 100.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -2 \lor \neg \left(i \leq 3.35 \cdot 10^{+78}\right):\\
\;\;\;\;-200 \cdot \frac{n}{i}\\
\mathbf{else}:\\
\;\;\;\;n \cdot 100\\
\end{array}
\end{array}
if i < -2 or 3.34999999999999983e78 < i Initial program 60.4%
associate-/r/60.0%
associate-*r*60.0%
*-commutative60.0%
associate-*r/59.9%
sub-neg59.9%
distribute-lft-in59.9%
metadata-eval59.9%
metadata-eval59.9%
metadata-eval59.9%
fma-define59.9%
metadata-eval59.9%
Simplified59.9%
Taylor expanded in n around inf 63.7%
associate-/l*63.7%
sub-neg63.7%
metadata-eval63.7%
metadata-eval63.7%
distribute-lft-in63.7%
metadata-eval63.7%
sub-neg63.7%
associate-*r/63.7%
*-commutative63.7%
expm1-define63.7%
Simplified63.7%
pow163.7%
*-commutative63.7%
clear-num63.7%
un-div-inv63.7%
Applied egg-rr63.7%
unpow163.7%
associate-*r/63.7%
*-commutative63.7%
Simplified63.7%
Taylor expanded in i around 0 27.3%
*-commutative27.3%
Simplified27.3%
Taylor expanded in i around inf 27.3%
if -2 < i < 3.34999999999999983e78Initial program 9.7%
associate-/r/10.2%
associate-*r*10.2%
*-commutative10.2%
associate-*r/10.2%
sub-neg10.2%
distribute-lft-in10.2%
metadata-eval10.2%
metadata-eval10.2%
metadata-eval10.2%
fma-define10.2%
metadata-eval10.2%
Simplified10.2%
Taylor expanded in i around 0 76.8%
*-commutative76.8%
Simplified76.8%
Final simplification60.6%
(FPCore (i n) :precision binary64 (if (<= n 1.6e-118) (* 100.0 (/ n (+ 1.0 (* i -0.5)))) (* n (+ 100.0 (* i 50.0)))))
double code(double i, double n) {
double tmp;
if (n <= 1.6e-118) {
tmp = 100.0 * (n / (1.0 + (i * -0.5)));
} else {
tmp = n * (100.0 + (i * 50.0));
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if (n <= 1.6d-118) then
tmp = 100.0d0 * (n / (1.0d0 + (i * (-0.5d0))))
else
tmp = n * (100.0d0 + (i * 50.0d0))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if (n <= 1.6e-118) {
tmp = 100.0 * (n / (1.0 + (i * -0.5)));
} else {
tmp = n * (100.0 + (i * 50.0));
}
return tmp;
}
def code(i, n): tmp = 0 if n <= 1.6e-118: tmp = 100.0 * (n / (1.0 + (i * -0.5))) else: tmp = n * (100.0 + (i * 50.0)) return tmp
function code(i, n) tmp = 0.0 if (n <= 1.6e-118) tmp = Float64(100.0 * Float64(n / Float64(1.0 + Float64(i * -0.5)))); else tmp = Float64(n * Float64(100.0 + Float64(i * 50.0))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if (n <= 1.6e-118) tmp = 100.0 * (n / (1.0 + (i * -0.5))); else tmp = n * (100.0 + (i * 50.0)); end tmp_2 = tmp; end
code[i_, n_] := If[LessEqual[n, 1.6e-118], N[(100.0 * N[(n / N[(1.0 + N[(i * -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(n * N[(100.0 + N[(i * 50.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq 1.6 \cdot 10^{-118}:\\
\;\;\;\;100 \cdot \frac{n}{1 + i \cdot -0.5}\\
\mathbf{else}:\\
\;\;\;\;n \cdot \left(100 + i \cdot 50\right)\\
\end{array}
\end{array}
if n < 1.60000000000000002e-118Initial program 32.7%
associate-/r/32.7%
associate-*r*32.7%
*-commutative32.7%
associate-*r/32.7%
sub-neg32.7%
distribute-lft-in32.7%
metadata-eval32.7%
metadata-eval32.7%
metadata-eval32.7%
fma-define32.7%
metadata-eval32.7%
Simplified32.7%
Taylor expanded in n around inf 31.0%
associate-/l*31.0%
sub-neg31.0%
metadata-eval31.0%
metadata-eval31.0%
distribute-lft-in31.0%
metadata-eval31.0%
sub-neg31.0%
associate-*r/31.0%
*-commutative31.0%
expm1-define72.5%
Simplified72.5%
pow172.5%
*-commutative72.5%
clear-num72.5%
un-div-inv72.5%
Applied egg-rr72.5%
unpow172.5%
associate-*r/72.5%
*-commutative72.5%
Simplified72.5%
Taylor expanded in i around 0 60.6%
*-commutative60.6%
Simplified60.6%
Taylor expanded in n around 0 60.6%
if 1.60000000000000002e-118 < n Initial program 15.3%
associate-/r/15.7%
associate-*r*15.7%
*-commutative15.7%
associate-*r/15.7%
sub-neg15.7%
distribute-lft-in15.7%
metadata-eval15.7%
metadata-eval15.7%
metadata-eval15.7%
fma-define15.7%
metadata-eval15.7%
Simplified15.7%
Taylor expanded in n around inf 28.8%
associate-/l*28.7%
sub-neg28.7%
metadata-eval28.7%
metadata-eval28.7%
distribute-lft-in28.7%
metadata-eval28.7%
sub-neg28.7%
associate-*r/28.7%
*-commutative28.7%
expm1-define84.5%
Simplified84.5%
Taylor expanded in i around 0 68.3%
*-commutative68.3%
Simplified68.3%
Final simplification63.4%
(FPCore (i n) :precision binary64 (if (<= i -3.0) (* -200.0 (/ n i)) (* n (+ 100.0 (* i 50.0)))))
double code(double i, double n) {
double tmp;
if (i <= -3.0) {
tmp = -200.0 * (n / i);
} else {
tmp = n * (100.0 + (i * 50.0));
}
return tmp;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
real(8) :: tmp
if (i <= (-3.0d0)) then
tmp = (-200.0d0) * (n / i)
else
tmp = n * (100.0d0 + (i * 50.0d0))
end if
code = tmp
end function
public static double code(double i, double n) {
double tmp;
if (i <= -3.0) {
tmp = -200.0 * (n / i);
} else {
tmp = n * (100.0 + (i * 50.0));
}
return tmp;
}
def code(i, n): tmp = 0 if i <= -3.0: tmp = -200.0 * (n / i) else: tmp = n * (100.0 + (i * 50.0)) return tmp
function code(i, n) tmp = 0.0 if (i <= -3.0) tmp = Float64(-200.0 * Float64(n / i)); else tmp = Float64(n * Float64(100.0 + Float64(i * 50.0))); end return tmp end
function tmp_2 = code(i, n) tmp = 0.0; if (i <= -3.0) tmp = -200.0 * (n / i); else tmp = n * (100.0 + (i * 50.0)); end tmp_2 = tmp; end
code[i_, n_] := If[LessEqual[i, -3.0], N[(-200.0 * N[(n / i), $MachinePrecision]), $MachinePrecision], N[(n * N[(100.0 + N[(i * 50.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -3:\\
\;\;\;\;-200 \cdot \frac{n}{i}\\
\mathbf{else}:\\
\;\;\;\;n \cdot \left(100 + i \cdot 50\right)\\
\end{array}
\end{array}
if i < -3Initial program 63.4%
associate-/r/62.6%
associate-*r*62.5%
*-commutative62.5%
associate-*r/62.5%
sub-neg62.5%
distribute-lft-in62.5%
metadata-eval62.5%
metadata-eval62.5%
metadata-eval62.5%
fma-define62.5%
metadata-eval62.5%
Simplified62.5%
Taylor expanded in n around inf 77.4%
associate-/l*77.3%
sub-neg77.3%
metadata-eval77.3%
metadata-eval77.3%
distribute-lft-in77.3%
metadata-eval77.3%
sub-neg77.3%
associate-*r/77.3%
*-commutative77.3%
expm1-define77.3%
Simplified77.3%
pow177.3%
*-commutative77.3%
clear-num77.3%
un-div-inv77.3%
Applied egg-rr77.3%
unpow177.3%
associate-*r/77.4%
*-commutative77.4%
Simplified77.4%
Taylor expanded in i around 0 30.6%
*-commutative30.6%
Simplified30.6%
Taylor expanded in i around inf 30.6%
if -3 < i Initial program 16.9%
associate-/r/17.3%
associate-*r*17.3%
*-commutative17.3%
associate-*r/17.3%
sub-neg17.3%
distribute-lft-in17.3%
metadata-eval17.3%
metadata-eval17.3%
metadata-eval17.3%
fma-define17.3%
metadata-eval17.3%
Simplified17.3%
Taylor expanded in n around inf 18.2%
associate-/l*18.2%
sub-neg18.2%
metadata-eval18.2%
metadata-eval18.2%
distribute-lft-in18.2%
metadata-eval18.2%
sub-neg18.2%
associate-*r/18.2%
*-commutative18.2%
expm1-define76.7%
Simplified76.7%
Taylor expanded in i around 0 70.7%
*-commutative70.7%
Simplified70.7%
(FPCore (i n) :precision binary64 (* n 100.0))
double code(double i, double n) {
return n * 100.0;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
code = n * 100.0d0
end function
public static double code(double i, double n) {
return n * 100.0;
}
def code(i, n): return n * 100.0
function code(i, n) return Float64(n * 100.0) end
function tmp = code(i, n) tmp = n * 100.0; end
code[i_, n_] := N[(n * 100.0), $MachinePrecision]
\begin{array}{l}
\\
n \cdot 100
\end{array}
Initial program 26.4%
associate-/r/26.5%
associate-*r*26.5%
*-commutative26.5%
associate-*r/26.5%
sub-neg26.5%
distribute-lft-in26.5%
metadata-eval26.5%
metadata-eval26.5%
metadata-eval26.5%
fma-define26.5%
metadata-eval26.5%
Simplified26.5%
Taylor expanded in i around 0 53.3%
*-commutative53.3%
Simplified53.3%
(FPCore (i n) :precision binary64 (* i -50.0))
double code(double i, double n) {
return i * -50.0;
}
real(8) function code(i, n)
real(8), intent (in) :: i
real(8), intent (in) :: n
code = i * (-50.0d0)
end function
public static double code(double i, double n) {
return i * -50.0;
}
def code(i, n): return i * -50.0
function code(i, n) return Float64(i * -50.0) end
function tmp = code(i, n) tmp = i * -50.0; end
code[i_, n_] := N[(i * -50.0), $MachinePrecision]
\begin{array}{l}
\\
i \cdot -50
\end{array}
Initial program 26.4%
Taylor expanded in i around 0 57.3%
associate-*r*57.0%
*-commutative57.0%
associate-*r/57.0%
metadata-eval57.0%
Simplified57.0%
Taylor expanded in n around 0 2.9%
*-commutative2.9%
Simplified2.9%
(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 2024145
(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))))