Skip to content

README.md

Latest commit

 

History

History
292 lines (192 loc) · 7.64 KB

README.md

File metadata and controls

292 lines (192 loc) · 7.64 KB

dmskmax

Calculate the maximum value of a one-dimensional double-precision floating-point ndarray according to a mask.

Usage

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

dmskmax( arrays )

Computes the maximum value of a one-dimensional double-precision floating-point ndarray according to a mask.

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

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

var maskbuf = new Uint8Array( [ 0, 0, 1, 0 ] );
var mask = new ndarray( 'uint8', maskbuf, [ 4 ], [ 1 ], 0, 'row-major' );

var v = dmskmax( [ x, mask ] );
// returns 2.0

The function has the following parameters:

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

Notes

  • If a mask array element is 0, the corresponding element in the input ndarray is considered valid and included in computation. If a mask array element is 1, the corresponding element in the input ndarray is considered invalid/missing and excluded from computation.
  • If provided an empty ndarray or a mask with all elements set to 1, the function returns NaN.

Examples

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

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

var maskbuf = bernoulli( xbuf.length, 0.2, {
    'dtype': 'uint8'
});
var mask = new ndarray( 'uint8', maskbuf, [ maskbuf.length ], [ 1 ], 0, 'row-major' );
console.log( ndarray2array( mask ) );

var v = dmskmax( [ x, mask ] );
console.log( v );

C APIs

Usage

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

stdlib_stats_dmskmax( arrays )

Computes the maximum value of a one-dimensional double-precision floating-point ndarray according to a mask.

#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 );

// Create a mask ndarray:
const uint8_t mask_data[] = { 0, 0, 1, 0 };
int64_t mask_strides[] = { STDLIB_NDARRAY_UINT8_BYTES_PER_ELEMENT };

struct ndarray *mask = stdlib_ndarray_allocate( STDLIB_NDARRAY_UINT8, (uint8_t *)mask_data, 1, shape, mask_strides, 0, STDLIB_NDARRAY_ROW_MAJOR, STDLIB_NDARRAY_INDEX_ERROR, 1, submodes );

// Compute the maximum value:
const struct ndarray *arrays[] = { x, mask };
double v = stdlib_stats_dmskmax( arrays );
// returns 2.0

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

The function accepts the following arguments:

  • arrays: [in] struct ndarray** list containing a one-dimensional input ndarray and a one-dimensional mask ndarray.
double stdlib_stats_dmskmax( const struct ndarray *arrays[] );

Examples

#include "stdlib/stats/base/ndarray/dmskmax.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 };

   // Create a mask buffer:
   const uint8_t mask_data[] = { 0, 0, 0, 0, 0, 0, 1, 1 };

   // 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 mask strides:
   int64_t mask_strides[] = { 2*STDLIB_NDARRAY_UINT8_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 );
   }

   // Create a mask ndarray:
   struct ndarray *mask = stdlib_ndarray_allocate( STDLIB_NDARRAY_UINT8, (uint8_t *)mask_data, ndims, shape, mask_strides, offset, order, imode, nsubmodes, submodes );
   if ( mask == NULL ) {
      fprintf( stderr, "Error allocating memory.\n" );
      exit( 1 );
   }

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

   // Compute the maximum value:
   double v = stdlib_stats_dmskmax( arrays );

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

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