
(FPCore (x) :precision binary64 (- (log x) (log (log x))))
double code(double x) {
return log(x) - log(log(x));
}
real(8) function code(x)
real(8), intent (in) :: x
code = log(x) - log(log(x))
end function
public static double code(double x) {
return Math.log(x) - Math.log(Math.log(x));
}
def code(x): return math.log(x) - math.log(math.log(x))
function code(x) return Float64(log(x) - log(log(x))) end
function tmp = code(x) tmp = log(x) - log(log(x)); end
code[x_] := N[(N[Log[x], $MachinePrecision] - N[Log[N[Log[x], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\log x - \log \log x
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 3 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x) :precision binary64 (- (log x) (log (log x))))
double code(double x) {
return log(x) - log(log(x));
}
real(8) function code(x)
real(8), intent (in) :: x
code = log(x) - log(log(x))
end function
public static double code(double x) {
return Math.log(x) - Math.log(Math.log(x));
}
def code(x): return math.log(x) - math.log(math.log(x))
function code(x) return Float64(log(x) - log(log(x))) end
function tmp = code(x) tmp = log(x) - log(log(x)); end
code[x_] := N[(N[Log[x], $MachinePrecision] - N[Log[N[Log[x], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\log x - \log \log x
\end{array}
(FPCore (x) :precision binary64 (- (log (/ (log x) x))))
double code(double x) {
return -log((log(x) / x));
}
real(8) function code(x)
real(8), intent (in) :: x
code = -log((log(x) / x))
end function
public static double code(double x) {
return -Math.log((Math.log(x) / x));
}
def code(x): return -math.log((math.log(x) / x))
function code(x) return Float64(-log(Float64(log(x) / x))) end
function tmp = code(x) tmp = -log((log(x) / x)); end
code[x_] := (-N[Log[N[(N[Log[x], $MachinePrecision] / x), $MachinePrecision]], $MachinePrecision])
\begin{array}{l}
\\
-\log \left(\frac{\log x}{x}\right)
\end{array}
Initial program 99.6%
lift-log.f64N/A
lift-log.f6499.6
remove-double-negN/A
neg-sub0N/A
flip3--N/A
metadata-evalN/A
neg-sub0N/A
cube-negN/A
sqr-powN/A
unpow-prod-downN/A
sqr-negN/A
pow-prod-downN/A
sqr-powN/A
distribute-frac-negN/A
Applied rewrites99.6%
lift-log.f64N/A
lift-log.f64N/A
metadata-evalN/A
lift-log.f64N/A
unpow1N/A
metadata-evalN/A
pow-divN/A
lift-pow.f64N/A
unpow1N/A
clear-numN/A
--rgt-identityN/A
lift--.f64N/A
log-recN/A
unpow1N/A
lift--.f64N/A
--rgt-identityN/A
lift-pow.f64N/A
pow-divN/A
metadata-evalN/A
inv-powN/A
Applied rewrites100.0%
Applied rewrites30.9%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-log.f64N/A
lift-*.f64N/A
frac-2negN/A
*-rgt-identityN/A
log-divN/A
*-rgt-identityN/A
log-divN/A
frac-2negN/A
clear-numN/A
log-recN/A
lower-neg.f64N/A
Applied rewrites100.0%
(FPCore (x) :precision binary64 (log (/ x (log x))))
double code(double x) {
return log((x / log(x)));
}
real(8) function code(x)
real(8), intent (in) :: x
code = log((x / log(x)))
end function
public static double code(double x) {
return Math.log((x / Math.log(x)));
}
def code(x): return math.log((x / math.log(x)))
function code(x) return log(Float64(x / log(x))) end
function tmp = code(x) tmp = log((x / log(x))); end
code[x_] := N[Log[N[(x / N[Log[x], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\log \left(\frac{x}{\log x}\right)
\end{array}
Initial program 99.6%
lift-log.f64N/A
lift-log.f6499.6
remove-double-negN/A
neg-sub0N/A
flip3--N/A
metadata-evalN/A
neg-sub0N/A
cube-negN/A
sqr-powN/A
unpow-prod-downN/A
sqr-negN/A
pow-prod-downN/A
sqr-powN/A
distribute-frac-negN/A
Applied rewrites99.6%
lift-log.f64N/A
lift-log.f64N/A
metadata-evalN/A
lift-log.f64N/A
unpow1N/A
metadata-evalN/A
pow-divN/A
lift-pow.f64N/A
unpow1N/A
clear-numN/A
--rgt-identityN/A
lift--.f64N/A
log-recN/A
unpow1N/A
lift--.f64N/A
--rgt-identityN/A
lift-pow.f64N/A
pow-divN/A
metadata-evalN/A
inv-powN/A
Applied rewrites100.0%
(FPCore (x) :precision binary64 (log (* x (log x))))
double code(double x) {
return log((x * log(x)));
}
real(8) function code(x)
real(8), intent (in) :: x
code = log((x * log(x)))
end function
public static double code(double x) {
return Math.log((x * Math.log(x)));
}
def code(x): return math.log((x * math.log(x)))
function code(x) return log(Float64(x * log(x))) end
function tmp = code(x) tmp = log((x * log(x))); end
code[x_] := N[Log[N[(x * N[Log[x], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\log \left(x \cdot \log x\right)
\end{array}
Initial program 99.6%
lift-log.f64N/A
diff-logN/A
lower-log.f64N/A
div-invN/A
inv-powN/A
pow-to-expN/A
lift-log.f64N/A
*-commutativeN/A
neg-mul-1N/A
neg-sub0N/A
flip3--N/A
metadata-evalN/A
neg-sub0N/A
distribute-frac-negN/A
Applied rewrites25.0%
herbie shell --seed 2024216
(FPCore (x)
:name "Jmat.Real.lambertw, estimator"
:precision binary64
(- (log x) (log (log x))))