time-to-botec

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

README.md (4436B)

      1 <!--
      2 
      3 @license Apache-2.0
      4 
      5 Copyright (c) 2020 The Stdlib Authors.
      6 
      7 Licensed under the Apache License, Version 2.0 (the "License");
      8 you may not use this file except in compliance with the License.
      9 You may obtain a copy of the License at
     10 
     11    http://www.apache.org/licenses/LICENSE-2.0
     12 
     13 Unless required by applicable law or agreed to in writing, software
     14 distributed under the License is distributed on an "AS IS" BASIS,
     15 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     16 See the License for the specific language governing permissions and
     17 limitations under the License.
     18 
     19 -->
     20 
     21 # smediansorted
     22 
     23 > Calculate the median value of a sorted single-precision floating-point strided array.
     24 
     25 <section class="intro">
     26 
     27 </section>
     28 
     29 <!-- /.intro -->
     30 
     31 <section class="usage">
     32 
     33 ## Usage
     34 
     35 ```javascript
     36 var smediansorted = require( '@stdlib/stats/base/smediansorted' );
     37 ```
     38 
     39 #### smediansorted( N, x, stride )
     40 
     41 Computes the median value of a sorted single-precision floating-point strided array `x`.
     42 
     43 ```javascript
     44 var Float32Array = require( '@stdlib/array/float32' );
     45 
     46 var x = new Float32Array( [ 1.0, 2.0, 3.0 ] );
     47 var v = smediansorted( x.length, x, 1 );
     48 // returns 2.0
     49 
     50 x = new Float32Array( [ 3.0, 2.0, 1.0 ] );
     51 v = smediansorted( x.length, x, 1 );
     52 // returns 2.0
     53 ```
     54 
     55 The function has the following parameters:
     56 
     57 -   **N**: number of indexed elements.
     58 -   **x**: sorted input [`Float32Array`][@stdlib/array/float32].
     59 -   **stride**: index increment for `x`.
     60 
     61 The `N` and `stride` parameters determine which elements in `x` are accessed at runtime. For example, to compute the median value of every other element in `x`,
     62 
     63 ```javascript
     64 var Float32Array = require( '@stdlib/array/float32' );
     65 var floor = require( '@stdlib/math/base/special/floor' );
     66 
     67 var x = new Float32Array( [ 1.0, 2.0, 2.0, -7.0, 3.0, 3.0, 4.0, 2.0 ] );
     68 var N = floor( x.length / 2 );
     69 
     70 var v = smediansorted( N, x, 2 );
     71 // returns 2.5
     72 ```
     73 
     74 Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
     75 
     76 <!-- eslint-disable stdlib/capitalized-comments -->
     77 
     78 ```javascript
     79 var Float32Array = require( '@stdlib/array/float32' );
     80 var floor = require( '@stdlib/math/base/special/floor' );
     81 
     82 var x0 = new Float32Array( [ 2.0, 1.0, 2.0, 2.0, -2.0, 2.0, 3.0, 4.0 ] );
     83 var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
     84 
     85 var N = floor( x0.length / 2 );
     86 
     87 var v = smediansorted( N, x1, 2 );
     88 // returns 2.0
     89 ```
     90 
     91 #### smediansorted.ndarray( N, x, stride, offset )
     92 
     93 Computes the median value of a sorted single-precision floating-point strided array using alternative indexing semantics.
     94 
     95 ```javascript
     96 var Float32Array = require( '@stdlib/array/float32' );
     97 
     98 var x = new Float32Array( [ 1.0, 2.0, 3.0 ] );
     99 var N = x.length;
    100 
    101 var v = smediansorted.ndarray( N, x, 1, 0 );
    102 // returns 2.0
    103 ```
    104 
    105 The function has the following additional parameters:
    106 
    107 -   **offset**: starting index for `x`.
    108 
    109 While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying `buffer`, the `offset` parameter supports indexing semantics based on a starting index. For example, to calculate the median value for every other value in `x` starting from the second value
    110 
    111 ```javascript
    112 var Float32Array = require( '@stdlib/array/float32' );
    113 var floor = require( '@stdlib/math/base/special/floor' );
    114 
    115 var x = new Float32Array( [ 2.0, 1.0, 2.0, 2.0, -2.0, 2.0, 3.0, 4.0 ] );
    116 var N = floor( x.length / 2 );
    117 
    118 var v = smediansorted.ndarray( N, x, 2, 1 );
    119 // returns 2.0
    120 ```
    121 
    122 </section>
    123 
    124 <!-- /.usage -->
    125 
    126 <section class="notes">
    127 
    128 ## Notes
    129 
    130 -   If `N <= 0`, both functions return `NaN`.
    131 -   The input strided array must be sorted in either **strictly** ascending or descending order.
    132 
    133 </section>
    134 
    135 <!-- /.notes -->
    136 
    137 <section class="examples">
    138 
    139 ## Examples
    140 
    141 <!-- eslint no-undef: "error" -->
    142 
    143 ```javascript
    144 var Float32Array = require( '@stdlib/array/float32' );
    145 var smediansorted = require( '@stdlib/stats/base/smediansorted' );
    146 
    147 var x;
    148 var i;
    149 
    150 x = new Float32Array( 10 );
    151 for ( i = 0; i < x.length; i++ ) {
    152     x[ i ] = i - 5.0;
    153 }
    154 console.log( x );
    155 
    156 var v = smediansorted( x.length, x, 1 );
    157 console.log( v );
    158 ```
    159 
    160 </section>
    161 
    162 <!-- /.examples -->
    163 
    164 <section class="links">
    165 
    166 [@stdlib/array/float32]: https://www.npmjs.com/package/@stdlib/array-float32
    167 
    168 [mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
    169 
    170 </section>
    171 
    172 <!-- /.links -->