time-to-botec

Benchmark sampling in different programming languages
Log | Files | Refs | README

repl.txt (3579B)

      1 
      2 {{alias}}( N, x, strideX, mask, strideMask )
      3     Computes the range of a double-precision floating-point strided array
      4     according to a mask, ignoring `NaN` values.
      5 
      6     The `N` and `stride` parameters determine which elements are accessed at
      7     runtime.
      8 
      9     Indexing is relative to the first index. To introduce offsets, use a typed
     10     array views.
     11 
     12     If a `mask` array element is `0`, the corresponding element in `x` is
     13     considered valid and included in computation.
     14 
     15     If a `mask` array element is `1`, the corresponding element in `x` is
     16     considered invalid/missing and excluded from computation.
     17 
     18     If `N <= 0`, the function returns `NaN`.
     19 
     20     Parameters
     21     ----------
     22     N: integer
     23         Number of indexed elements.
     24 
     25     x: Float64Array
     26         Input array.
     27 
     28     strideX: integer
     29         Index increment for `x`.
     30 
     31     mask: Uint8Array
     32         Mask array.
     33 
     34     strideMask: integer
     35         Index increment for `mask`.
     36 
     37     Returns
     38     -------
     39     out: number
     40         Range.
     41 
     42     Examples
     43     --------
     44     // Standard Usage:
     45     > var x = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, 4.0, 2.0, NaN ] );
     46     > var mask = new {{alias:@stdlib/array/uint8}}( [ 0, 0, 1, 0, 0 ] );
     47     > {{alias}}( x.length, x, 1, mask, 1 )
     48     4.0
     49 
     50     // Using `N` and `stride` parameters:
     51     > x = new {{alias:@stdlib/array/float64}}( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, 4.0 ] );
     52     > mask = new {{alias:@stdlib/array/uint8}}( [ 0, 0, 0, 0, 0, 0, 1 ] );
     53     > var N = {{alias:@stdlib/math/base/special/floor}}( x.length / 2 );
     54     > {{alias}}( N, x, 2, mask, 2 )
     55     4.0
     56 
     57     // Using view offsets:
     58     > var x0 = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, 4.0 ] );
     59     > var x1 = new {{alias:@stdlib/array/float64}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 );
     60     > var mask0 = new {{alias:@stdlib/array/uint8}}( [ 0, 0, 0, 0, 0, 0, 1 ] );
     61     > var mask1 = new {{alias:@stdlib/array/uint8}}( mask0.buffer, mask0.BYTES_PER_ELEMENT*1 );
     62     > N = {{alias:@stdlib/math/base/special/floor}}( x0.length / 2 );
     63     > {{alias}}( N, x1, 2, mask1, 2 )
     64     4.0
     65 
     66 {{alias}}.ndarray( N, x, strideX, offsetX, mask, strideMask, offsetMask )
     67     Computes the range of a double-precision floating-point strided array
     68     according to a mask, ignoring `NaN` values and using alternative indexing
     69     semantics.
     70 
     71     While typed array views mandate a view offset based on the underlying
     72     buffer, the `offset` parameter supports indexing semantics based on a
     73     starting index.
     74 
     75     Parameters
     76     ----------
     77     N: integer
     78         Number of indexed elements.
     79 
     80     x: Float64Array
     81         Input array.
     82 
     83     strideX: integer
     84         Index increment for `x`.
     85 
     86     offsetX: integer
     87         Starting index for `x`.
     88 
     89     mask: Uint8Array
     90         Mask array.
     91 
     92     strideMask: integer
     93         Index increment for `mask`.
     94 
     95     offsetMask: integer
     96         Starting index for `mask`.
     97 
     98     Returns
     99     -------
    100     out: number
    101         Range.
    102 
    103     Examples
    104     --------
    105     // Standard Usage:
    106     > var x = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, 2.0, 4.0, NaN ] );
    107     > var mask = new {{alias:@stdlib/array/uint8}}( [ 0, 0, 0, 1, 0 ] );
    108     > {{alias}}.ndarray( x.length, x, 1, 0, mask, 1, 0 )
    109     4.0
    110 
    111     // Using offset parameter:
    112     > x = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, 4.0 ] );
    113     > mask = new {{alias:@stdlib/array/uint8}}( [ 0, 0, 0, 0, 0, 0, 1 ] );
    114     > var N = {{alias:@stdlib/math/base/special/floor}}( x.length / 2 );
    115     > {{alias}}.ndarray( N, x, 2, 1, mask, 2, 1 )
    116     4.0
    117 
    118     See Also
    119     --------
    120