|
20 | 20 |
|
21 | 21 | // MODULES // |
22 | 22 |
|
23 | | -var tape = require( 'tape' ); |
24 | | -var flatten2d = require( '@stdlib/array/base/flatten2d' ); |
25 | | -var Float64Array = require( '@stdlib/array/float64' ); |
26 | | -var dgetrans = require( './../lib/ndarray.js' ); |
| 23 | +var tape = require('tape'); |
| 24 | +var ndarray = require('./path/to/ndarray'); // Replace with actual path |
27 | 25 |
|
28 | | -// HELPERS // |
29 | | - |
30 | | -function createMatrix(arr, shape, columnMajor) { |
31 | | - return new Float64Array(flatten2d(arr, shape, columnMajor)); |
32 | | -} |
33 | 26 |
|
34 | 27 | // TESTS // |
35 | 28 |
|
36 | | -tape( 'main export is a function', function test( t ) { |
37 | | - t.ok( true, __filename ); |
38 | | - t.strictEqual( typeof dgetrans, 'function', 'main export is a function' ); |
39 | | - t.end(); |
40 | | -}); |
41 | | - |
42 | | -tape( 'the function has an arity of 10', function test( t ) { |
43 | | - t.strictEqual( dgetrans.length, 10, 'returns expected value' ); |
44 | | - t.end(); |
45 | | -}); |
46 | | - |
47 | | -// ------------------------------------------------------------------ |
48 | | -// Test cases for different shapes and memory layouts |
49 | | -// ------------------------------------------------------------------ |
50 | | - |
51 | | -tape( 'transposes a tall rectangular matrix (row-major -> row-major)', function test( t ) { |
52 | | - var M = 4, N = 2; |
53 | | - |
54 | | - var A = createMatrix([ |
55 | | - [1, 2], |
56 | | - [3, 4], |
57 | | - [5, 6], |
58 | | - [7, 8] |
59 | | - ], [M, N], false); |
60 | | - |
61 | | - var out = new Float64Array(M * N); |
62 | | - |
63 | | - var expected = createMatrix([ |
64 | | - [1, 3, 5, 7], |
65 | | - [2, 4, 6, 8] |
66 | | - ], [N, M], false); |
67 | | - |
68 | | - var actual = dgetrans(M, N, A, N, 1, 0, out, M, 1, 0); |
69 | | - |
70 | | - t.deepEqual(actual, expected, 'returns expected transpose'); |
71 | | - t.end(); |
| 29 | +tape('main export is a function', function test(t) { |
| 30 | + t.ok(true, __filename); |
| 31 | + t.strictEqual(typeof ndarray, 'function', 'main export is a function'); |
| 32 | + t.end(); |
72 | 33 | }); |
73 | 34 |
|
74 | | -tape( 'transposes a tall rectangular matrix (row-major -> column-major)', function test( t ) { |
75 | | - var M = 4, N = 2; |
76 | | - |
77 | | - var A = createMatrix([ |
78 | | - [1, 2], |
79 | | - [3, 4], |
80 | | - [5, 6], |
81 | | - [7, 8] |
82 | | - ], [M, N], false); |
83 | | - |
84 | | - var out = new Float64Array(M * N); |
85 | | - |
86 | | - var expected = createMatrix([ |
87 | | - [1, 3, 5, 7], |
88 | | - [2, 4, 6, 8] |
89 | | - ], [N, M], true); |
90 | | - |
91 | | - var actual = dgetrans(M, N, A, N, 1, 0, out, 1, N, 0); |
92 | | - |
93 | | - t.deepEqual(actual, expected, 'returns expected transpose'); |
94 | | - t.end(); |
| 35 | +tape('should create an ndarray with specified shape', function test(t) { |
| 36 | + var strides = [2, 1]; |
| 37 | + var offset = 0; |
| 38 | + var shape = [2, 2]; |
| 39 | + var order = 'row-major'; |
| 40 | + var data = [1, 2, 3, 4]; |
| 41 | + |
| 42 | + var arr = ndarray('generic', data, shape, strides, offset, order); |
| 43 | + |
| 44 | + t.strictEqual(arr.shape.length, 2, 'has two dimensions'); |
| 45 | + t.deepEqual(arr.shape, [2, 2], 'correct shape'); |
| 46 | + t.strictEqual(arr.get(0, 0), 1, 'correct value at (0, 0)'); |
| 47 | + t.strictEqual(arr.get(0, 1), 2, 'correct value at (0, 1)'); |
| 48 | + t.strictEqual(arr.get(1, 0), 3, 'correct value at (1, 0)'); |
| 49 | + t.strictEqual(arr.get(1, 1), 4, 'correct value at (1, 1)'); |
| 50 | + t.end(); |
95 | 51 | }); |
96 | 52 |
|
97 | | -tape( 'transposes a wide rectangular matrix (column-major -> row-major)', function test( t ) { |
98 | | - var M = 2, N = 4; |
99 | | - |
100 | | - var A = createMatrix([ |
101 | | - [1, 2, 3, 4], |
102 | | - [5, 6, 7, 8] |
103 | | - ], [M, N], true); |
104 | | - |
105 | | - var out = new Float64Array(M * N); |
106 | | - |
107 | | - var expected = createMatrix([ |
108 | | - [1, 5], |
109 | | - [2, 6], |
110 | | - [3, 7], |
111 | | - [4, 8] |
112 | | - ], [N, M], false); |
113 | | - |
114 | | - var actual = dgetrans(M, N, A, 1, M, 0, out, M, 1, 0); |
115 | | - |
116 | | - t.deepEqual(actual, expected, 'returns expected transpose'); |
117 | | - t.end(); |
| 53 | +tape('should support setting elements', function test(t) { |
| 54 | + var strides = [2, 1]; |
| 55 | + var offset = 0; |
| 56 | + var shape = [2, 2]; |
| 57 | + var order = 'row-major'; |
| 58 | + var data = [0, 0, 0, 0]; |
| 59 | + |
| 60 | + var arr = ndarray('generic', data, shape, strides, offset, order); |
| 61 | + |
| 62 | + arr.set(0, 0, 5); |
| 63 | + arr.set(0, 1, 6); |
| 64 | + arr.set(1, 0, 7); |
| 65 | + arr.set(1, 1, 8); |
| 66 | + |
| 67 | + t.strictEqual(arr.get(0, 0), 5, 'value set at (0, 0)'); |
| 68 | + t.strictEqual(arr.get(0, 1), 6, 'value set at (0, 1)'); |
| 69 | + t.strictEqual(arr.get(1, 0), 7, 'value set at (1, 0)'); |
| 70 | + t.strictEqual(arr.get(1, 1), 8, 'value set at (1, 1)'); |
| 71 | + t.end(); |
118 | 72 | }); |
119 | | - |
120 | | -tape( 'transposes a square matrix (column-major -> column-major)', function test( t ) { |
121 | | - var M = 3, N = 3; |
122 | | - |
123 | | - var A = createMatrix([ |
124 | | - [1, 2, 3], |
125 | | - [4, 5, 6], |
126 | | - [7, 8, 9] |
127 | | - ], [M, N], true); |
128 | | - |
129 | | - var out = new Float64Array(M * N); |
130 | | - |
131 | | - var expected = createMatrix([ |
132 | | - [1, 4, 7], |
133 | | - [2, 5, 8], |
134 | | - [3, 6, 9] |
135 | | - ], [N, M], true); |
136 | | - |
137 | | - var actual = dgetrans(M, N, A, 1, M, 0, out, 1, N, 0); |
138 | | - |
139 | | - t.deepEqual(actual, expected, 'returns expected transpose'); |
140 | | - t.end(); |
141 | | -}); |
142 | | - |
143 | | -tape( 'transposes an empty matrix (M=0)', function test( t ) { |
144 | | - var M = 0, N = 3; |
145 | | - |
146 | | - var A = new Float64Array(0); |
147 | | - var out = new Float64Array(0); |
148 | | - var expected = new Float64Array(0); |
149 | | - |
150 | | - var actual = dgetrans(M, N, A, 1, M, 0, out, 1, N, 0); |
151 | | - |
152 | | - t.deepEqual(actual, expected, 'returns empty transpose'); |
153 | | - t.end(); |
154 | | -}); |
155 | | - |
156 | | -tape( 'transposes an empty matrix (N=0)', function test( t ) { |
157 | | - var M = 3, N = 0; |
158 | | - |
159 | | - var A = new Float64Array(0); |
160 | | - var out = new Float64Array(0); |
161 | | - var expected = new Float64Array(0); |
162 | | - |
163 | | - var actual = dgetrans(M, N, A, 1, M, 0, out, 1, N, 0); |
164 | | - |
165 | | - t.deepEqual(actual, expected, 'returns empty transpose'); |
166 | | - t.end(); |
167 | | -}); |
168 | | - |
169 | | -tape( 'transposes a single element matrix', function test( t ) { |
170 | | - var M = 1, N = 1; |
171 | | - |
172 | | - var A = new Float64Array([42]); |
173 | | - var out = new Float64Array(1); |
174 | | - |
175 | | - var expected = new Float64Array([42]); |
176 | | - |
177 | | - var actual = dgetrans(M, N, A, 1, M, 0, out, 1, N, 0); |
178 | | - |
179 | | - t.deepEqual(actual, expected, 'returns expected transpose'); |
180 | | - t.end(); |
181 | | -}); |
182 | | - |
183 | | -// ------------------------------------------------------------------ |
184 | | -// Optional: Performance test (disabled by default) |
185 | | -// ------------------------------------------------------------------ |
186 | | - |
187 | | -// tape.skip( 'transposes a large matrix efficiently', function test( t ) { |
188 | | -// var M = 1000, N = 1000; |
189 | | -// var A = new Float64Array(M * N); |
190 | | -// for (var i = 0; i < A.length; i++) { |
191 | | -// A[i] = i; |
192 | | -// } |
193 | | -// var out = new Float64Array(M * N); |
194 | | -// dgetrans(M, N, A, N, 1, 0, out, M, 1, 0); |
195 | | -// t.ok(true, 'transposed large matrix without error'); |
196 | | -// t.end(); |
197 | | -// }); |
198 | | - |
0 commit comments