time-to-botec

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

repl.txt (2476B)

      1 
      2 {{alias}}( N, alpha, x, stride )
      3     Adds a constant to each strided array element and computes the sum using a
      4     second-order iterative Kahan–Babuška algorithm.
      5 
      6     The `N` and `stride` parameters determine which elements in `x` are accessed
      7     at runtime.
      8 
      9     Indexing is relative to the first index. To introduce an offset, use a typed
     10     array view.
     11 
     12     If `N <= 0`, the function returns `0.0`.
     13 
     14     Parameters
     15     ----------
     16     N: integer
     17         Number of indexed elements.
     18 
     19     alpha: number
     20         Constant.
     21 
     22     x: Array<number>|TypedArray
     23         Input array.
     24 
     25     stride: integer
     26         Index increment.
     27 
     28     Returns
     29     -------
     30     out: number
     31         Sum.
     32 
     33     Examples
     34     --------
     35     // Standard Usage:
     36     > var x = [ 1.0, -2.0, 2.0 ];
     37     > {{alias}}( x.length, 5.0, x, 1 )
     38     16.0
     39 
     40     // Using `N` and `stride` parameters:
     41     > x = [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ];
     42     > var N = {{alias:@stdlib/math/base/special/floor}}( x.length / 2 );
     43     > var stride = 2;
     44     > {{alias}}( N, 5.0, x, stride )
     45     16.0
     46 
     47     // Using view offsets:
     48     > var x0 = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );
     49     > var x1 = new {{alias:@stdlib/array/float64}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 );
     50     > N = {{alias:@stdlib/math/base/special/floor}}( x0.length / 2 );
     51     > stride = 2;
     52     > {{alias}}( N, 5.0, x1, stride )
     53     14.0
     54 
     55 {{alias}}.ndarray( N, alpha, x, stride, offset )
     56     Adds a constant to each strided array element and computes the sum using a
     57     second-order iterative Kahan–Babuška algorithm and alternative indexing
     58     semantics.
     59 
     60     While typed array views mandate a view offset based on the underlying
     61     buffer, the `offset` parameter supports indexing semantics based on a
     62     starting index.
     63 
     64     Parameters
     65     ----------
     66     N: integer
     67         Number of indexed elements.
     68 
     69     alpha: number
     70         Constant.
     71 
     72     x: Array<number>|TypedArray
     73         Input array.
     74 
     75     stride: integer
     76         Index increment.
     77 
     78     offset: integer
     79         Starting index.
     80 
     81     Returns
     82     -------
     83     out: number
     84         Sum.
     85 
     86     Examples
     87     --------
     88     // Standard Usage:
     89     > var x = [ 1.0, -2.0, 2.0 ];
     90     > {{alias}}.ndarray( x.length, 5.0, x, 1, 0 )
     91     16.0
     92 
     93     // Using offset parameter:
     94     > var x = [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ];
     95     > var N = {{alias:@stdlib/math/base/special/floor}}( x.length / 2 );
     96     > {{alias}}.ndarray( N, 5.0, x, 2, 1 )
     97     14.0
     98 
     99     See Also
    100     --------
    101