time-to-botec

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

repl.txt (3103B)

      1 
      2 {{alias}}( N, alpha, x, stride )
      3     Multiplies a single-precision floating-point vector `x` by a constant
      4     `alpha`.
      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 typed
     10     array views.
     11 
     12     If `N <= 0` or `stride <= 0`, the function returns `x` unchanged.
     13 
     14     Parameters
     15     ----------
     16     N: integer
     17         Number of indexed elements.
     18 
     19     alpha: number
     20         Constant.
     21 
     22     x: Float32Array
     23         Input array.
     24 
     25     stride: integer
     26         Index increment for `x`.
     27 
     28     Returns
     29     -------
     30     x: Float32Array
     31         Input array `x`.
     32 
     33     Examples
     34     --------
     35     // Standard Usage:
     36     > var x = new {{alias:@stdlib/array/float32}}( [ -2.0, 1.0, 3.0, -5.0, 4.0, -1.0, -3.0 ] );
     37     > var alpha = 5.0;
     38     > {{alias}}( x.length, alpha, x, 1 )
     39     <Float32Array>[ -10.0, 5.0, 15.0, -25.0, 20.0, -5.0, -15.0 ]
     40 
     41     // Using `N` and `stride` parameters:
     42     > x = new {{alias:@stdlib/array/float32}}( [ -2.0, 1.0, 3.0, -5.0, 4.0, -1.0, -3.0 ] );
     43     > var N = {{alias:@stdlib/math/base/special/floor}}( x.length / 2 );
     44     > alpha = 5.0;
     45     > var stride = 2;
     46     > {{alias}}( N, alpha, x, stride )
     47     <Float32Array>[ -10.0, 1.0, 15.0, -5.0, 20.0, -1.0, -3.0 ]
     48 
     49     // Using view offsets:
     50     > var x0 = new {{alias:@stdlib/array/float32}}( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );
     51     > var x1 = new {{alias:@stdlib/array/float32}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 );
     52     > N = {{alias:@stdlib/math/base/special/floor}}( x0.length / 2 );
     53     > alpha = 5.0;
     54     > stride = 2;
     55     > {{alias}}( N, alpha, x1, stride )
     56     <Float32Array>[ -10.0, 3.0, -20.0, 5.0, -30.0 ]
     57     > x0
     58     <Float32Array>[ 1.0, -10.0, 3.0, -20.0, 5.0, -30.0 ]
     59 
     60 {{alias}}.ndarray( N, alpha, x, stride, offset )
     61     Multiplies a single-precision floating-point vector `x` by a constant
     62     `alpha` using alternative indexing semantics.
     63 
     64     While typed array views mandate a view offset based on the underlying
     65     buffer, the `offset` parameter supports indexing semantics based on a
     66     starting index.
     67 
     68     Parameters
     69     ----------
     70     N: integer
     71         Number of indexed elements.
     72 
     73     alpha: number
     74         Constant.
     75 
     76     x: Float32Array
     77         Input array.
     78 
     79     stride: integer
     80         Index increment for `x`.
     81 
     82     offset: integer
     83         Starting index of `x`.
     84 
     85     Returns
     86     -------
     87     x: Float32Array
     88         Input array `x`.
     89 
     90     Examples
     91     --------
     92     // Standard Usage:
     93     > var x = new {{alias:@stdlib/array/float32}}( [ -2.0, 1.0, 3.0, -5.0, 4.0, -1.0, -3.0 ] );
     94     > var alpha = 5.0;
     95     > {{alias}}.ndarray( x.length, alpha, x, 1, 0 )
     96     <Float32Array>[ -10.0, 5.0, 15.0, -25.0, 20.0, -5.0, -15.0 ]
     97 
     98     // Using an index offset:
     99     > x = new {{alias:@stdlib/array/float32}}( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );
    100     > var N = {{alias:@stdlib/math/base/special/floor}}( x.length / 2 );
    101     > alpha = 5.0;
    102     > var stride = 2;
    103     > {{alias}}.ndarray( N, alpha, x, stride, 1 )
    104     <Float32Array>[ 1.0, -10.0, 3.0, -20.0, 5.0, -30.0 ]
    105 
    106     See Also
    107     --------
    108