README.md

dmeanors

Compute the arithmetic mean of a one-dimensional double-precision floating-point ndarray using ordinary recursive summation.

The arithmetic mean is defined as

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

Usage

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

dmeanors( arrays )

Computes the arithmetic mean of a one-dimensional double-precision floating-point ndarray using ordinary recursive 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 = dmeanors( [ 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`.
  

• Ordinary recursive summation (i.e., a "simple" sum) is performant, but can incur significant numerical error. If performance is paramount and error tolerated, using ordinary recursive summation to compute an arithmetic mean is acceptable; in all other cases, exercise due caution.
  

Examples

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

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 = dmeanors( [ x ] );
console.log( v );

---

C APIs

Usage

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

stdlib_stats_dmeanors( arrays )

Computes the arithmetic mean of a one-dimensional double-precision floating-point ndarray using ordinary recursive 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 value:
const struct ndarray *arrays[] = { x };
double v = stdlib_stats_dmeanors( 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_dmeanors( const struct ndarray *arrays[] );

Examples

#include "stdlib/stats/base/ndarray/dmeanors.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 value:
         double v = stdlib_stats_dmeanors( arrays );

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

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