time-to-botec

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

repl.txt (2676B)

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