
(FPCore (wj x) :precision binary64 (let* ((t_0 (* wj (exp wj)))) (- wj (/ (- t_0 x) (+ (exp wj) t_0)))))
double code(double wj, double x) {
double t_0 = wj * exp(wj);
return wj - ((t_0 - x) / (exp(wj) + t_0));
}
real(8) function code(wj, x)
real(8), intent (in) :: wj
real(8), intent (in) :: x
real(8) :: t_0
t_0 = wj * exp(wj)
code = wj - ((t_0 - x) / (exp(wj) + t_0))
end function
public static double code(double wj, double x) {
double t_0 = wj * Math.exp(wj);
return wj - ((t_0 - x) / (Math.exp(wj) + t_0));
}
def code(wj, x): t_0 = wj * math.exp(wj) return wj - ((t_0 - x) / (math.exp(wj) + t_0))
function code(wj, x) t_0 = Float64(wj * exp(wj)) return Float64(wj - Float64(Float64(t_0 - x) / Float64(exp(wj) + t_0))) end
function tmp = code(wj, x) t_0 = wj * exp(wj); tmp = wj - ((t_0 - x) / (exp(wj) + t_0)); end
code[wj_, x_] := Block[{t$95$0 = N[(wj * N[Exp[wj], $MachinePrecision]), $MachinePrecision]}, N[(wj - N[(N[(t$95$0 - x), $MachinePrecision] / N[(N[Exp[wj], $MachinePrecision] + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := wj \cdot e^{wj}\\
wj - \frac{t\_0 - x}{e^{wj} + t\_0}
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 12 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (wj x) :precision binary64 (let* ((t_0 (* wj (exp wj)))) (- wj (/ (- t_0 x) (+ (exp wj) t_0)))))
double code(double wj, double x) {
double t_0 = wj * exp(wj);
return wj - ((t_0 - x) / (exp(wj) + t_0));
}
real(8) function code(wj, x)
real(8), intent (in) :: wj
real(8), intent (in) :: x
real(8) :: t_0
t_0 = wj * exp(wj)
code = wj - ((t_0 - x) / (exp(wj) + t_0))
end function
public static double code(double wj, double x) {
double t_0 = wj * Math.exp(wj);
return wj - ((t_0 - x) / (Math.exp(wj) + t_0));
}
def code(wj, x): t_0 = wj * math.exp(wj) return wj - ((t_0 - x) / (math.exp(wj) + t_0))
function code(wj, x) t_0 = Float64(wj * exp(wj)) return Float64(wj - Float64(Float64(t_0 - x) / Float64(exp(wj) + t_0))) end
function tmp = code(wj, x) t_0 = wj * exp(wj); tmp = wj - ((t_0 - x) / (exp(wj) + t_0)); end
code[wj_, x_] := Block[{t$95$0 = N[(wj * N[Exp[wj], $MachinePrecision]), $MachinePrecision]}, N[(wj - N[(N[(t$95$0 - x), $MachinePrecision] / N[(N[Exp[wj], $MachinePrecision] + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := wj \cdot e^{wj}\\
wj - \frac{t\_0 - x}{e^{wj} + t\_0}
\end{array}
\end{array}
(FPCore (wj x)
:precision binary64
(let* ((t_0 (* wj (exp wj))))
(if (<= (+ wj (/ (- x t_0) (+ (exp wj) t_0))) 2e-12)
(+
x
(*
wj
(+
(*
wj
(+
(+
1.0
(+
1.0
(-
-1.0
(*
wj
(+
(* -2.0 (* x -2.5))
(- (* x 0.6666666666666666) (- -1.0 (* x -3.0))))))))
(* x 2.5)))
(* x -2.0))))
(- wj (/ (- (/ x (exp wj)) wj) (- -1.0 wj))))))
double code(double wj, double x) {
double t_0 = wj * exp(wj);
double tmp;
if ((wj + ((x - t_0) / (exp(wj) + t_0))) <= 2e-12) {
tmp = x + (wj * ((wj * ((1.0 + (1.0 + (-1.0 - (wj * ((-2.0 * (x * -2.5)) + ((x * 0.6666666666666666) - (-1.0 - (x * -3.0)))))))) + (x * 2.5))) + (x * -2.0)));
} else {
tmp = wj - (((x / exp(wj)) - wj) / (-1.0 - wj));
}
return tmp;
}
real(8) function code(wj, x)
real(8), intent (in) :: wj
real(8), intent (in) :: x
real(8) :: t_0
real(8) :: tmp
t_0 = wj * exp(wj)
if ((wj + ((x - t_0) / (exp(wj) + t_0))) <= 2d-12) then
tmp = x + (wj * ((wj * ((1.0d0 + (1.0d0 + ((-1.0d0) - (wj * (((-2.0d0) * (x * (-2.5d0))) + ((x * 0.6666666666666666d0) - ((-1.0d0) - (x * (-3.0d0))))))))) + (x * 2.5d0))) + (x * (-2.0d0))))
else
tmp = wj - (((x / exp(wj)) - wj) / ((-1.0d0) - wj))
end if
code = tmp
end function
public static double code(double wj, double x) {
double t_0 = wj * Math.exp(wj);
double tmp;
if ((wj + ((x - t_0) / (Math.exp(wj) + t_0))) <= 2e-12) {
tmp = x + (wj * ((wj * ((1.0 + (1.0 + (-1.0 - (wj * ((-2.0 * (x * -2.5)) + ((x * 0.6666666666666666) - (-1.0 - (x * -3.0)))))))) + (x * 2.5))) + (x * -2.0)));
} else {
tmp = wj - (((x / Math.exp(wj)) - wj) / (-1.0 - wj));
}
return tmp;
}
def code(wj, x): t_0 = wj * math.exp(wj) tmp = 0 if (wj + ((x - t_0) / (math.exp(wj) + t_0))) <= 2e-12: tmp = x + (wj * ((wj * ((1.0 + (1.0 + (-1.0 - (wj * ((-2.0 * (x * -2.5)) + ((x * 0.6666666666666666) - (-1.0 - (x * -3.0)))))))) + (x * 2.5))) + (x * -2.0))) else: tmp = wj - (((x / math.exp(wj)) - wj) / (-1.0 - wj)) return tmp
function code(wj, x) t_0 = Float64(wj * exp(wj)) tmp = 0.0 if (Float64(wj + Float64(Float64(x - t_0) / Float64(exp(wj) + t_0))) <= 2e-12) tmp = Float64(x + Float64(wj * Float64(Float64(wj * Float64(Float64(1.0 + Float64(1.0 + Float64(-1.0 - Float64(wj * Float64(Float64(-2.0 * Float64(x * -2.5)) + Float64(Float64(x * 0.6666666666666666) - Float64(-1.0 - Float64(x * -3.0)))))))) + Float64(x * 2.5))) + Float64(x * -2.0)))); else tmp = Float64(wj - Float64(Float64(Float64(x / exp(wj)) - wj) / Float64(-1.0 - wj))); end return tmp end
function tmp_2 = code(wj, x) t_0 = wj * exp(wj); tmp = 0.0; if ((wj + ((x - t_0) / (exp(wj) + t_0))) <= 2e-12) tmp = x + (wj * ((wj * ((1.0 + (1.0 + (-1.0 - (wj * ((-2.0 * (x * -2.5)) + ((x * 0.6666666666666666) - (-1.0 - (x * -3.0)))))))) + (x * 2.5))) + (x * -2.0))); else tmp = wj - (((x / exp(wj)) - wj) / (-1.0 - wj)); end tmp_2 = tmp; end
code[wj_, x_] := Block[{t$95$0 = N[(wj * N[Exp[wj], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(wj + N[(N[(x - t$95$0), $MachinePrecision] / N[(N[Exp[wj], $MachinePrecision] + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2e-12], N[(x + N[(wj * N[(N[(wj * N[(N[(1.0 + N[(1.0 + N[(-1.0 - N[(wj * N[(N[(-2.0 * N[(x * -2.5), $MachinePrecision]), $MachinePrecision] + N[(N[(x * 0.6666666666666666), $MachinePrecision] - N[(-1.0 - N[(x * -3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(x * 2.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(x * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(wj - N[(N[(N[(x / N[Exp[wj], $MachinePrecision]), $MachinePrecision] - wj), $MachinePrecision] / N[(-1.0 - wj), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := wj \cdot e^{wj}\\
\mathbf{if}\;wj + \frac{x - t\_0}{e^{wj} + t\_0} \leq 2 \cdot 10^{-12}:\\
\;\;\;\;x + wj \cdot \left(wj \cdot \left(\left(1 + \left(1 + \left(-1 - wj \cdot \left(-2 \cdot \left(x \cdot -2.5\right) + \left(x \cdot 0.6666666666666666 - \left(-1 - x \cdot -3\right)\right)\right)\right)\right)\right) + x \cdot 2.5\right) + x \cdot -2\right)\\
\mathbf{else}:\\
\;\;\;\;wj - \frac{\frac{x}{e^{wj}} - wj}{-1 - wj}\\
\end{array}
\end{array}
if (-.f64 wj (/.f64 (-.f64 (*.f64 wj (exp.f64 wj)) x) (+.f64 (exp.f64 wj) (*.f64 wj (exp.f64 wj))))) < 1.99999999999999996e-12Initial program 73.1%
sub-neg73.1%
distribute-neg-frac73.1%
distribute-rgt1-in73.7%
associate-/l/73.6%
sub-neg73.6%
+-commutative73.6%
distribute-neg-in73.6%
remove-double-neg73.6%
sub-neg73.6%
div-sub73.1%
associate-/l*73.1%
*-inverses73.6%
*-rgt-identity73.6%
Simplified73.6%
Taylor expanded in wj around 0 98.8%
cancel-sign-sub-inv98.8%
metadata-eval98.8%
Simplified98.8%
expm1-log1p-u93.1%
expm1-undefine93.1%
log1p-undefine93.1%
add-exp-log98.8%
*-commutative98.8%
associate-+l+98.8%
Applied egg-rr98.8%
if 1.99999999999999996e-12 < (-.f64 wj (/.f64 (-.f64 (*.f64 wj (exp.f64 wj)) x) (+.f64 (exp.f64 wj) (*.f64 wj (exp.f64 wj))))) Initial program 93.5%
sub-neg93.5%
distribute-neg-frac93.5%
distribute-rgt1-in95.1%
associate-/l/95.1%
sub-neg95.1%
+-commutative95.1%
distribute-neg-in95.1%
remove-double-neg95.1%
sub-neg95.1%
div-sub93.5%
associate-/l*93.5%
*-inverses99.9%
*-rgt-identity99.9%
Simplified99.9%
Final simplification99.1%
(FPCore (wj x)
:precision binary64
(+
x
(*
wj
(+
(*
wj
(+
(+
1.0
(+
1.0
(-
-1.0
(*
wj
(+
(* -2.0 (* x -2.5))
(- (* x 0.6666666666666666) (- -1.0 (* x -3.0))))))))
(* x 2.5)))
(* x -2.0)))))
double code(double wj, double x) {
return x + (wj * ((wj * ((1.0 + (1.0 + (-1.0 - (wj * ((-2.0 * (x * -2.5)) + ((x * 0.6666666666666666) - (-1.0 - (x * -3.0)))))))) + (x * 2.5))) + (x * -2.0)));
}
real(8) function code(wj, x)
real(8), intent (in) :: wj
real(8), intent (in) :: x
code = x + (wj * ((wj * ((1.0d0 + (1.0d0 + ((-1.0d0) - (wj * (((-2.0d0) * (x * (-2.5d0))) + ((x * 0.6666666666666666d0) - ((-1.0d0) - (x * (-3.0d0))))))))) + (x * 2.5d0))) + (x * (-2.0d0))))
end function
public static double code(double wj, double x) {
return x + (wj * ((wj * ((1.0 + (1.0 + (-1.0 - (wj * ((-2.0 * (x * -2.5)) + ((x * 0.6666666666666666) - (-1.0 - (x * -3.0)))))))) + (x * 2.5))) + (x * -2.0)));
}
def code(wj, x): return x + (wj * ((wj * ((1.0 + (1.0 + (-1.0 - (wj * ((-2.0 * (x * -2.5)) + ((x * 0.6666666666666666) - (-1.0 - (x * -3.0)))))))) + (x * 2.5))) + (x * -2.0)))
function code(wj, x) return Float64(x + Float64(wj * Float64(Float64(wj * Float64(Float64(1.0 + Float64(1.0 + Float64(-1.0 - Float64(wj * Float64(Float64(-2.0 * Float64(x * -2.5)) + Float64(Float64(x * 0.6666666666666666) - Float64(-1.0 - Float64(x * -3.0)))))))) + Float64(x * 2.5))) + Float64(x * -2.0)))) end
function tmp = code(wj, x) tmp = x + (wj * ((wj * ((1.0 + (1.0 + (-1.0 - (wj * ((-2.0 * (x * -2.5)) + ((x * 0.6666666666666666) - (-1.0 - (x * -3.0)))))))) + (x * 2.5))) + (x * -2.0))); end
code[wj_, x_] := N[(x + N[(wj * N[(N[(wj * N[(N[(1.0 + N[(1.0 + N[(-1.0 - N[(wj * N[(N[(-2.0 * N[(x * -2.5), $MachinePrecision]), $MachinePrecision] + N[(N[(x * 0.6666666666666666), $MachinePrecision] - N[(-1.0 - N[(x * -3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(x * 2.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(x * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + wj \cdot \left(wj \cdot \left(\left(1 + \left(1 + \left(-1 - wj \cdot \left(-2 \cdot \left(x \cdot -2.5\right) + \left(x \cdot 0.6666666666666666 - \left(-1 - x \cdot -3\right)\right)\right)\right)\right)\right) + x \cdot 2.5\right) + x \cdot -2\right)
\end{array}
Initial program 78.1%
sub-neg78.1%
distribute-neg-frac78.1%
distribute-rgt1-in78.9%
associate-/l/78.8%
sub-neg78.8%
+-commutative78.8%
distribute-neg-in78.8%
remove-double-neg78.8%
sub-neg78.8%
div-sub78.0%
associate-/l*78.0%
*-inverses80.0%
*-rgt-identity80.0%
Simplified80.0%
Taylor expanded in wj around 0 96.8%
cancel-sign-sub-inv96.8%
metadata-eval96.8%
Simplified96.8%
expm1-log1p-u87.4%
expm1-undefine87.4%
log1p-undefine87.4%
add-exp-log96.8%
*-commutative96.8%
associate-+l+96.8%
Applied egg-rr96.8%
Final simplification96.8%
(FPCore (wj x)
:precision binary64
(-
x
(*
wj
(-
(*
wj
(-
(+
(*
wj
(+
(+ 1.0 (* x -3.0))
(+ (* -2.0 (* x -2.5)) (* x 0.6666666666666666))))
-1.0)
(* x 2.5)))
(* x -2.0)))))
double code(double wj, double x) {
return x - (wj * ((wj * (((wj * ((1.0 + (x * -3.0)) + ((-2.0 * (x * -2.5)) + (x * 0.6666666666666666)))) + -1.0) - (x * 2.5))) - (x * -2.0)));
}
real(8) function code(wj, x)
real(8), intent (in) :: wj
real(8), intent (in) :: x
code = x - (wj * ((wj * (((wj * ((1.0d0 + (x * (-3.0d0))) + (((-2.0d0) * (x * (-2.5d0))) + (x * 0.6666666666666666d0)))) + (-1.0d0)) - (x * 2.5d0))) - (x * (-2.0d0))))
end function
public static double code(double wj, double x) {
return x - (wj * ((wj * (((wj * ((1.0 + (x * -3.0)) + ((-2.0 * (x * -2.5)) + (x * 0.6666666666666666)))) + -1.0) - (x * 2.5))) - (x * -2.0)));
}
def code(wj, x): return x - (wj * ((wj * (((wj * ((1.0 + (x * -3.0)) + ((-2.0 * (x * -2.5)) + (x * 0.6666666666666666)))) + -1.0) - (x * 2.5))) - (x * -2.0)))
function code(wj, x) return Float64(x - Float64(wj * Float64(Float64(wj * Float64(Float64(Float64(wj * Float64(Float64(1.0 + Float64(x * -3.0)) + Float64(Float64(-2.0 * Float64(x * -2.5)) + Float64(x * 0.6666666666666666)))) + -1.0) - Float64(x * 2.5))) - Float64(x * -2.0)))) end
function tmp = code(wj, x) tmp = x - (wj * ((wj * (((wj * ((1.0 + (x * -3.0)) + ((-2.0 * (x * -2.5)) + (x * 0.6666666666666666)))) + -1.0) - (x * 2.5))) - (x * -2.0))); end
code[wj_, x_] := N[(x - N[(wj * N[(N[(wj * N[(N[(N[(wj * N[(N[(1.0 + N[(x * -3.0), $MachinePrecision]), $MachinePrecision] + N[(N[(-2.0 * N[(x * -2.5), $MachinePrecision]), $MachinePrecision] + N[(x * 0.6666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision] - N[(x * 2.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(x * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x - wj \cdot \left(wj \cdot \left(\left(wj \cdot \left(\left(1 + x \cdot -3\right) + \left(-2 \cdot \left(x \cdot -2.5\right) + x \cdot 0.6666666666666666\right)\right) + -1\right) - x \cdot 2.5\right) - x \cdot -2\right)
\end{array}
Initial program 78.1%
sub-neg78.1%
distribute-neg-frac78.1%
distribute-rgt1-in78.9%
associate-/l/78.8%
sub-neg78.8%
+-commutative78.8%
distribute-neg-in78.8%
remove-double-neg78.8%
sub-neg78.8%
div-sub78.0%
associate-/l*78.0%
*-inverses80.0%
*-rgt-identity80.0%
Simplified80.0%
Taylor expanded in wj around 0 96.8%
cancel-sign-sub-inv96.8%
metadata-eval96.8%
Simplified96.8%
Final simplification96.8%
(FPCore (wj x) :precision binary64 (+ x (* wj (- (* x -2.0) (* wj (- 1.0 (+ 2.0 (- (* x 2.5) wj))))))))
double code(double wj, double x) {
return x + (wj * ((x * -2.0) - (wj * (1.0 - (2.0 + ((x * 2.5) - wj))))));
}
real(8) function code(wj, x)
real(8), intent (in) :: wj
real(8), intent (in) :: x
code = x + (wj * ((x * (-2.0d0)) - (wj * (1.0d0 - (2.0d0 + ((x * 2.5d0) - wj))))))
end function
public static double code(double wj, double x) {
return x + (wj * ((x * -2.0) - (wj * (1.0 - (2.0 + ((x * 2.5) - wj))))));
}
def code(wj, x): return x + (wj * ((x * -2.0) - (wj * (1.0 - (2.0 + ((x * 2.5) - wj))))))
function code(wj, x) return Float64(x + Float64(wj * Float64(Float64(x * -2.0) - Float64(wj * Float64(1.0 - Float64(2.0 + Float64(Float64(x * 2.5) - wj))))))) end
function tmp = code(wj, x) tmp = x + (wj * ((x * -2.0) - (wj * (1.0 - (2.0 + ((x * 2.5) - wj)))))); end
code[wj_, x_] := N[(x + N[(wj * N[(N[(x * -2.0), $MachinePrecision] - N[(wj * N[(1.0 - N[(2.0 + N[(N[(x * 2.5), $MachinePrecision] - wj), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + wj \cdot \left(x \cdot -2 - wj \cdot \left(1 - \left(2 + \left(x \cdot 2.5 - wj\right)\right)\right)\right)
\end{array}
Initial program 78.1%
sub-neg78.1%
distribute-neg-frac78.1%
distribute-rgt1-in78.9%
associate-/l/78.8%
sub-neg78.8%
+-commutative78.8%
distribute-neg-in78.8%
remove-double-neg78.8%
sub-neg78.8%
div-sub78.0%
associate-/l*78.0%
*-inverses80.0%
*-rgt-identity80.0%
Simplified80.0%
Taylor expanded in wj around 0 96.8%
cancel-sign-sub-inv96.8%
metadata-eval96.8%
Simplified96.8%
expm1-log1p-u87.4%
expm1-undefine87.4%
log1p-undefine87.4%
add-exp-log96.8%
*-commutative96.8%
associate-+l+96.8%
Applied egg-rr96.8%
Taylor expanded in x around 0 96.7%
expm1-log1p-u71.7%
expm1-undefine71.7%
*-un-lft-identity71.7%
add-exp-log71.7%
expm1-define71.7%
log1p-define71.7%
expm1-log1p-u71.7%
Applied egg-rr71.7%
sub-neg71.7%
log1p-undefine71.7%
rem-exp-log96.7%
sub-neg96.7%
*-commutative96.7%
associate-+r+96.7%
mul-1-neg96.7%
associate-+r+96.7%
metadata-eval96.7%
mul-1-neg96.7%
+-commutative96.7%
fma-define96.7%
fma-neg96.7%
metadata-eval96.7%
Simplified96.7%
Final simplification96.7%
(FPCore (wj x) :precision binary64 (if (<= wj 3.8e-10) (+ x (* (- 1.0 wj) (* wj wj))) (- wj (/ (- (- x (* wj x)) wj) (- -1.0 wj)))))
double code(double wj, double x) {
double tmp;
if (wj <= 3.8e-10) {
tmp = x + ((1.0 - wj) * (wj * wj));
} else {
tmp = wj - (((x - (wj * x)) - wj) / (-1.0 - wj));
}
return tmp;
}
real(8) function code(wj, x)
real(8), intent (in) :: wj
real(8), intent (in) :: x
real(8) :: tmp
if (wj <= 3.8d-10) then
tmp = x + ((1.0d0 - wj) * (wj * wj))
else
tmp = wj - (((x - (wj * x)) - wj) / ((-1.0d0) - wj))
end if
code = tmp
end function
public static double code(double wj, double x) {
double tmp;
if (wj <= 3.8e-10) {
tmp = x + ((1.0 - wj) * (wj * wj));
} else {
tmp = wj - (((x - (wj * x)) - wj) / (-1.0 - wj));
}
return tmp;
}
def code(wj, x): tmp = 0 if wj <= 3.8e-10: tmp = x + ((1.0 - wj) * (wj * wj)) else: tmp = wj - (((x - (wj * x)) - wj) / (-1.0 - wj)) return tmp
function code(wj, x) tmp = 0.0 if (wj <= 3.8e-10) tmp = Float64(x + Float64(Float64(1.0 - wj) * Float64(wj * wj))); else tmp = Float64(wj - Float64(Float64(Float64(x - Float64(wj * x)) - wj) / Float64(-1.0 - wj))); end return tmp end
function tmp_2 = code(wj, x) tmp = 0.0; if (wj <= 3.8e-10) tmp = x + ((1.0 - wj) * (wj * wj)); else tmp = wj - (((x - (wj * x)) - wj) / (-1.0 - wj)); end tmp_2 = tmp; end
code[wj_, x_] := If[LessEqual[wj, 3.8e-10], N[(x + N[(N[(1.0 - wj), $MachinePrecision] * N[(wj * wj), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(wj - N[(N[(N[(x - N[(wj * x), $MachinePrecision]), $MachinePrecision] - wj), $MachinePrecision] / N[(-1.0 - wj), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;wj \leq 3.8 \cdot 10^{-10}:\\
\;\;\;\;x + \left(1 - wj\right) \cdot \left(wj \cdot wj\right)\\
\mathbf{else}:\\
\;\;\;\;wj - \frac{\left(x - wj \cdot x\right) - wj}{-1 - wj}\\
\end{array}
\end{array}
if wj < 3.7999999999999998e-10Initial program 78.7%
sub-neg78.7%
distribute-neg-frac78.7%
distribute-rgt1-in79.5%
associate-/l/79.5%
sub-neg79.5%
+-commutative79.5%
distribute-neg-in79.5%
remove-double-neg79.5%
sub-neg79.5%
div-sub78.7%
associate-/l*78.7%
*-inverses79.5%
*-rgt-identity79.5%
Simplified79.5%
Taylor expanded in wj around 0 98.3%
cancel-sign-sub-inv98.3%
metadata-eval98.3%
Simplified98.3%
expm1-log1p-u89.0%
expm1-undefine89.0%
log1p-undefine89.0%
add-exp-log98.3%
*-commutative98.3%
associate-+l+98.3%
Applied egg-rr98.3%
Taylor expanded in x around 0 98.2%
Taylor expanded in x around 0 97.6%
unpow297.6%
Simplified97.6%
if 3.7999999999999998e-10 < wj Initial program 58.3%
sub-neg58.3%
distribute-neg-frac58.3%
distribute-rgt1-in58.3%
associate-/l/58.4%
sub-neg58.4%
+-commutative58.4%
distribute-neg-in58.4%
remove-double-neg58.4%
sub-neg58.4%
div-sub58.4%
associate-/l*58.4%
*-inverses95.9%
*-rgt-identity95.9%
Simplified95.9%
Taylor expanded in wj around 0 84.7%
mul-1-neg84.7%
unsub-neg84.7%
*-commutative84.7%
Simplified84.7%
Final simplification97.2%
(FPCore (wj x) :precision binary64 (+ x (* wj (+ (* x -2.0) (* wj (- 1.0 wj))))))
double code(double wj, double x) {
return x + (wj * ((x * -2.0) + (wj * (1.0 - wj))));
}
real(8) function code(wj, x)
real(8), intent (in) :: wj
real(8), intent (in) :: x
code = x + (wj * ((x * (-2.0d0)) + (wj * (1.0d0 - wj))))
end function
public static double code(double wj, double x) {
return x + (wj * ((x * -2.0) + (wj * (1.0 - wj))));
}
def code(wj, x): return x + (wj * ((x * -2.0) + (wj * (1.0 - wj))))
function code(wj, x) return Float64(x + Float64(wj * Float64(Float64(x * -2.0) + Float64(wj * Float64(1.0 - wj))))) end
function tmp = code(wj, x) tmp = x + (wj * ((x * -2.0) + (wj * (1.0 - wj)))); end
code[wj_, x_] := N[(x + N[(wj * N[(N[(x * -2.0), $MachinePrecision] + N[(wj * N[(1.0 - wj), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + wj \cdot \left(x \cdot -2 + wj \cdot \left(1 - wj\right)\right)
\end{array}
Initial program 78.1%
sub-neg78.1%
distribute-neg-frac78.1%
distribute-rgt1-in78.9%
associate-/l/78.8%
sub-neg78.8%
+-commutative78.8%
distribute-neg-in78.8%
remove-double-neg78.8%
sub-neg78.8%
div-sub78.0%
associate-/l*78.0%
*-inverses80.0%
*-rgt-identity80.0%
Simplified80.0%
Taylor expanded in wj around 0 96.8%
cancel-sign-sub-inv96.8%
metadata-eval96.8%
Simplified96.8%
Taylor expanded in x around 0 96.5%
Final simplification96.5%
(FPCore (wj x) :precision binary64 (+ x (* (- 1.0 wj) (* wj wj))))
double code(double wj, double x) {
return x + ((1.0 - wj) * (wj * wj));
}
real(8) function code(wj, x)
real(8), intent (in) :: wj
real(8), intent (in) :: x
code = x + ((1.0d0 - wj) * (wj * wj))
end function
public static double code(double wj, double x) {
return x + ((1.0 - wj) * (wj * wj));
}
def code(wj, x): return x + ((1.0 - wj) * (wj * wj))
function code(wj, x) return Float64(x + Float64(Float64(1.0 - wj) * Float64(wj * wj))) end
function tmp = code(wj, x) tmp = x + ((1.0 - wj) * (wj * wj)); end
code[wj_, x_] := N[(x + N[(N[(1.0 - wj), $MachinePrecision] * N[(wj * wj), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(1 - wj\right) \cdot \left(wj \cdot wj\right)
\end{array}
Initial program 78.1%
sub-neg78.1%
distribute-neg-frac78.1%
distribute-rgt1-in78.9%
associate-/l/78.8%
sub-neg78.8%
+-commutative78.8%
distribute-neg-in78.8%
remove-double-neg78.8%
sub-neg78.8%
div-sub78.0%
associate-/l*78.0%
*-inverses80.0%
*-rgt-identity80.0%
Simplified80.0%
Taylor expanded in wj around 0 96.8%
cancel-sign-sub-inv96.8%
metadata-eval96.8%
Simplified96.8%
expm1-log1p-u87.4%
expm1-undefine87.4%
log1p-undefine87.4%
add-exp-log96.8%
*-commutative96.8%
associate-+l+96.8%
Applied egg-rr96.8%
Taylor expanded in x around 0 96.7%
Taylor expanded in x around 0 95.6%
unpow295.6%
Simplified95.6%
Final simplification95.6%
(FPCore (wj x) :precision binary64 (+ x (* wj (- wj x))))
double code(double wj, double x) {
return x + (wj * (wj - x));
}
real(8) function code(wj, x)
real(8), intent (in) :: wj
real(8), intent (in) :: x
code = x + (wj * (wj - x))
end function
public static double code(double wj, double x) {
return x + (wj * (wj - x));
}
def code(wj, x): return x + (wj * (wj - x))
function code(wj, x) return Float64(x + Float64(wj * Float64(wj - x))) end
function tmp = code(wj, x) tmp = x + (wj * (wj - x)); end
code[wj_, x_] := N[(x + N[(wj * N[(wj - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + wj \cdot \left(wj - x\right)
\end{array}
Initial program 78.1%
sub-neg78.1%
distribute-neg-frac78.1%
distribute-rgt1-in78.9%
associate-/l/78.8%
sub-neg78.8%
+-commutative78.8%
distribute-neg-in78.8%
remove-double-neg78.8%
sub-neg78.8%
div-sub78.0%
associate-/l*78.0%
*-inverses80.0%
*-rgt-identity80.0%
Simplified80.0%
Taylor expanded in wj around 0 77.5%
Taylor expanded in wj around 0 95.2%
sub-neg95.2%
neg-mul-195.2%
remove-double-neg95.2%
+-commutative95.2%
Simplified95.2%
Taylor expanded in x around 0 95.2%
(FPCore (wj x) :precision binary64 (+ x (* wj wj)))
double code(double wj, double x) {
return x + (wj * wj);
}
real(8) function code(wj, x)
real(8), intent (in) :: wj
real(8), intent (in) :: x
code = x + (wj * wj)
end function
public static double code(double wj, double x) {
return x + (wj * wj);
}
def code(wj, x): return x + (wj * wj)
function code(wj, x) return Float64(x + Float64(wj * wj)) end
function tmp = code(wj, x) tmp = x + (wj * wj); end
code[wj_, x_] := N[(x + N[(wj * wj), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + wj \cdot wj
\end{array}
Initial program 78.1%
sub-neg78.1%
distribute-neg-frac78.1%
distribute-rgt1-in78.9%
associate-/l/78.8%
sub-neg78.8%
+-commutative78.8%
distribute-neg-in78.8%
remove-double-neg78.8%
sub-neg78.8%
div-sub78.0%
associate-/l*78.0%
*-inverses80.0%
*-rgt-identity80.0%
Simplified80.0%
Taylor expanded in wj around 0 77.5%
Taylor expanded in wj around 0 95.2%
sub-neg95.2%
neg-mul-195.2%
remove-double-neg95.2%
+-commutative95.2%
Simplified95.2%
Taylor expanded in x around 0 95.1%
(FPCore (wj x) :precision binary64 (* x (- 1.0 wj)))
double code(double wj, double x) {
return x * (1.0 - wj);
}
real(8) function code(wj, x)
real(8), intent (in) :: wj
real(8), intent (in) :: x
code = x * (1.0d0 - wj)
end function
public static double code(double wj, double x) {
return x * (1.0 - wj);
}
def code(wj, x): return x * (1.0 - wj)
function code(wj, x) return Float64(x * Float64(1.0 - wj)) end
function tmp = code(wj, x) tmp = x * (1.0 - wj); end
code[wj_, x_] := N[(x * N[(1.0 - wj), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \left(1 - wj\right)
\end{array}
Initial program 78.1%
sub-neg78.1%
distribute-neg-frac78.1%
distribute-rgt1-in78.9%
associate-/l/78.8%
sub-neg78.8%
+-commutative78.8%
distribute-neg-in78.8%
remove-double-neg78.8%
sub-neg78.8%
div-sub78.0%
associate-/l*78.0%
*-inverses80.0%
*-rgt-identity80.0%
Simplified80.0%
Taylor expanded in wj around 0 77.5%
Taylor expanded in wj around 0 85.9%
*-lft-identity85.9%
mul-1-neg85.9%
distribute-lft-neg-in85.9%
distribute-rgt-out85.9%
sub-neg85.9%
Simplified85.9%
(FPCore (wj x) :precision binary64 x)
double code(double wj, double x) {
return x;
}
real(8) function code(wj, x)
real(8), intent (in) :: wj
real(8), intent (in) :: x
code = x
end function
public static double code(double wj, double x) {
return x;
}
def code(wj, x): return x
function code(wj, x) return x end
function tmp = code(wj, x) tmp = x; end
code[wj_, x_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 78.1%
sub-neg78.1%
distribute-neg-frac78.1%
distribute-rgt1-in78.9%
associate-/l/78.8%
sub-neg78.8%
+-commutative78.8%
distribute-neg-in78.8%
remove-double-neg78.8%
sub-neg78.8%
div-sub78.0%
associate-/l*78.0%
*-inverses80.0%
*-rgt-identity80.0%
Simplified80.0%
Taylor expanded in wj around 0 85.9%
(FPCore (wj x) :precision binary64 wj)
double code(double wj, double x) {
return wj;
}
real(8) function code(wj, x)
real(8), intent (in) :: wj
real(8), intent (in) :: x
code = wj
end function
public static double code(double wj, double x) {
return wj;
}
def code(wj, x): return wj
function code(wj, x) return wj end
function tmp = code(wj, x) tmp = wj; end
code[wj_, x_] := wj
\begin{array}{l}
\\
wj
\end{array}
Initial program 78.1%
sub-neg78.1%
distribute-neg-frac78.1%
distribute-rgt1-in78.9%
associate-/l/78.8%
sub-neg78.8%
+-commutative78.8%
distribute-neg-in78.8%
remove-double-neg78.8%
sub-neg78.8%
div-sub78.0%
associate-/l*78.0%
*-inverses80.0%
*-rgt-identity80.0%
Simplified80.0%
Taylor expanded in wj around inf 4.7%
(FPCore (wj x) :precision binary64 (- wj (- (/ wj (+ wj 1.0)) (/ x (+ (exp wj) (* wj (exp wj)))))))
double code(double wj, double x) {
return wj - ((wj / (wj + 1.0)) - (x / (exp(wj) + (wj * exp(wj)))));
}
real(8) function code(wj, x)
real(8), intent (in) :: wj
real(8), intent (in) :: x
code = wj - ((wj / (wj + 1.0d0)) - (x / (exp(wj) + (wj * exp(wj)))))
end function
public static double code(double wj, double x) {
return wj - ((wj / (wj + 1.0)) - (x / (Math.exp(wj) + (wj * Math.exp(wj)))));
}
def code(wj, x): return wj - ((wj / (wj + 1.0)) - (x / (math.exp(wj) + (wj * math.exp(wj)))))
function code(wj, x) return Float64(wj - Float64(Float64(wj / Float64(wj + 1.0)) - Float64(x / Float64(exp(wj) + Float64(wj * exp(wj)))))) end
function tmp = code(wj, x) tmp = wj - ((wj / (wj + 1.0)) - (x / (exp(wj) + (wj * exp(wj))))); end
code[wj_, x_] := N[(wj - N[(N[(wj / N[(wj + 1.0), $MachinePrecision]), $MachinePrecision] - N[(x / N[(N[Exp[wj], $MachinePrecision] + N[(wj * N[Exp[wj], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
wj - \left(\frac{wj}{wj + 1} - \frac{x}{e^{wj} + wj \cdot e^{wj}}\right)
\end{array}
herbie shell --seed 2024107
(FPCore (wj x)
:name "Jmat.Real.lambertw, newton loop step"
:precision binary64
:alt
(- wj (- (/ wj (+ wj 1.0)) (/ x (+ (exp wj) (* wj (exp wj))))))
(- wj (/ (- (* wj (exp wj)) x) (+ (exp wj) (* wj (exp wj))))))