How to calculate Estimated Arithmetic Mean for a lognormal distribution I have been tasked to program functions from some Excel sheet into a asp.net app so it can be shared to my colleagues via a web interface. However, I am stuck on one thing.
I have a set of variables $X = \{0.043, 0.236, 0.057, 0.016\}$ and I have been able to calculate all the descriptive statistics and plot a lognormal graph, etc., but I need to calculate the estimated arithmetic mean which is giving me a headache as I can't find much information on this.
The Excel sheet says the estimated arithmetic mean should be $0.085$. I would be grateful if anybody could sketch me the algorithm needed to get this value as I can't find out how Excel is doing it.
I know it is fit to be normally and lognormally distributed and here are some of the things I have calculated for this series that may help:
Mean: 0.088
Median: 0.05
Standard deviation: 0.1
Geometric mean: 0.0552
Geometric standard deviation: 3.04
W-test of log transformed data: 0.970
W-test of data: 0.786
mean of log(samples): -2.897
standard deviation of log(samples): 1.1117  
Edit: Thank you all for your help, it has helped me a lot. I have translated whuber's algorithm in C# code in case anyone needs it:
public double Finney(int m, double z)
    {
        int i = 0;
        int iMax = 0;
        double a = 1;
        double g = a;
        double x = 0;
        const double aTol = 0.0000000001;
        const int itermax = 1000;

        if (m <= -1)
        {  return 0;  }

        x = (z * m * m) / (m + 1);

        if (Math.Abs(x) < aTol)
        {  return 1;  }

        iMax = Int32.Parse(Math.Round((Math.Abs(Math.Round(z) + 1) + 20)).ToString());

        if (iMax > itermax)
        {  return 0;  }

        for (i = 1; i <= iMax; i++ )
        {
            if(Math.Abs(a) <= (aTol * Math.Abs(g)))
            {  break;  }
            a = (a * x) / (m + (2 * (i - 1))) / i;
            g = g + a;
        }

        return g;

    }

 A: @whuber gave already a complete answer. For convenience, I want to share an implementation of whuber's algorithm in R along with two other solutions using pre-existing packages.
Using whuber's algorithm
#-----------------------------------------------------------------------------
# The data
#-----------------------------------------------------------------------------

x <- c(0.043, 0.236, 0.057, 0.016)
n <- length(x)
logx <- log(x)

log.mean <- mean(logx)
log.sd <- sd(logx)

#-----------------------------------------------------------------------------
# R-translation of whuber's algorithm "Finney"
#-----------------------------------------------------------------------------

Finney <- function(m, z, maxiter = 1000, aTol = 1e-10){

  aTol <- aTol  

  iterMax <- maxiter

  if (m <= -1) {
    stop("Finney = 0")
  }

  x <- z*m*m/(m + 1)

  if (abs(x) < aTol) { 
    return(Finney = 1L)
  }

  iMax <- abs(trunc(z) + 1) + 20

  if (iMax > iterMax) {
    stop("iMax > iterMax")
  }

  a <- 1L
  g <- a

  for  (i in seq(iMax)) {    
    if (abs(a) <= aTol*abs(g)) {
      break()
    } 
    a <- a*x/(m + 2*(i - 1))/i
    g = g + a
  }
return(g)
}

# Sanity check

Finney(n-1, log.sd^2/2)
[1] 1.532355

exp(log.mean)*Finney(n-1, log.sd^2/2)
[1] 0.08451876


Using the hypergeo package
Seems correct. Now the solution using the R package hypergeo. The UMVUE for the arithmetic mean can also be calculated using the $_0F_{1}$ Hypergeometric function in the following way:
$$
m(x) = \exp{(\bar{y})}_0F_{1}\left(;\frac{(n-1)}{2};\frac{(n-1)^{2}s_{y}^{2}}{4n}\right)
$$
#-----------------------------------------------------------------------------
# Using the package "hypergeo"
#-----------------------------------------------------------------------------

require(hypergeo)

genhypergeo(NULL, (n-1)/2, ((n - 1)^2*log.sd^2)/(4*n))
[1] 1.532355

exp(log.mean)*genhypergeo(NULL, (n-1)/2, ((n - 1)^2*log.sd^2)/(4*n))
[1] 0.08451876


Using the EnvStats package
The package EnvStat has a function elnormAlt that estimates the mean (optionally with a confidence interval) and the coefficient of variation of a lognormal distribution using several methods. Choose the option method = "mvue" to reproduce the results shown above:
#-----------------------------------------------------------------------------
# Using the package "EnvStats"
#-----------------------------------------------------------------------------

require(EnvStats)

elnormAlt(x, method = "mvue", ci = FALSE)

Results of Distribution Parameter Estimation
--------------------------------------------

Assumed Distribution:            Lognormal

Estimated Parameter(s):          mean = 0.08451876
                                 cv   = 1.02389278

Estimation Method:               mvue

Data:                            x

Sample Size:                     4


Timing the three implementations
Finally, here is a comparison of how long it takes to apply the three methods to 1,000 samples of size $n=5,10,15,...,1000$, using @whuber's method as the baseline.

The functions from the EnvStats and hypergeo packages presumably have more error handling and more options, which at least partially can explain why they take so much longer. The R code used for the comparison follows below:
nvec<-seq(10,1000,10)
B<-1000
reftime<-time1<-time2<-time3<-rep(NA,length(nvec))

# Compile the COOLSerdash-Whuber function:
require(compiler)
Finney<-cmpfun(Finney)

for(i in 1:length(nvec))
{
n<-nvec[i]
cat(n,"\n")

## Just generate some LNorm data:
start.time <- Sys.time()
for(j in 1:B) {x<-rlnorm(n)}
end.time <- Sys.time()
reftime[i]<-end.time - start.time

## Whuber's method:
start.time <- Sys.time()
for(j in 1:B) {x<-rlnorm(n); exp(log.mean)*Finney(n-1, log.sd^2/2)
 }
end.time <- Sys.time()
time1[i]<-end.time - start.time


## Hypergeo:
start.time <- Sys.time()
for(j in 1:B) {x<-rlnorm(n); exp(log.mean)*genhypergeo(NULL, (n-1)/2, ((n - 1)^2*log.sd^2)/(4*n))
 }
end.time <- Sys.time()
time2[i]<-end.time - start.time

## EnvStats:
start.time <- Sys.time()
for(j in 1:B) {x<-rlnorm(n); elnormAlt(x, method = "mvue", ci = FALSE)  }
end.time <- Sys.time()
time3[i]<-end.time - start.time

}

## 
time1<-time1-reftime
time2<-time2-reftime
time3<-time3-reftime

## Save the results:
plot(nvec,time1,type="l",lwd=3,ylim=c(0,max(time3/time1)),ylab="Relative execution time",xlab="Sample size n",cex.lab=1.5,cex.axis=1.5,cex.main=1.5,main="Relative execution time")
lines(nvec,time2/time1,type="l",lwd=3,col=2)
lines(nvec,time3/time1,type="l",lwd=3,col=4)
legend(600,19,c("@whuber","hypergeo","EnvStats"),col=c(1,2,4),lwd=2,cex=1.5)

