A Simple Randomized Algorithm to Compute Harmonic Numbers and Logarithms

TL;DR

This paper introduces a simple randomized algorithm that efficiently approximates harmonic numbers and logarithms by leveraging properties of maximum values in random lists, with potential extensions for various bases and arguments.

Contribution

The paper presents a novel randomized method for approximating harmonic numbers and logarithms, connecting maximum value statistics with logarithmic functions.

Findings

Efficient approximation of harmonic numbers using random maximums.

Approximation of natural logarithm from harmonic numbers with increasing accuracy.

Extension capability to approximate logarithms with different bases and rational arguments.

Abstract

Given a list of N numbers, the maximum can be computed in N iterations. During these N iterations, the maximum gets updated on average as many times as the Nth harmonic number. We first use this fact to approximate the Nth harmonic number as a side effect. Further, using the fact the Nth harmonic number is equal to the natural logarithm of N plus a constant that goes to zero with N, we approximate the natural logarithm from the harmonic number. To improve accuracy, we repeat the computation over many lists of uniformly generated random numbers. The algorithm is easily extended to approximate logarithms with integer bases or rational arguments.

Figures

Equations

$$H_x=\sum _{i=1}^x\frac{1}{i}=\ln (x)+\gamma +{ϵ}_x$$

$$\ln (x)=H_x-\gamma -{ϵ}_x.$$

Full text

1 Introduction

We approximately compute the harmonic number and the natural logarithm of an integer as a side effect of computing the maximum of a list of $x$ numbers randomly drawn from a uniform distribution. The key point of this computation is that it basically uses only counting. To improve accuracy, we repeat the computation multiple times and take the average. Using the basic properties of the natural logarithm function, it is simple to extend the algorithm to approximate the logarithms with integer bases or rational arguments. The details follow.

2 Computing the Maximum

Given a list of $x$ numbers in the interval $[0.0,1.0)$, where $x>0$, the algorithm (written in the Python programming language) in Figure 1 computes the maximum in $x$ iterations. It is well known that during these iterations, the maximum gets updated $H_{x}$ times on average, where $H_{x}$ is the $x$th harmonic number [1]. The reason for this fact is that in a list of $x$ numbers randomly drawn from a uniform distribution, each number has a probability of $1/x$ of being the maximum.

3 Computing the Harmonic Number and the Natural Logarithm

The $x$th harmonic number $H_{x}$ is defined as the series

[TABLE]

where $\gamma$ is the Euler-Mascheroni constant (roughly equal to $0.57721$) and $\epsilon_{x}$, which is in the interval $(\frac{1}{2(x+1)},\frac{1}{2x})$, approaches [math] as $x$ goes to infinity [2].

We can rewrite this equation to compute $\ln(x)$ as

[TABLE]

This means an approximation to $H_{x}$ can be converted to an approximation to $\ln(x)$.

The algorithm (written in the Python programming language) is given in Figure 2. The inner loop computes the maximum over $x$ uniformly random numbers. The outer loop with $n$ iterations is for accuracy improvement; it computes an approximation to $H_{x}$ every iteration as a side effect of the maximum computation rather than the result of the summation in Equation 1. This $H_{x}$ computation is an approximation due to two reasons: 1) $H_{x}$ is never an integer except for $x=1$ [2], and 2) it is a probabilistic estimate. After these loops exit, the final $H_{x}$ is set to the average over all these approximations. The natural logarithm is then approximated at the end of this algorithm using Equation 2, where we set $\epsilon_{x}$ to its upper bound of $1/(2x)$.

4 Results

Some results from limited experiments as shown in Figure 3 indicate that the approximation quality is relatively good especially with larger arguments. In this figure, the approximate $\ln(x)$ is the value computed by the algorithm in the previous section and the library $\ln(x)$ is the log function from the Python Math library.

Though we used 1000 repetitions for the results shown, separate limited experiments show that the approximation quality gets better after as low as 10 repetitions.

5 Pros and Cons

This algorithm to approximate the harmonic number and the natural logarithm takes time proportional to the product of $x$ and $n$. Even for $n=1$, the time is linear in $x$. As such, this is probably not an efficient way of computing the harmonic number or the natural logarithm. What is the use of this algorithm then?

One reason, possibly the main reason, why this algorithm may be interesting is that it approximately computes a function that occurs in its own time complexity analysis. Here the functions are the harmonic number as well as the natural logarithm. Another reason is that this algorithm uses integer arithmetic only except for the final averaging and error computation. Finally, this algorithm is easily parallelizable since the maximum of a list is equal to the maximum over the maximums of parts of the list.

In the technical literature, there are of course many formulas and algorithms for computing both functions [2]. This is expected as the harmonic number and the natural logarithm are so fundamental. This paper is not meant to provide any comparisons with those algorithms or to claim that it is better; it is mainly a fun application on the use of the side effect of a well known and simple algorithm, namely, the maximum computation.

6 Conclusions

We provide a simple algorithm that exploits the time complexity expression of the maximum computation of a list of numbers to approximate the harmonic number and then using it to approximate the natural logarithm. Limited experiments show that the approximations are good with small relative and absolute errors. We hope others may find this algorithm interesting enough to study and potentially improve. At a minimum this paper might hopefully inspire some exercises for students of a basic algorithms book like [1].