1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
{{alias}}( N, x, sx, m, sm, y, sy )
Computes the reciprocal square root for each element in a double-precision
floating-point strided array `x` according to a strided mask array and
assigns the results to elements in a double-precision floating-point strided
array `y`.
The `N` and stride parameters determine which strided array elements are
accessed at runtime.
Indexing is relative to the first index. To introduce an offset, use typed
array views.
Parameters
----------
N: integer
Number of indexed elements.
x: Float64Array
Input array.
sx: integer
Index increment for `x`.
m: Uint8Array
Mask array.
sm: integer
Index increment for `m`.
y: Float64Array
Destination array.
sy: integer
Index increment for `y`.
Returns
-------
y: Float64Array
Input array `y`.
Examples
--------
// Standard usage:
> var x = new {{alias:@stdlib/array/float64}}( [ 0.0, 4.0, 9.0, 12.0 ] );
> var m = new {{alias:@stdlib/array/uint8}}( [ 0, 0, 1, 0 ] );
> var y = new {{alias:@stdlib/array/float64}}( [ 0.0, 0.0, 0.0, 0.0 ] );
> {{alias}}( x.length, x, 1, m, 1, y, 1 )
<Float64Array>[ Infinity, 0.5, 0.0, ~0.289 ]
// Using `N` and stride parameters:
> y = new {{alias:@stdlib/array/float64}}( [ 0.0, 0.0, 0.0, 0.0 ] );
> {{alias}}( 2, x, 2, m, 2, y, -1 )
<Float64Array>[ 0.0, Infinity, 0.0, 0.0 ]
// Using view offsets:
> var x0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 4.0, 9.0, 12.0 ] );
> var m0 = new {{alias:@stdlib/array/uint8}}( [ 0, 0, 1, 0 ] );
> var y0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 0.0, 0.0, 0.0 ] );
> var x1 = new {{alias:@stdlib/array/float64}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 );
> var m1 = new {{alias:@stdlib/array/uint8}}( m0.buffer, m0.BYTES_PER_ELEMENT*1 );
> var y1 = new {{alias:@stdlib/array/float64}}( y0.buffer, y0.BYTES_PER_ELEMENT*2 );
> {{alias}}( 2, x1, -2, m1, -2, y1, 1 )
<Float64Array>[ ~0.289, 0.5 ]
> y0
<Float64Array>[ 0.0, 0.0, ~0.289, 0.5 ]
{{alias}}.ndarray( N, x, sx, ox, m, sm, om, y, sy, oy )
Computes the reciprocal square root for each element in a double-precision
floating-point strided array `x` according to a strided mask array and
assigns the results to elements in a double-precision floating-point strided
array `y` using alternative indexing semantics.
While typed array views mandate a view offset based on the underlying
buffer, the offset parameters support indexing semantics based on starting
indices.
Parameters
----------
N: integer
Number of indexed elements.
x: Float64Array
Input array.
sx: integer
Index increment for `x`.
ox: integer
Starting index for `x`.
m: Float64Array
Mask array.
sm: integer
Index increment for `m`.
om: integer
Starting index for `m`.
y: Float64Array
Destination array.
sy: integer
Index increment for `y`.
oy: integer
Starting index for `y`.
Returns
-------
y: Float64Array
Input array `y`.
Examples
--------
// Standard usage:
> var x = new {{alias:@stdlib/array/float64}}( [ 0.0, 4.0, 9.0, 12.0 ] );
> var m = new {{alias:@stdlib/array/uint8}}( [ 0, 0, 1, 0 ] );
> var y = new {{alias:@stdlib/array/float64}}( [ 0.0, 0.0, 0.0, 0.0 ] );
> {{alias}}.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, 0 )
<Float64Array>[ Infinity, 0.5, 0.0, ~0.289 ]
// Advanced indexing:
> x = new {{alias:@stdlib/array/float64}}( [ 0.0, 4.0, 9.0, 12.0 ] );
> m = new {{alias:@stdlib/array/uint8}}( [ 0, 0, 1, 0 ] );
> y = new {{alias:@stdlib/array/float64}}( [ 0.0, 0.0, 0.0, 0.0 ] );
> {{alias}}.ndarray( 2, x, 2, 1, m, 2, 1, y, -1, y.length-1 )
<Float64Array>[ 0.0, 0.0, ~0.289, 0.5 ]
See Also
--------
|
