An Insight into the Data Structure of the Dynamic Batch Means Algorithm with Binary Tree Code

Abstract

Batching is a well-known method used to estimate the variance of the sample mean in steady-state simulation. Dynamic batching is a novel technique employed to implement traditional batch means estimators without the knowledge of the simulation run length a priori. In this study, we reinvestigated the dynamic batch means (DBM) algorithm with binary tree hierarchy and further proposed a binary coding idea to construct the corresponding data structure. We also present a closed-form expression for the DBM estimator with binary tree coding idea. This closed-form expression implies a mathematical expression that clearly defines itself in an algebraic binary relation. Given that the sample size and storage space are known in advance, we can show that the computation complexity in the closed-form expression for obtaining the indexes $c_j^{\left(k\right)}$, i.e., the batch mean shifts $s$, is less than the effort in recursive expression.

1. Introduction

Consider a sequence $\left\{Y_1,Y_2,\cdots ,Y_n\right\}$ representing the $n$ random observations of simulation output from a covariance stationary stochastic process with an unknown mean $\mu =\mathrm{E}\left(Y_i\right)$ and an unknown variance ${\sigma }^2=\mathrm{var}\left(Y_i\right)$. For instance, $Y_i$ could represent the waiting time for the i-th customer in a certain queuing system or the transit time of the i-th part through a manufacturing line. We let $\mu$ be the performance measure, ${\stackrel{=}{Y}}_n={\sum }_{i=1}^n{Y}_i/n$ be the point estimator of $\mu$, and $\mathrm{var}\left({\stackrel{=}{Y}}_n\right)$ be the quality measure associated with using ${\stackrel{=}{Y}}_n$ to estimate $\mu$. Song and Schmeiser [1] showed the following:

$$n \mathrm{var}\left({\stackrel{=}{Y}}_n\right)={\gamma }_0{\sigma }^2-\frac{{\gamma }_1{\sigma }^2}{n}+o\left(n^{-1}\right)$$

(1)

where ${\gamma }_0=1+2{\sum }_{h=1}^{\infty }{\rho }_h$ is the sum of all correlations, ${\gamma }_1=2{\sum }_{h=1}^{\infty }h{\rho }_h$ is the sum of all weighted correlations, and ${\rho }_h=\mathrm{corr}\left(Y_i,Y_{i+h}\right)$ is the lag $h$ correlation of $Y_i$ and $Y_{i+h}$, which satisfies ${\rho }_h=O\left({\delta }^h\right)$ for $h=1,2,\cdots ,$ and $\delta \in \left(0,1\right)$ to reflect a general correlation structure appropriate for a wide range of stochastic processes, including waiting times in the steady-state M/M/1 queuing system [2].

Estimating the variance of the sample mean is a fundamental problem in simulation output analysis. It is crucial for the calculation of the confidence interval of the population mean [3] and the probability of selecting correctly from alternatives available to the decision-makers [4]. Currie and Chen [5] gave a tutorial that introduced some useful techniques for analyzing the output of stochastic simulation models, such as the methods for determining the optimal warm-up length and number of replications. Furthermore, the ways of using simulation to compare different systems were introduced as well. Chen [6] discussed how statistical techniques are applied in simulation output analysis, e.g., initialization bias reduction, tests of independence, and quantile estimation.

Batching [7] is a well-known technique used to estimate the variance of the sample mean in steady-state simulation. The batching idea is to divide $n$ observations into $b$ batches, each of which has the size $m$. Traditional batch means estimators [8,9,10] in simulation output analysis assume that the simulation run length or the sample size $n$ is known in advance. The storage requirements for these estimators typically require $O\left(n\right)$ space. Recently, some advanced methods of combining batch means estimators have been discussed. Song [11] proposed a rule that linearly combines two smallest batch size estimators and uses the optimal weight as the function of the sum of all correlations of the data process (${\gamma }_0$). The simulation results concluded that the Song rule provides significant advancements in estimating the variance of the sample mean. Vats et al. [12] discussed the multivariate output analysis and proposed the multivariate batch means estimator for Markov chain Monte Carlo (MCMC) simulation.

Dynamic batch means (DBM) estimators use Fishman’s idea [13] of periodically doubling batch sizes as sampling procedures. DBM estimators [14,15,16] use only finite storage space (i.e., fixed memory), increase batch size dynamically as simulation run length increases, and compute the batch means estimates according to the value of the current batch size. DBM estimators require only $O\left(1\right)$ storage space and no knowledge of the simulation run length a priori. Song [14] proposed the dynamic overlapping batch means estimator (DOBM), which allows users to implement the traditional overlapping batch means estimator (OBM) for $\left(100f\right)\%$ overlapping cases without knowing the sample size in advance, where $f=0,1/2,3/4,7/8,\cdots$. Song [14] also showed that DOBM and OBM are equivalent in terms of data structure properties using the recursive relationships.

In this study, we modified the DBM algorithm by incorporating a binary tree hierarchy and further proposed a binary coding idea to construct the corresponding data structure. Therefore, we present a closed-form expression for the DBM estimators with our binary tree coding idea. To the best of our knowledge, this closed-form expression is original and is proposed in this study to clearly define the mathematical expression for the estimator via a straightforward algebraic binary relation.

The remainder of this paper is organized as follows. Section 2 reviews the background of the traditional batch means and DBM estimators. Section 3 defines the binary tree hierarchy in developing the closed-form expression for the DBM estimators. Section 4 describes the computational effort analysis. Section 5 concludes the paper.

2. Background

2.1. Batch Means Estimators

Batching divides observations into batches ($b$ batches, with each batch having the size $m$, i.e., $n=bm$) and uses these batches as the basic data units for analysis. Song and Schmeiser [1] summarized and defined batch means estimators, including nonoverlapping batch means (NBM) [9], OBM [8], partial-overlapping batch means (PBM) [10], and spaced batch means (SBM) [17], as a special case of the following function of $m$ and $s$:

$${\widehat{V}}_{\mathrm{BM}}\left(m,s\right)=\frac{{\sum }_{i=1}^b{\left({\overline{Y}}_{s\left(i-1\right)+1,m}-{\stackrel{=}{Y}}_n\right)}^2}{d}$$

(2)

where $1\le s\le n-m$ is the distance (or shift) between the first observation of any two adjacent batches, $d=b\left(n{m}^{-1}-1\right)$, $\mathrm{b}=\left(n-m+s\right)/s$ is the number of batches (where $\lfloor x\rfloor$ is the greatest integer smaller than or equal to $x$),

$${\overline{Y}}_{s\left(i-1\right)+1,m}={{\displaystyle \sum }}_{j=1}^m\raisebox{1ex}{$Y_{s\left(i-1\right)+j}$}\!\left/ \!\raisebox{-1ex}{$m$}\right.$$

(3)

is the i-th batch mean, and $Y_{s\left(i-1\right)+j}$ is the j-th observation in the i-th batch.

The NBM estimator with batch size $m$ is the special case obtained when $s=m$. The OBM estimator with batch size $m$ is the special case obtained when $s=1$. The PBM estimator with batch size $m$ is the special case obtained when $1<s<m$. The $\left(100f\right)\%$ OBM, $0<f<1$, another form of PBM, indicates that $\left(100f\right)\%$ overlap exists among all data between two adjacent batches, where $f=1-\left(s/m\right)$ and $1<s<m$ (i.e., $0\le f<1$). For example, 75% OBM is the ${\widehat{V}}_{\mathrm{BM}}\left(m,s\right)$ estimator for $s=m/4$. The SBM estimator with batch size $m$ is the special case obtained when $s>m$.

2.2. Dynamic Batch Means Estimators

Yeh and Schmeiser [18] were the first to introduce the dynamic batching idea into NBM. Song [14] further proposed a general form for the $\left(100f\right)\%$ DOBM estimator using a recursive expression, where $f=0,1/2,3/4,7/8,\cdots$. Several DBM variations [15,16,19] have been recently developed for steady-state simulation output analysis.

In DBM, all data (the data here may be the sum of several consecutive observations) are stored in a vector $\underset{\_}{L}$ with size $2wg$ (i.e., $\underset{\_}{L}=\left[{\underset{\_}{A}}_1, {\underset{\_}{A}}_2, \cdots ,{\underset{\_}{A}}_w\right]$, ${\underset{\_}{A}}_j=\left[A_j\left(1\right), A_j\left(2\right),\cdots ,A_j\left(2g\right)\right]$, $j=1, 2, \cdots , w$), where $w$ and $g$ are two prespecified parameters: $w$ is the number of subvectors in $\underset{\_}{L}$, and $2g$ is the number of cells (memory size) for each subvector ${\underset{\_}{A}}_j$, $j=1, 2, \cdots , w$. The key idea behind the DBM involves collapsing the w vectors. DBM combines two particular adjacent batches stored in $\underset{\_}{L}$ when $\underset{\_}{L}$ is full. This combining scheme is called “collapsing”. Instead of keeping each individual observation, DBM stores the sum of the observations for each batch. DBM adds new observations in the current cell(s) if the number of observations stored is less than the present batch size $m=2^k$ at stage $k$. Whenever the first subvector ${\underset{\_}{A}}_1$ in $\underset{\_}{L}$ is full, DBM starts to collapse data. Initially, $k$ is set to 0 and is increased by 1 after collapsing. Collapsing starts with the subvector ${\underset{\_}{A}}_J$, where $j=\min \left\{2^k,w\right\}$ and $J$ could be regarded as the number of subvectors used at step $k$. Following collapsing in ${\underset{\_}{A}}_J$, the subsequent collapsing occurs in subvector ${\underset{\_}{A}}_{J-1}$ and other subvectors. The subvectors in $\underset{\_}{L}$ are updated as follows:

$$A_j^{\left(k\right)}\left(i\right)=\{\begin{array}{cc}{A}_{j/2}^{\left(k-1\right)}\left(2i\right)+A_{j/2}^{\left(k-1\right)}\left(2i+1\right),i=1,\cdots ,g-1;& j\mathrm{is}\mathrm{even};\\ A_{j/2}^{\left(k-1\right)}\left(2g\right),i=g;& j\mathrm{is}\mathrm{even};\\ A_{\left(j+1\right)/2}^{\left(k-1\right)}\left(2i-1\right)+A_{\left(j+1\right)/2}^{\left(k-1\right)}\left(2i\right),i=1,\cdots ,g-1;& j\mathrm{is}\mathrm{odd}\end{array}$$

(4)

where $A_j^{\left(k\right)}\left(i\right)$, $i=1, 2,\cdots , 2g$, $j=1, 2, \cdots , w$, is the i-th cell of subvector ${\underset{\_}{A}}_j$ at step $k$ and where the numerical values (batch sums) are stored, that is, the observations in certain pairs of adjacent batches after collapsing are combined into one batch sum. As a result, half of the vector becomes available to contain new observations.

Song [14] summarized and defined DBM estimators as a function of $m$ and $s$ at step $k$, as follows:

$${\widehat{V}}_{\mathrm{DBM}}\left(m,s\right)=d^{-1}{{\displaystyle \sum }}_{j=1}^{2^z}{{\displaystyle \sum }}_{i=1}^{b_j}{\left(\frac{A_j^{\left(k\right)}\left(i\right)}{m}-{\overline{\overline{Y}}}_n\right)}^2$$

(5)

where $A_j^{\left(k\right)}\left(i\right)$ is defined in Equation (4). Song [14] derived a proposition to show that DBM is equivalent to the traditional BM for some cases via a recursive expression:

$$A_j^{\left(k\right)}\left(i\right)={{\displaystyle \sum }}_{t=1}^m{Y}_{\left(i-1\right)m+c_j^{\left(k\right)}+t}$$

(6)

where $i=1,2,\cdots ,{\dot{b}}_j$, $j=1,2,\cdots ,2^z$, ${\dot{b}}_j={\gamma }_l-1+m_l/2^k$, $l=1,2,\cdots ,w$, ${\gamma }_l$ is the cells used to store the latest observations, $m_l$ is the number of observations stored in $A_j^{\left(k\right)}\left(i\right)$, $z=\min \left\{k,{\log }_{2}w\right\}$, and

$$c_j^{\left(k\right)}=\{\begin{array}{cc}{c}_{1+\left(j-1\right)/2}^{\left(k-1\right)},& j=1,3,\cdots ,2^z-1,\\ c_{j-1}^{\left(k\right)}+2^{k-1},& j=2,4,\cdots ,2^z.\end{array}$$

(7)

The values of $c_j^{\left(k\right)}$ are illustrated in Figure 1. The column corresponding to each $k$ contains $c_j^{\left(k\right)}$, $j=1, 2, \cdots , 2^z$. For example, if $w=8=2^3$ and $k=3$, then $z=3$ and the corresponding values of $c_j^{\left(3\right)}$, $j=1,2,\cdots ,8$, are 0, 4, 2, 6, 1, 5, 3, 7, which are listed in the fourth column from the left-hand side ($k=3$). Therefore, the corresponding first observations stored in cells $A_j^{\left(3\right)}\left(1\right)$, $j=1,2,\cdots ,8$ (shown in the second column from the right-hand side in Figure 1 in Song [13]) are $y_1, y_5, y_3, y_7, y_2, y_6, y_4$, and $y_8$.

The main drawback of the recursive expression for DBM is the difficulty in calculating the values of $c_j^{\left(k\right)}$. Considering that Equation (7) is a recursive equation, we have to go through all the values of $k$ (i.e., $k=0,1,2,\cdots$) to eventually obtain the values of $c_j^{\left(k\right)}$. In the subsequent section, we propose a closed-form expression for the DBM estimator using a binary tree coding idea.

3. Methods

Trees consisting of nodes and leaves are widely used structures for maintaining or analyzing ordered data [20,21]. Binary trees [22] have a characteristic feature in which each node has exactly two children, namely, the left child and the right child. On the basis of the following proper definitions, we obtained an insight into the data structure of the DBM algorithm:

Definition 1.

Let $T$ be a binary tree. A leaf is a left (lower) leaf if it is a left (lower) child of its parent. A leaf is a right (upper) leaf if it is a right (upper) child of its parent.

We built the correspondence between trees and codes in representing $c_j^{\left(k\right)}$ as follows: Label every left (lower) edge in a tree $T$ with a value of 1 and every right (upper) edge with a value of 0.

Definition 2.

Let $x_j^k=\left(x_j^k\left(1\right), x_j^k\left(2\right),\cdots , x_j^k\left(k\right)\right)$ be the binary codeword. The digit $x_j^k\left(i\right)$ is assigned the value of 1 if it is a left (lower) leaf. The digit $x_j^k\left(i\right)$ is assigned the value of 0 if it is a right (upper) leaf.

In this study, $x_j^k\left(i\right)$ is a binary digit, $1\le i\le k$, and $k$ is called the length of the codeword. The binary codeword was introduced to keep the record/information of whether a term $2^{k-1}$ is added to $c_j^{\left(k\right)}$ at step $k$ or not in Figure 1. A rooted binary code tree corresponds to a binary codeword, as shown in Figure 2. Each pair of braces in the figure corresponds to a leaf on the tree, and the associated codeword is the binary digits within the braces.

Property 1.

Convert each of the binary codewords of $c_j^{\left(k\right)}$ to its equivalent base-10 form. The resulting decimal value parallels the value $\left(j-1\right)$ for the suffix of $c_j^{\left(k\right)}$ in each step $k$. In practice, we can obtain the binary codeword of $c_j^{\left(k\right)}$ directly by converting its corresponding decimal value $\left(j-1\right)$ into base-2 form. This relationship can be expressed as follows:

$$\left[x_j^k\left(1\right),x_j^k\left(2\right),\cdots ,x_j^k\left(k-1\right),x_j^k\left(k\right)\right]·{\left[2^{k-1},2^{k-2},\cdots ,2^1,2^0\right]}^{\mathrm{t}}=j-1$$

(8)

This property can be easily proven by substituting the binary codeword into Equation (8). This process is a simple base-2 to base-10 conversion. We take the binary codewords at step $k=3$ in Figure 2 as an example. The eight codewords are $\left\{000\right\}$, $\left\{001\right\}$, $\left\{010\right\}$, $\left\{011\right\}$, $\left\{100\right\}$, $\left\{101\right\}$, $\left\{110\right\}$, and $\left\{111\right\}$. The resulting decimal values are 0, 1, 2, 3, 4, 5, 6, and 7, respectively.

Property 2.

Let $\underset{\_}{B}$ be the inverse binary-coded matrix defined as $\underset{\_}{B}\equiv {\left[2^0,2^1,\cdots ,2^{k-1}\right]}^t$. Convert each of the binary codewords of $c_j^{\left(k\right)}$ to its equivalent base-10 form via the inverse binary-coded matrix $\underset{\_}{B}$. The resulting decimal value is exactly the value of $c_j^{\left(k\right)}$ in each step $k$. This relationship can be modeled as follows:

$$c_j^{\left(k\right)}=x_j^k·\underset{\_}{\mathrm{B}}=\left[x_j^k\left(1\right),x_j^k\left(2\right),\cdots ,x_j^k\left(k\right)\right]·{\left[2^0,2^1,\cdots ,2^{k-1}\right]}^{\mathrm{t}}$$

(9)

Proof. 

The proof of this property can be carried out using the method of mathematical induction.

Initially, we check the first base case for $k=1$ and obtain the result that $c_j^{\left(k=1\right)}=x_j^{k=1}·\underset{\_}{\mathrm{B}}=\left[x_j^{k=1}\left(1\right)\right]·\left[2^0\right]=2^0·x_j^{k=1}\left(1\right), j=0, 1.$ If $j=0$, $c_{j=0}^{\left(k=1\right)}=2^0·0=0$. If $j=1$, $c_{j=1}^{\left(k=1\right)}=2^0·1=1$. We can show that the result is true for the first base case, i.e., $k=1$.

Further, we discuss the second base case for $k=2$ and have $c_j^{\left(k=2\right)}=x_j^{k=2}·\underset{\_}{\mathrm{B}}=\left[x_j^{k=2}\left(1\right), x_j^{k=2}\left(2\right)\right]·{\left[2^0,2^1\right]}^t=2^0·x_j^{k=2}\left(1\right)+2^1·x_j^{k=2}\left(2\right), j=0, 1, 2, 3.$ If $j=0$, $c_{j=0}^{\left(k=2\right)}=2^0·0+2^1·0=0$. If $j=1$, $c_{j=1}^{\left(k=2\right)}=2^0·0+2^1·1=2$. If $j=2$, $c_{j=2}^{\left(k=2\right)}=2^0·1+2^1·0=1$. If $j=3$, $c_{j=3}^{\left(k=2\right)}=2^0·1+2^1·1=3$. We can also show that the property is true for $k=2$.

In the induction step, we assume that the result is true for the case $k=n$ as well. The inductive hypothesis supposes that $c_j^{\left(k=n\right)}=x_j^{k=n}·\underset{\_}{\mathrm{B}}=\left[x_j^{k=n}\left(1\right), x_j^{k=n}\left(2\right),\cdots ,x_j^{k=n}\left(n\right)\right]·{\left[2^0,2^1,\cdots ,2^{n-1}\right]}^t=2^0·x_j^{k=n}\left(1\right)+2^1·x_j^{k=n}\left(2\right)+\cdots +2^{n-1}·x_j^{k=n}\left(n\right), j=0, 1, \cdots ,2^k-1.$ That is, $c_j^{\left(k=n\right)}={\sum }_{i=1}^n{2}^{i-1}·x_j^{k=n}\left(i\right), j=0, 1, \cdots ,2^k-1$.

Moreover, we have to show that it is also true for $k=n+1$. When $k=n+1$, $c_j^{\left(k=n+1\right)}=x_j^{k=n+1}·\underset{\_}{\mathrm{B}}=\left[x_j^{k=n+1}\left(1\right), x_j^{k=n+1}\left(2\right),\cdots ,x_j^{k=n+1}\left(n\right), x_j^{k=n+1}\left(n+1\right)\right]·{\left[2^0,2^1,\cdots ,2^{n-1},2^n\right]}^t=2^0·x_j^{k=n+1}\left(1\right)+2^1·x_j^{k=n+1}\left(2\right)+\cdots +2^{n-1}·x_j^{k=n+1}\left(n\right)+2^n·x_j^{k=n+1}\left(n+1\right), j=0, 1, \cdots ,2^k-1.$ We then have the result that $c_j^{\left(k=n+1\right)}={\sum }_{i=1}^n{2}^{i-1}·x_j^{k=n+1}\left(i\right)+2^n·x_j^{k=n+1}\left(n+1\right)=c_j^{\left(k=n\right)}+2^n·x_j^{k=n+1}\left(n+1\right)$, where $j=0, 1, \cdots ,2^k-1$, that is, the value of $c_j^{\left(k=n+1\right)}$ for a given node is equal to the summation of the value of its parent’s $c_j^{\left(k=n\right)}$ and $2^n·x_j^{k=n+1}\left(n+1\right)$. If the given node is a right (upper) child of its parent, then $x_j^{k=n+1}\left(n+1\right)=0$; otherwise, $x_j^{k=n+1}\left(n+1\right)=1$. The formula is therefore true for $k=n+1$.  □

As both the base cases and the inductive step have been performed, by mathematical induction, the property holds for all the natural numbers $n$.

The explanation and demonstration of this property are further given below. The binary codeword $x_j^k$ is defined as a tracking code and keeps the record of whether a term $2^{k-1}$ is added to $c_j^{\left(k\right)}$ at step $k$ or not in the original recursive relationship. The inverse binary-coded matrix $\underset{\_}{B}$ corresponds to the value added to $c_j^{\left(k\right)}$ at step $k$ if it is necessary (i.e., $x_j^k\left(i\right)=1$). Consequently, the product of $x_j^k·\underset{\_}{B}$ is the value of $c_j^{\left(k\right)}$. The illustration of this property can be derived with the use of an example with $k=3$ in Figure 2. The corresponding eight codewords are $\left\{000\right\}$, $\left\{001\right\}$, $\left\{010\right\}$, $\left\{011\right\}$, $\left\{100\right\}$, $\left\{101\right\}$, $\left\{110\right\}$, and $\left\{111\right\}$. The relationship can be proven by substituting the binary codeword into Equation (9). The resulting decimal values with inverse binary-coded matrix $\underset{\_}{B}$ are 0, 4, 2, 6, 1, 5, 3, and 7. We take the last codeword $\left\{111\right\}$ as an example:

$$c_7^{\left(3\right)}=x_7^3·\underset{\_}{B}=\left[x_7^3\left(1\right),x_7^3\left(2\right),x_7^3\left(3\right)\right]·{\left[2^0,2^1,2^2\right]}^{\mathrm{t}}=\left[1,1,1\right]·{\left[1,2,4\right]}^{\mathrm{t}}=7$$

(10)

The relationship between the binary codeword and the value of $c_j^{\left(k\right)}$ is clearly demonstrated. The verification of this property could also be checked and confirmed via the recursive equation of $c_j^{\left(k\right)}$ in Figure 1.

Theorem 1.

The closed-form expression for the DBM estimator with the use of the binary tree code at step $k$ can be represented as follows:

$${\widehat{V}}_{\mathrm{DBM}}\left(m,s\right)=d^{-1}{{\displaystyle \sum }}_{j=1}^{2^z}{{\displaystyle \sum }}_{i=1}^{b_j}{\left(\frac{A_j^{\left(k\right)}\left(i\right)}{m}-{\stackrel{=}{Y}}_n\right)}^2$$

(11)

where $A_j^{\left(k\right)}\left(i\right)={\sum }_{t=1}^m{Y}_{\left(i-1\right)m+c_j^{\left(k\right)}+t}$, $c_j^{\left(k\right)}=x_j^k·\underset{\_}{B}$, $i=1, 2, \cdots , b_j$, $j=1, 2, \cdots , 2^z$, and $z=min\left\{k,{\log }_{2}w\right\}$.

Proof. 

The proof of this theorem is straightforward. On the basis of Property 2, we can reformulate the mathematical form of the DBM estimator using the proposed expression of $c_j^{\left(k\right)}$ instead of the original recursive relationships. The closed-form expression for the DBM estimator is then obtained accordingly.  □

4. Results

In this section, we describe the computation effort analysis for the recursive expression of Song [14] and the closed-form expression proposed in this study. Because the data structure stored in the DBM depends on the total number of times that collapsing has occurred, we performed the computation effort analysis under the condition that the sample size $n$ and the prespecified storage space $g$ are given.

Proposition 1.

Given that the sample size and the storage space are $n$ and $g$, respectively, the computational complexity in obtaining $c_j^{\left(k\right)}$ for the recursive expression of the DBM estimator is $O\left({log}_{2}n/\left(g-1\right)\right)$.

The computational effort in obtaining $c_j^{\left(k\right)}$ for the recursive expression is proportional to the total number of times that collapsing has occurred because the DBM algorithm has to update the values of $c_j^{\left(k\right)}$ accordingly when collapsing occurs in the procedure. In other words, the final values of $c_j^{\left(k\right)}$ must be calculated based on the recursive equation from first step $k=0$ to last step $k$. If the simulation run length is n and the memory parameter is g, then the total number of times that collapsing has occurred is $k={\log }_{2}n/\left(g-1\right).$ Therefore, the computational effort in the recursive expression is $O\left({\log }_{2}n/\left(g-1\right)\right)$.

Proposition 2.

Given that the sample size and the storage space are $n$ and $g$, respectively, the computational complexity in obtaining $c_j^{\left(k\right)}$ for the closed-form expression of the DBM estimator is O(1).

We have to examine the computational effort needed in Equation (9) to determine the complexity in computing $c_j^{\left(k\right)}$ for the closed-form expression. If the simulation run length is $n$ and the memory parameter is $g$, then we can determine the binary codewords based on the final value of the parameter $k$, where $k={\log }_{2}n/\left(g-1\right)$. The values of $c_j^{\left(k\right)}$ are consequently obtained by substituting the binary codewords into Equation (9) directly, whereas there is only a single matrix multiplication operation with $k$ elements for each matrix. More precisely, there are $k$ multiplication operations and $k-1$ addition operations in the matrix multiplication, i.e., in total, $2k-1$ operations are needed for Equation (9). However, once the simulation run length $n$ and the memory parameter $g$ are given and known, the parameter $k$ is then determined and it is a fixed constant. Therefore, this result leads to the conclusion that the computational complexity is O(1).

On the basis of the results in Propositions 1 and 2, we can conclude that the computation effort in the closed-form expression for obtaining the indexes $c_j^{\left(k\right)}$, i.e., the batch mean shifts $s$, is less than the effort needed in the recursive expression.

5. Conclusions

In this study, we reinvestigated the DBM algorithm and modified it with a binary tree hierarchy. With a well-defined binary codeword, this study proposes a closed-form expression for the DBM estimator instead of using crude recursive relationships. This closed-form expression yields a mathematical expression that is clearly defined by our algebraic binary relation. Based on the computation effort analysis, we can conclude that the computation effort in the closed-form expression for obtaining the indexes $c_j^{\left(k\right)}$ is less than the effort needed in the recursive expression.