time-to-botec

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

README.md (4027B)

      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 # maxsorted
     22 
     23 > Calculate the maximum value of a sorted 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 maxsorted = require( '@stdlib/stats/base/maxsorted' );
     37 ```
     38 
     39 #### maxsorted( N, x, stride )
     40 
     41 Computes the maximum value of a sorted strided array `x`.
     42 
     43 ```javascript
     44 var x = [ 1.0, 2.0, 3.0 ];
     45 var N = x.length;
     46 
     47 var v = maxsorted( N, x, 1 );
     48 // returns 3.0
     49 
     50 x = [ 3.0, 2.0, 1.0 ];
     51 N = x.length;
     52 
     53 v = maxsorted( N, x, 1 );
     54 // returns 3.0
     55 ```
     56 
     57 The function has the following parameters:
     58 
     59 -   **N**: number of indexed elements.
     60 -   **x**: sorted input [`Array`][mdn-array] or [`typed array`][mdn-typed-array].
     61 -   **stride**: index increment for `x`.
     62 
     63 The `N` and `stride` parameters determine which elements in `x` are accessed at runtime. For example, to compute the maximum value of every other element in `x`,
     64 
     65 ```javascript
     66 var floor = require( '@stdlib/math/base/special/floor' );
     67 
     68 var x = [ 1.0, 2.0, 2.0, -7.0, 3.0, 3.0, 4.0, 2.0 ];
     69 var N = floor( x.length / 2 );
     70 
     71 var v = maxsorted( N, x, 2 );
     72 // returns 4.0
     73 ```
     74 
     75 Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
     76 
     77 <!-- eslint-disable stdlib/capitalized-comments -->
     78 
     79 ```javascript
     80 var Float64Array = require( '@stdlib/array/float64' );
     81 var floor = require( '@stdlib/math/base/special/floor' );
     82 
     83 var x0 = new Float64Array( [ 2.0, 1.0, 2.0, 2.0, -2.0, 2.0, 3.0, 4.0 ] );
     84 var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
     85 
     86 var N = floor( x0.length / 2 );
     87 
     88 var v = maxsorted( N, x1, 2 );
     89 // returns 4.0
     90 ```
     91 
     92 #### maxsorted.ndarray( N, x, stride, offset )
     93 
     94 Computes the maximum value of a sorted strided array using alternative indexing semantics.
     95 
     96 ```javascript
     97 var x = [ 1.0, 2.0, 3.0 ];
     98 var N = x.length;
     99 
    100 var v = maxsorted.ndarray( N, x, 1, 0 );
    101 // returns 3.0
    102 ```
    103 
    104 The function has the following additional parameters:
    105 
    106 -   **offset**: starting index for `x`.
    107 
    108 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 maximum value for every other value in `x` starting from the second value
    109 
    110 ```javascript
    111 var floor = require( '@stdlib/math/base/special/floor' );
    112 
    113 var x = [ 2.0, 1.0, 2.0, 2.0, -2.0, 2.0, 3.0, 4.0 ];
    114 var N = floor( x.length / 2 );
    115 
    116 var v = maxsorted.ndarray( N, x, 2, 1 );
    117 // returns 4.0
    118 ```
    119 
    120 </section>
    121 
    122 <!-- /.usage -->
    123 
    124 <section class="notes">
    125 
    126 ## Notes
    127 
    128 -   If `N <= 0`, both functions return `NaN`.
    129 -   The input strided array must be sorted in either **strictly** ascending or descending order.
    130 
    131 </section>
    132 
    133 <!-- /.notes -->
    134 
    135 <section class="examples">
    136 
    137 ## Examples
    138 
    139 <!-- eslint no-undef: "error" -->
    140 
    141 ```javascript
    142 var Float64Array = require( '@stdlib/array/float64' );
    143 var maxsorted = require( '@stdlib/stats/base/maxsorted' );
    144 
    145 var x;
    146 var i;
    147 
    148 x = new Float64Array( 10 );
    149 for ( i = 0; i < x.length; i++ ) {
    150     x[ i ] = i - 5.0;
    151 }
    152 console.log( x );
    153 
    154 var v = maxsorted( x.length, x, 1 );
    155 console.log( v );
    156 ```
    157 
    158 </section>
    159 
    160 <!-- /.examples -->
    161 
    162 <section class="links">
    163 
    164 [mdn-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array
    165 
    166 [mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
    167 
    168 </section>
    169 
    170 <!-- /.links -->