time-to-botec

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

README.md (4483B)

      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 # dmaxabssorted
     22 
     23 > Calculate the maximum absolute value of a sorted double-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 dmaxabssorted = require( '@stdlib/stats/base/dmaxabssorted' );
     37 ```
     38 
     39 #### dmaxabssorted( N, x, stride )
     40 
     41 Computes the maximum absolute value of a sorted double-precision floating-point strided array `x`.
     42 
     43 ```javascript
     44 var Float64Array = require( '@stdlib/array/float64' );
     45 
     46 var x = new Float64Array( [ -1.0, -2.0, -3.0 ] );
     47 var v = dmaxabssorted( x.length, x, 1 );
     48 // returns 3.0
     49 
     50 x = new Float64Array( [ -3.0, -2.0, -1.0 ] );
     51 v = dmaxabssorted( x.length, x, 1 );
     52 // returns 3.0
     53 ```
     54 
     55 The function has the following parameters:
     56 
     57 -   **N**: number of indexed elements.
     58 -   **x**: sorted input [`Float64Array`][@stdlib/array/float64].
     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 maximum absolute value of every other element in `x`,
     62 
     63 ```javascript
     64 var Float64Array = require( '@stdlib/array/float64' );
     65 var floor = require( '@stdlib/math/base/special/floor' );
     66 
     67 var x = new Float64Array( [ 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 = dmaxabssorted( N, x, 2 );
     71 // returns 4.0
     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 Float64Array = require( '@stdlib/array/float64' );
     80 var floor = require( '@stdlib/math/base/special/floor' );
     81 
     82 var x0 = new Float64Array( [ 2.0, 1.0, 2.0, 2.0, -2.0, 2.0, 3.0, 4.0 ] );
     83 var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
     84 
     85 var N = floor( x0.length / 2 );
     86 
     87 var v = dmaxabssorted( N, x1, 2 );
     88 // returns 4.0
     89 ```
     90 
     91 #### dmaxabssorted.ndarray( N, x, stride, offset )
     92 
     93 Computes the maximum absolute value of a sorted double-precision floating-point strided array using alternative indexing semantics.
     94 
     95 ```javascript
     96 var Float64Array = require( '@stdlib/array/float64' );
     97 
     98 var x = new Float64Array( [ -1.0, -2.0, -3.0 ] );
     99 var v = dmaxabssorted.ndarray( x.length, x, 1, 0 );
    100 // returns 3.0
    101 ```
    102 
    103 The function has the following additional parameters:
    104 
    105 -   **offset**: starting index for `x`.
    106 
    107 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 absolute value for every other value in `x` starting from the second value
    108 
    109 ```javascript
    110 var Float64Array = require( '@stdlib/array/float64' );
    111 var floor = require( '@stdlib/math/base/special/floor' );
    112 
    113 var x = new Float64Array( [ 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 = dmaxabssorted.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 dmaxabssorted = require( '@stdlib/stats/base/dmaxabssorted' );
    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 = dmaxabssorted( x.length, x, 1 );
    155 console.log( v );
    156 ```
    157 
    158 </section>
    159 
    160 <!-- /.examples -->
    161 
    162 <section class="links">
    163 
    164 [@stdlib/array/float64]: https://www.npmjs.com/package/@stdlib/array-float64
    165 
    166 [mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
    167 
    168 </section>
    169 
    170 <!-- /.links -->