@@ -46,11 +46,11 @@ interface ModuleConstructor {
46
46
* });
47
47
*
48
48
* // Create a BLAS routine:
49
- * var saxpy = new saxpy.Module( mem );
49
+ * var mod = new saxpy.Module( mem );
50
50
* // returns <Module>
51
51
*
52
52
* // Initialize the routine:
53
- * saxpy .initializeSync();
53
+ * mod .initializeSync();
54
54
*
55
55
* // Define a vector data type:
56
56
* var dtype = 'float32';
@@ -63,19 +63,19 @@ interface ModuleConstructor {
63
63
* var yptr = N * bytesPerElement( dtype );
64
64
*
65
65
* // Write vector values to module memory:
66
- * saxpy .write( xptr, oneTo( N, dtype ) );
67
- * saxpy .write( yptr, ones( N, dtype ) );
66
+ * mod .write( xptr, oneTo( N, dtype ) );
67
+ * mod .write( yptr, ones( N, dtype ) );
68
68
*
69
69
* // Perform computation:
70
- * var ptr = saxpy .main( N, 5.0, xptr, 1, yptr, 1 );
70
+ * var ptr = mod .main( N, 5.0, xptr, 1, yptr, 1 );
71
71
* // returns <number>
72
72
*
73
73
* var bool = ( ptr === yptr );
74
74
* // returns true
75
75
*
76
76
* // Read out the results:
77
77
* var view = zeros( N, dtype );
78
- * saxpy .read( yptr, view );
78
+ * mod .read( yptr, view );
79
79
* // view => <Float32Array>[ 6.0, 11.0, 16.0, 21.0, 26.0 ]
80
80
*/
81
81
new ( mem : Memory ) : Module ; // newable
@@ -100,11 +100,11 @@ interface ModuleConstructor {
100
100
* });
101
101
*
102
102
* // Create a BLAS routine:
103
- * var saxpy = saxpy.Module( mem );
103
+ * var mod = saxpy.Module( mem );
104
104
* // returns <Module>
105
105
*
106
106
* // Initialize the routine:
107
- * saxpy .initializeSync();
107
+ * mod .initializeSync();
108
108
*
109
109
* // Define a vector data type:
110
110
* var dtype = 'float32';
@@ -117,19 +117,19 @@ interface ModuleConstructor {
117
117
* var yptr = N * bytesPerElement( dtype );
118
118
*
119
119
* // Write vector values to module memory:
120
- * saxpy .write( xptr, oneTo( N, dtype ) );
121
- * saxpy .write( yptr, ones( N, dtype ) );
120
+ * mod .write( xptr, oneTo( N, dtype ) );
121
+ * mod .write( yptr, ones( N, dtype ) );
122
122
*
123
123
* // Perform computation:
124
- * var ptr = saxpy .main( N, 5.0, xptr, 1, yptr, 1 );
124
+ * var ptr = mod .main( N, 5.0, xptr, 1, yptr, 1 );
125
125
* // returns <number>
126
126
*
127
127
* var bool = ( ptr === yptr );
128
128
* // returns true
129
129
*
130
130
* // Read out the results:
131
131
* var view = zeros( N, dtype );
132
- * saxpy .read( yptr, view );
132
+ * mod .read( yptr, view );
133
133
* // view => <Float32Array>[ 6.0, 11.0, 16.0, 21.0, 26.0 ]
134
134
*/
135
135
( mem : Memory ) : Module ; // callable
@@ -164,11 +164,11 @@ interface Module extends ModuleWrapper {
164
164
* });
165
165
*
166
166
* // Create a BLAS routine:
167
- * var saxpy = new Module( mem );
167
+ * var mod = new saxpy. Module( mem );
168
168
* // returns <Module>
169
169
*
170
170
* // Initialize the routine:
171
- * saxpy .initializeSync();
171
+ * mod .initializeSync();
172
172
*
173
173
* // Define a vector data type:
174
174
* var dtype = 'float32';
@@ -181,19 +181,19 @@ interface Module extends ModuleWrapper {
181
181
* var yptr = N * bytesPerElement( dtype );
182
182
*
183
183
* // Write vector values to module memory:
184
- * saxpy .write( xptr, oneTo( N, dtype ) );
185
- * saxpy .write( yptr, ones( N, dtype ) );
184
+ * mod .write( xptr, oneTo( N, dtype ) );
185
+ * mod .write( yptr, ones( N, dtype ) );
186
186
*
187
187
* // Perform computation:
188
- * var ptr = saxpy .main( N, 5.0, xptr, 1, yptr, 1 );
188
+ * var ptr = mod .main( N, 5.0, xptr, 1, yptr, 1 );
189
189
* // returns <number>
190
190
*
191
191
* var bool = ( ptr === yptr );
192
192
* // returns true
193
193
*
194
194
* // Read out the results:
195
195
* var view = zeros( N, dtype );
196
- * saxpy .read( yptr, view );
196
+ * mod .read( yptr, view );
197
197
* // view => <Float32Array>[ 6.0, 11.0, 16.0, 21.0, 26.0 ]
198
198
*/
199
199
main ( N : number , alpha : number , xptr : number , strideX : number , yptr : number , strideY : number ) : number ;
@@ -225,11 +225,11 @@ interface Module extends ModuleWrapper {
225
225
* });
226
226
*
227
227
* // Create a BLAS routine:
228
- * var saxpy = new Module( mem );
228
+ * var mod = new saxpy. Module( mem );
229
229
* // returns <Module>
230
230
*
231
231
* // Initialize the routine:
232
- * saxpy .initializeSync();
232
+ * mod .initializeSync();
233
233
*
234
234
* // Define a vector data type:
235
235
* var dtype = 'float32';
@@ -242,19 +242,19 @@ interface Module extends ModuleWrapper {
242
242
* var yptr = N * bytesPerElement( dtype );
243
243
*
244
244
* // Write vector values to module memory:
245
- * saxpy .write( xptr, oneTo( N, dtype ) );
246
- * saxpy .write( yptr, ones( N, dtype ) );
245
+ * mod .write( xptr, oneTo( N, dtype ) );
246
+ * mod .write( yptr, ones( N, dtype ) );
247
247
*
248
248
* // Perform computation:
249
- * var ptr = saxpy .ndarray( N, 5.0, xptr, 1, 0, yptr, 1, 0 );
249
+ * var ptr = mod .ndarray( N, 5.0, xptr, 1, 0, yptr, 1, 0 );
250
250
* // returns <number>
251
251
*
252
252
* var bool = ( ptr === yptr );
253
253
* // returns true
254
254
*
255
255
* // Read out the results:
256
256
* var view = zeros( N, dtype );
257
- * saxpy .read( yptr, view );
257
+ * mod .read( yptr, view );
258
258
* // view => <Float32Array>[ 6.0, 11.0, 16.0, 21.0, 26.0 ]
259
259
*/
260
260
ndarray ( N : number , alpha : number , xptr : number , strideX : number , offsetX : number , yptr : number , strideY : number , offsetY : number ) : number ;
@@ -330,11 +330,11 @@ interface Routine extends ModuleWrapper {
330
330
* });
331
331
*
332
332
* // Create a BLAS routine:
333
- * var saxpy = new saxpy.Module( mem );
333
+ * var mod = new saxpy.Module( mem );
334
334
* // returns <Module>
335
335
*
336
336
* // Initialize the routine:
337
- * saxpy .initializeSync();
337
+ * mod .initializeSync();
338
338
*
339
339
* // Define a vector data type:
340
340
* var dtype = 'float32';
@@ -347,19 +347,19 @@ interface Routine extends ModuleWrapper {
347
347
* var yptr = N * bytesPerElement( dtype );
348
348
*
349
349
* // Write vector values to module memory:
350
- * saxpy .write( xptr, oneTo( N, dtype ) );
351
- * saxpy .write( yptr, ones( N, dtype ) );
350
+ * mod .write( xptr, oneTo( N, dtype ) );
351
+ * mod .write( yptr, ones( N, dtype ) );
352
352
*
353
353
* // Perform computation:
354
- * var ptr = saxpy .main( N, 5.0, xptr, 1, yptr, 1 );
354
+ * var ptr = mod .main( N, 5.0, xptr, 1, yptr, 1 );
355
355
* // returns <number>
356
356
*
357
357
* var bool = ( ptr === yptr );
358
358
* // returns true
359
359
*
360
360
* // Read out the results:
361
361
* var view = zeros( N, dtype );
362
- * saxpy .read( yptr, view );
362
+ * mod .read( yptr, view );
363
363
* // view => <Float32Array>[ 6.0, 11.0, 16.0, 21.0, 26.0 ]
364
364
*/
365
365
Module : ModuleConstructor ;
0 commit comments