About stdlib...

We believe in a future in which the web is a preferred environment for numerical computation. To help realize this future, we've built stdlib. stdlib is a standard library, with an emphasis on numerical and scientific computation, written in JavaScript (and C) for execution in browsers and in Node.js.

The library is fully decomposable, being architected in such a way that you can swap out and mix and match APIs and functionality to cater to your exact preferences and use cases.

When you use stdlib, you can be absolutely certain that you are using the most thorough, rigorous, well-written, studied, documented, tested, measured, and high-quality code out there.

To join us in bringing numerical computing to the web, get started by checking us out on GitHub, and please consider financially supporting stdlib. We greatly appreciate your continued support!

dmeanlipw

Compute the arithmetic mean of a one-dimensional double-precision floating-point ndarray using a one-pass trial mean algorithm with pairwise summation.

The arithmetic mean is defined as

$$\mu = \frac{1}{n} \sum_{i=0}^{n-1} x_i$$

Installation

npm install @stdlib/stats-base-ndarray-dmeanlipw

Alternatively,

• To load the package in a website via a script tag without installation and bundlers, use the ES Module available on the esm branch (see README).
• If you are using Deno, visit the deno branch (see README for usage intructions).
• For use in Observable, or in browser/node environments, use the Universal Module Definition (UMD) build available on the umd branch (see README).

The branches.md file summarizes the available branches and displays a diagram illustrating their relationships.

To view installation and usage instructions specific to each branch build, be sure to explicitly navigate to the respective README files on each branch, as linked to above.

Usage

var dmeanlipw = require( '@stdlib/stats-base-ndarray-dmeanlipw' );

dmeanlipw( arrays )

Computes the arithmetic mean of a one-dimensional double-precision floating-point ndarray using a one-pass trial mean algorithm with pairwise summation.

var Float64Array = require( '@stdlib/array-float64' );
var ndarray = require( '@stdlib/ndarray-base-ctor' );

var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] );
var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );

var v = dmeanlipw( [ x ] );
// returns 2.5

The function has the following parameters:

• arrays: array-like object containing a one-dimensional input ndarray.

Notes

• If provided an empty one-dimensional ndarray, the function returns NaN.
• The underlying algorithm is a specialized case of Welford's algorithm. Similar to the method of assumed mean, the first ndarray element is used as a trial mean. The trial mean is subtracted from subsequent data values, and the average deviations used to adjust the initial guess. Accordingly, the algorithm's accuracy is best when data is unordered (i.e., the data is not sorted in either ascending or descending order such that the first value is an "extreme" value).

Examples

var discreteUniform = require( '@stdlib/random-array-discrete-uniform' );
var ndarray = require( '@stdlib/ndarray-base-ctor' );
var ndarray2array = require( '@stdlib/ndarray-to-array' );
var dmeanlipw = require( '@stdlib/stats-base-ndarray-dmeanlipw' );

var xbuf = discreteUniform( 10, -50, 50, {
    'dtype': 'float64'
});
var x = new ndarray( 'float64', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
console.log( ndarray2array( x ) );

var v = dmeanlipw( [ x ] );
console.log( v );

---

C APIs

Usage

#include "stdlib/stats/base/ndarray/dmeanlipw.h"

stdlib_stats_dmeanlipw( arrays )

Computes the arithmetic mean of a one-dimensional double-precision floating-point ndarray using a one-pass trial mean algorithm with pairwise summation.

#include "stdlib/ndarray/ctor.h"
#include "stdlib/ndarray/dtypes.h"
#include "stdlib/ndarray/index_modes.h"
#include "stdlib/ndarray/orders.h"
#include "stdlib/ndarray/base/bytes_per_element.h"
#include <stdint.h>

// Create an ndarray:
const double data[] = { 1.0, 2.0, 3.0, 4.0 };
int64_t shape[] = { 4 };
int64_t strides[] = { STDLIB_NDARRAY_FLOAT64_BYTES_PER_ELEMENT };
int8_t submodes[] = { STDLIB_NDARRAY_INDEX_ERROR };

struct ndarray *x = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)data, 1, shape, strides, 0, STDLIB_NDARRAY_ROW_MAJOR, STDLIB_NDARRAY_INDEX_ERROR, 1, submodes );

// Compute the arithmetic mean:
const struct ndarray *arrays[] = { x };
double v = stdlib_stats_dmeanlipw( arrays );
// returns 2.5

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• arrays: [in] struct ndarray** list containing a one-dimensional input ndarray.

double stdlib_stats_dmeanlipw( const struct ndarray *arrays[] );

Examples

#include "stdlib/stats/base/ndarray/dmeanlipw.h"
#include "stdlib/ndarray/ctor.h"
#include "stdlib/ndarray/dtypes.h"
#include "stdlib/ndarray/index_modes.h"
#include "stdlib/ndarray/orders.h"
#include "stdlib/ndarray/base/bytes_per_element.h"
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>

int main( void ) {
   // Create a data buffer:
   const double data[] = { 1.0, -2.0, 3.0, -4.0, 5.0, -6.0, 7.0, -8.0 };

   // Specify the number of array dimensions:
   const int64_t ndims = 1;

   // Specify the array shape:
   int64_t shape[] = { 4 };

   // Specify the array strides:
   int64_t strides[] = { 2*STDLIB_NDARRAY_FLOAT64_BYTES_PER_ELEMENT };

   // Specify the byte offset:
   const int64_t offset = 0;

   // Specify the array order:
   const enum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;

   // Specify the index mode:
   const enum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;

   // Specify the subscript index modes:
   int8_t submodes[] = { STDLIB_NDARRAY_INDEX_ERROR };
   const int64_t nsubmodes = 1;

   // Create an ndarray:
   struct ndarray *x = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)data, ndims, shape, strides, offset, order, imode, nsubmodes, submodes );
   if ( x == NULL ) {
      fprintf( stderr, "Error allocating memory.\n" );
      exit( 1 );
   }

   // Define a list of ndarrays:
   const struct ndarray *arrays[] = { x };

   // Compute the arithmetic mean:
   double v = stdlib_stats_dmeanlipw( arrays );

   // Print the result:
   printf( "mean: %lf\n", v );

   // Free allocated memory:
   stdlib_ndarray_free( x );
}

---

References

• Welford, B. P. 1962. "Note on a Method for Calculating Corrected Sums of Squares and Products." Technometrics 4 (3). Taylor & Francis: 419–20. doi:10.1080/00401706.1962.10490022.
• van Reeken, A. J. 1968. "Letters to the Editor: Dealing with Neely's Algorithms." Communications of the ACM 11 (3): 149–50. doi:10.1145/362929.362961.
• Ling, Robert F. 1974. "Comparison of Several Algorithms for Computing Sample Means and Variances." Journal of the American Statistical Association 69 (348). American Statistical Association, Taylor & Francis, Ltd.: 859–66. doi:10.2307/2286154.
• Higham, Nicholas J. 1993. "The Accuracy of Floating Point Summation." SIAM Journal on Scientific Computing 14 (4): 783–99. doi:10.1137/0914050.

---

Notice

This package is part of stdlib, a standard library for JavaScript and Node.js, with an emphasis on numerical and scientific computing. The library provides a collection of robust, high performance libraries for mathematics, statistics, streams, utilities, and more.

For more information on the project, filing bug reports and feature requests, and guidance on how to develop stdlib, see the main project repository.

Community

---

License

See LICENSE.

Copyright

Copyright © 2016-2026. The Stdlib Authors.