|
1
|
1 // tc-index.cc -*- C++ -*- |
|
|
2 /* |
|
|
3 |
|
381
|
4 Copyright (C) 1992, 1993, 1994 John W. Eaton |
|
1
|
5 |
|
|
6 This file is part of Octave. |
|
|
7 |
|
|
8 Octave is free software; you can redistribute it and/or modify it |
|
|
9 under the terms of the GNU General Public License as published by the |
|
|
10 Free Software Foundation; either version 2, or (at your option) any |
|
|
11 later version. |
|
|
12 |
|
|
13 Octave is distributed in the hope that it will be useful, but WITHOUT |
|
|
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
|
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
|
16 for more details. |
|
|
17 |
|
|
18 You should have received a copy of the GNU General Public License |
|
|
19 along with Octave; see the file COPYING. If not, write to the Free |
|
|
20 Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. |
|
|
21 |
|
|
22 */ |
|
|
23 |
|
240
|
24 #ifdef HAVE_CONFIG_H |
|
|
25 #include "config.h" |
|
1
|
26 #endif |
|
|
27 |
|
164
|
28 #include "idx-vector.h" |
|
1
|
29 #include "user-prefs.h" |
|
164
|
30 #include "tree-const.h" |
|
|
31 #include "utils.h" |
|
1
|
32 #include "gripes.h" |
|
164
|
33 #include "error.h" |
|
1
|
34 |
|
|
35 #include "tc-inlines.cc" |
|
|
36 |
|
|
37 int |
|
164
|
38 tree_constant_rep::valid_as_scalar_index (void) const |
|
1
|
39 { |
|
|
40 int valid = type_tag == magic_colon |
|
|
41 || (type_tag == scalar_constant && NINT (scalar) == 1) |
|
|
42 || (type_tag == range_constant |
|
|
43 && range->nelem () == 1 && NINT (range->base ()) == 1); |
|
|
44 |
|
|
45 return valid; |
|
|
46 } |
|
|
47 |
|
|
48 tree_constant |
|
164
|
49 tree_constant_rep::do_scalar_index (const tree_constant *args, |
|
|
50 int nargs) const |
|
1
|
51 { |
|
|
52 if (valid_scalar_indices (args, nargs)) |
|
|
53 { |
|
|
54 if (type_tag == scalar_constant) |
|
|
55 return tree_constant (scalar); |
|
|
56 else if (type_tag == complex_scalar_constant) |
|
|
57 return tree_constant (*complex_scalar); |
|
|
58 else |
|
|
59 panic_impossible (); |
|
|
60 } |
|
67
|
61 else |
|
1
|
62 { |
|
67
|
63 int rows = 0; |
|
|
64 int cols = 0; |
|
1
|
65 |
|
67
|
66 switch (nargs) |
|
1
|
67 { |
|
67
|
68 case 3: |
|
|
69 { |
|
|
70 if (args[2].is_matrix_type ()) |
|
|
71 { |
|
|
72 Matrix mj = args[2].matrix_value (); |
|
|
73 |
|
|
74 idx_vector j (mj, user_pref.do_fortran_indexing, ""); |
|
191
|
75 if (! j) |
|
|
76 return tree_constant (); |
|
67
|
77 |
|
|
78 int len = j.length (); |
|
|
79 if (len == j.ones_count ()) |
|
|
80 cols = len; |
|
|
81 } |
|
387
|
82 else if (args[2].const_type () == magic_colon |
|
|
83 || (args[2].is_scalar_type () |
|
|
84 && NINT (args[2].double_value ()) == 1)) |
|
67
|
85 { |
|
|
86 cols = 1; |
|
|
87 } |
|
|
88 else |
|
|
89 break; |
|
|
90 } |
|
|
91 // Fall through... |
|
|
92 case 2: |
|
|
93 { |
|
|
94 if (args[1].is_matrix_type ()) |
|
|
95 { |
|
|
96 Matrix mi = args[1].matrix_value (); |
|
|
97 |
|
|
98 idx_vector i (mi, user_pref.do_fortran_indexing, ""); |
|
191
|
99 if (! i) |
|
|
100 return tree_constant (); |
|
67
|
101 |
|
|
102 int len = i.length (); |
|
|
103 if (len == i.ones_count ()) |
|
|
104 rows = len; |
|
|
105 } |
|
387
|
106 else if (args[1].const_type () == magic_colon |
|
|
107 || (args[1].is_scalar_type () |
|
|
108 && NINT (args[1].double_value ()) == 1)) |
|
67
|
109 { |
|
|
110 rows = 1; |
|
|
111 } |
|
388
|
112 else if (args[1].is_scalar_type () |
|
|
113 && NINT (args[1].double_value ()) == 0) |
|
|
114 { |
|
|
115 Matrix m (0, 0); |
|
|
116 return tree_constant (m); |
|
|
117 } |
|
67
|
118 else |
|
|
119 break; |
|
|
120 |
|
|
121 if (cols == 0) |
|
|
122 { |
|
|
123 if (user_pref.prefer_column_vectors) |
|
|
124 cols = 1; |
|
|
125 else |
|
|
126 { |
|
|
127 cols = rows; |
|
|
128 rows = 1; |
|
|
129 } |
|
|
130 } |
|
|
131 |
|
|
132 if (type_tag == scalar_constant) |
|
|
133 { |
|
|
134 Matrix m (rows, cols, scalar); |
|
|
135 return tree_constant (m); |
|
|
136 } |
|
|
137 else if (type_tag == complex_scalar_constant) |
|
|
138 { |
|
|
139 ComplexMatrix cm (rows, cols, *complex_scalar); |
|
|
140 return tree_constant (cm); |
|
|
141 } |
|
|
142 else |
|
|
143 panic_impossible (); |
|
|
144 } |
|
|
145 break; |
|
|
146 default: |
|
240
|
147 ::error ("illegal number of arguments for scalar type"); |
|
143
|
148 return tree_constant (); |
|
67
|
149 break; |
|
1
|
150 } |
|
|
151 } |
|
|
152 |
|
240
|
153 ::error ("index invalid or out of range for scalar type"); |
|
143
|
154 return tree_constant (); |
|
1
|
155 } |
|
|
156 |
|
|
157 tree_constant |
|
164
|
158 tree_constant_rep::do_matrix_index (const tree_constant *args, |
|
|
159 int nargin) const |
|
1
|
160 { |
|
|
161 tree_constant retval; |
|
|
162 |
|
|
163 switch (nargin) |
|
|
164 { |
|
|
165 case 2: |
|
|
166 if (args == NULL_TREE_CONST) |
|
240
|
167 ::error ("matrix index is null"); |
|
1
|
168 else if (args[1].is_undefined ()) |
|
240
|
169 ::error ("matrix index is a null expression"); |
|
1
|
170 else |
|
|
171 retval = do_matrix_index (args[1]); |
|
|
172 break; |
|
|
173 case 3: |
|
|
174 if (args == NULL_TREE_CONST) |
|
240
|
175 ::error ("matrix indices are null"); |
|
1
|
176 else if (args[1].is_undefined ()) |
|
240
|
177 ::error ("first matrix index is a null expression"); |
|
1
|
178 else if (args[2].is_undefined ()) |
|
240
|
179 ::error ("second matrix index is a null expression"); |
|
1
|
180 else |
|
|
181 retval = do_matrix_index (args[1], args[2]); |
|
|
182 break; |
|
|
183 default: |
|
240
|
184 ::error ("too many indices for matrix expression"); |
|
1
|
185 break; |
|
|
186 } |
|
|
187 |
|
|
188 return retval; |
|
|
189 } |
|
|
190 |
|
|
191 tree_constant |
|
164
|
192 tree_constant_rep::do_matrix_index (const tree_constant& i_arg) const |
|
1
|
193 { |
|
|
194 tree_constant retval; |
|
|
195 |
|
|
196 int nr = rows (); |
|
|
197 int nc = columns (); |
|
|
198 |
|
|
199 if (user_pref.do_fortran_indexing) |
|
|
200 retval = fortran_style_matrix_index (i_arg); |
|
|
201 else if (nr <= 1 || nc <= 1) |
|
|
202 retval = do_vector_index (i_arg); |
|
|
203 else |
|
240
|
204 ::error ("single index only valid for row or column vector"); |
|
1
|
205 |
|
|
206 return retval; |
|
|
207 } |
|
|
208 |
|
|
209 tree_constant |
|
164
|
210 tree_constant_rep::fortran_style_matrix_index |
|
|
211 (const tree_constant& i_arg) const |
|
1
|
212 { |
|
|
213 tree_constant retval; |
|
|
214 |
|
|
215 tree_constant tmp_i = i_arg.make_numeric_or_magic (); |
|
|
216 |
|
|
217 tree_constant_rep::constant_type itype = tmp_i.const_type (); |
|
|
218 |
|
|
219 int nr = rows (); |
|
|
220 int nc = columns (); |
|
|
221 |
|
|
222 switch (itype) |
|
|
223 { |
|
|
224 case complex_scalar_constant: |
|
|
225 case scalar_constant: |
|
|
226 { |
|
|
227 int i = NINT (tmp_i.double_value ()); |
|
|
228 int ii = fortran_row (i, nr) - 1; |
|
|
229 int jj = fortran_column (i, nr) - 1; |
|
143
|
230 if (index_check (i-1, "") < 0) |
|
|
231 return tree_constant (); |
|
|
232 if (range_max_check (i-1, nr * nc) < 0) |
|
|
233 return tree_constant (); |
|
1
|
234 retval = do_matrix_index (ii, jj); |
|
|
235 } |
|
|
236 break; |
|
|
237 case complex_matrix_constant: |
|
|
238 case matrix_constant: |
|
|
239 { |
|
|
240 Matrix mi = tmp_i.matrix_value (); |
|
|
241 if (mi.rows () == 0 || mi.columns () == 0) |
|
|
242 { |
|
|
243 Matrix mtmp; |
|
|
244 retval = tree_constant (mtmp); |
|
|
245 } |
|
|
246 else |
|
|
247 { |
|
|
248 // Yes, we really do want to call this with mi. |
|
|
249 retval = fortran_style_matrix_index (mi); |
|
|
250 } |
|
|
251 } |
|
|
252 break; |
|
|
253 case string_constant: |
|
|
254 gripe_string_invalid (); |
|
|
255 break; |
|
|
256 case range_constant: |
|
|
257 gripe_range_invalid (); |
|
|
258 break; |
|
|
259 case magic_colon: |
|
|
260 retval = do_matrix_index (magic_colon); |
|
|
261 break; |
|
|
262 default: |
|
|
263 panic_impossible (); |
|
|
264 break; |
|
|
265 } |
|
|
266 |
|
|
267 return retval; |
|
|
268 } |
|
|
269 |
|
|
270 tree_constant |
|
164
|
271 tree_constant_rep::fortran_style_matrix_index (const Matrix& mi) const |
|
1
|
272 { |
|
|
273 assert (is_matrix_type ()); |
|
|
274 |
|
|
275 tree_constant retval; |
|
|
276 |
|
|
277 int nr = rows (); |
|
|
278 int nc = columns (); |
|
|
279 |
|
|
280 int len = nr * nc; |
|
|
281 |
|
|
282 int index_nr = mi.rows (); |
|
|
283 int index_nc = mi.columns (); |
|
|
284 |
|
|
285 if (index_nr >= 1 && index_nc >= 1) |
|
|
286 { |
|
240
|
287 const double *cop_out = (const double *) NULL; |
|
|
288 const Complex *c_cop_out = (const Complex *) NULL; |
|
1
|
289 int real_type = type_tag == matrix_constant; |
|
|
290 if (real_type) |
|
240
|
291 cop_out = matrix->data (); |
|
1
|
292 else |
|
240
|
293 c_cop_out = complex_matrix->data (); |
|
1
|
294 |
|
240
|
295 const double *cop_out_index = mi.data (); |
|
1
|
296 |
|
|
297 idx_vector iv (mi, 1, "", len); |
|
191
|
298 if (! iv) |
|
|
299 return tree_constant (); |
|
1
|
300 |
|
|
301 int result_size = iv.length (); |
|
|
302 |
|
388
|
303 if (nc == 1 || (nr != 1 && iv.one_zero_only ())) |
|
1
|
304 { |
|
|
305 CRMATRIX (m, cm, result_size, 1); |
|
|
306 |
|
|
307 for (int i = 0; i < result_size; i++) |
|
|
308 { |
|
|
309 int idx = iv.elem (i); |
|
|
310 CRMATRIX_ASSIGN_ELEM (m, cm, i, 0, cop_out [idx], |
|
|
311 c_cop_out [idx], real_type); |
|
|
312 } |
|
|
313 |
|
|
314 ASSIGN_CRMATRIX_TO (retval, m, cm); |
|
|
315 } |
|
388
|
316 else if (nr == 1) |
|
1
|
317 { |
|
|
318 CRMATRIX (m, cm, 1, result_size); |
|
|
319 |
|
|
320 for (int i = 0; i < result_size; i++) |
|
|
321 { |
|
|
322 int idx = iv.elem (i); |
|
|
323 CRMATRIX_ASSIGN_ELEM (m, cm, 0, i, cop_out [idx], |
|
|
324 c_cop_out [idx], real_type); |
|
|
325 } |
|
|
326 |
|
|
327 ASSIGN_CRMATRIX_TO (retval, m, cm); |
|
|
328 } |
|
|
329 else |
|
|
330 { |
|
|
331 CRMATRIX (m, cm, index_nr, index_nc); |
|
|
332 |
|
|
333 for (int j = 0; j < index_nc; j++) |
|
|
334 for (int i = 0; i < index_nr; i++) |
|
|
335 { |
|
|
336 double tmp = *cop_out_index++; |
|
|
337 int idx = tree_to_mat_idx (tmp); |
|
|
338 CRMATRIX_ASSIGN_ELEM (m, cm, i, j, cop_out [idx], |
|
|
339 c_cop_out [idx], real_type); |
|
|
340 } |
|
|
341 |
|
|
342 ASSIGN_CRMATRIX_TO (retval, m, cm); |
|
|
343 } |
|
|
344 } |
|
|
345 else |
|
|
346 { |
|
|
347 if (index_nr == 0 || index_nc == 0) |
|
240
|
348 ::error ("empty matrix invalid as index"); |
|
1
|
349 else |
|
240
|
350 ::error ("invalid matrix index"); |
|
143
|
351 return tree_constant (); |
|
1
|
352 } |
|
|
353 |
|
|
354 return retval; |
|
|
355 } |
|
|
356 |
|
|
357 tree_constant |
|
164
|
358 tree_constant_rep::do_vector_index (const tree_constant& i_arg) const |
|
1
|
359 { |
|
|
360 tree_constant retval; |
|
|
361 |
|
|
362 tree_constant tmp_i = i_arg.make_numeric_or_range_or_magic (); |
|
|
363 |
|
|
364 tree_constant_rep::constant_type itype = tmp_i.const_type (); |
|
|
365 |
|
|
366 int nr = rows (); |
|
|
367 int nc = columns (); |
|
|
368 |
|
|
369 int len = nr > nc ? nr : nc; |
|
|
370 |
|
381
|
371 if (nr == 0 || nc == 0) |
|
|
372 { |
|
|
373 ::error ("attempt to index empty matrix"); |
|
|
374 return retval; |
|
|
375 } |
|
|
376 |
|
1
|
377 assert ((nr == 1 || nc == 1) && ! user_pref.do_fortran_indexing); |
|
|
378 |
|
|
379 int swap_indices = (nr == 1); |
|
|
380 |
|
|
381 switch (itype) |
|
|
382 { |
|
|
383 case complex_scalar_constant: |
|
|
384 case scalar_constant: |
|
|
385 { |
|
|
386 int i = tree_to_mat_idx (tmp_i.double_value ()); |
|
143
|
387 if (index_check (i, "") < 0) |
|
|
388 return tree_constant (); |
|
1
|
389 if (swap_indices) |
|
|
390 { |
|
143
|
391 if (range_max_check (i, nc) < 0) |
|
|
392 return tree_constant (); |
|
1
|
393 retval = do_matrix_index (0, i); |
|
|
394 } |
|
|
395 else |
|
|
396 { |
|
143
|
397 if (range_max_check (i, nr) < 0) |
|
|
398 return tree_constant (); |
|
1
|
399 retval = do_matrix_index (i, 0); |
|
|
400 } |
|
|
401 } |
|
|
402 break; |
|
|
403 case complex_matrix_constant: |
|
|
404 case matrix_constant: |
|
|
405 { |
|
|
406 Matrix mi = tmp_i.matrix_value (); |
|
|
407 if (mi.rows () == 0 || mi.columns () == 0) |
|
|
408 { |
|
|
409 Matrix mtmp; |
|
|
410 retval = tree_constant (mtmp); |
|
|
411 } |
|
|
412 else |
|
|
413 { |
|
|
414 idx_vector iv (mi, user_pref.do_fortran_indexing, "", len); |
|
191
|
415 if (! iv) |
|
|
416 return tree_constant (); |
|
|
417 |
|
1
|
418 if (swap_indices) |
|
|
419 { |
|
212
|
420 if (range_max_check (iv.max (), nc) < 0) |
|
143
|
421 return tree_constant (); |
|
1
|
422 retval = do_matrix_index (0, iv); |
|
|
423 } |
|
|
424 else |
|
|
425 { |
|
212
|
426 if (range_max_check (iv.max (), nr) < 0) |
|
143
|
427 return tree_constant (); |
|
1
|
428 retval = do_matrix_index (iv, 0); |
|
|
429 } |
|
|
430 } |
|
|
431 } |
|
|
432 break; |
|
|
433 case string_constant: |
|
|
434 gripe_string_invalid (); |
|
|
435 break; |
|
|
436 case range_constant: |
|
|
437 { |
|
|
438 Range ri = tmp_i.range_value (); |
|
|
439 if (len == 2 && is_zero_one (ri)) |
|
|
440 { |
|
|
441 if (swap_indices) |
|
|
442 retval = do_matrix_index (0, 1); |
|
|
443 else |
|
|
444 retval = do_matrix_index (1, 0); |
|
|
445 } |
|
212
|
446 else if (len == 2 && is_one_zero (ri)) |
|
|
447 { |
|
|
448 retval = do_matrix_index (0, 0); |
|
|
449 } |
|
1
|
450 else |
|
|
451 { |
|
212
|
452 if (index_check (ri, "") < 0) |
|
143
|
453 return tree_constant (); |
|
1
|
454 if (swap_indices) |
|
|
455 { |
|
212
|
456 if (range_max_check (tree_to_mat_idx (ri.max ()), nc) < 0) |
|
143
|
457 return tree_constant (); |
|
1
|
458 retval = do_matrix_index (0, ri); |
|
|
459 } |
|
|
460 else |
|
|
461 { |
|
212
|
462 if (range_max_check (tree_to_mat_idx (ri.max ()), nr) < 0) |
|
143
|
463 return tree_constant (); |
|
1
|
464 retval = do_matrix_index (ri, 0); |
|
|
465 } |
|
|
466 } |
|
|
467 } |
|
|
468 break; |
|
|
469 case magic_colon: |
|
|
470 if (swap_indices) |
|
|
471 retval = do_matrix_index (0, magic_colon); |
|
|
472 else |
|
|
473 retval = do_matrix_index (magic_colon, 0); |
|
|
474 break; |
|
|
475 default: |
|
|
476 panic_impossible (); |
|
|
477 break; |
|
|
478 } |
|
|
479 |
|
|
480 return retval; |
|
|
481 } |
|
|
482 |
|
|
483 tree_constant |
|
164
|
484 tree_constant_rep::do_matrix_index (const tree_constant& i_arg, |
|
|
485 const tree_constant& j_arg) const |
|
1
|
486 { |
|
|
487 tree_constant retval; |
|
|
488 |
|
|
489 tree_constant tmp_i = i_arg.make_numeric_or_range_or_magic (); |
|
|
490 |
|
|
491 tree_constant_rep::constant_type itype = tmp_i.const_type (); |
|
|
492 |
|
|
493 switch (itype) |
|
|
494 { |
|
|
495 case complex_scalar_constant: |
|
|
496 case scalar_constant: |
|
|
497 { |
|
|
498 int i = tree_to_mat_idx (tmp_i.double_value ()); |
|
143
|
499 if (index_check (i, "row") < 0) |
|
|
500 return tree_constant (); |
|
1
|
501 retval = do_matrix_index (i, j_arg); |
|
|
502 } |
|
|
503 break; |
|
|
504 case complex_matrix_constant: |
|
|
505 case matrix_constant: |
|
|
506 { |
|
|
507 Matrix mi = tmp_i.matrix_value (); |
|
|
508 idx_vector iv (mi, user_pref.do_fortran_indexing, "row", rows ()); |
|
191
|
509 if (! iv) |
|
|
510 return tree_constant (); |
|
|
511 |
|
1
|
512 if (iv.length () == 0) |
|
|
513 { |
|
|
514 Matrix mtmp; |
|
|
515 retval = tree_constant (mtmp); |
|
|
516 } |
|
|
517 else |
|
|
518 retval = do_matrix_index (iv, j_arg); |
|
|
519 } |
|
|
520 break; |
|
|
521 case string_constant: |
|
|
522 gripe_string_invalid (); |
|
|
523 break; |
|
|
524 case range_constant: |
|
|
525 { |
|
|
526 Range ri = tmp_i.range_value (); |
|
212
|
527 int nr = rows (); |
|
|
528 if (nr == 2 && is_zero_one (ri)) |
|
1
|
529 { |
|
|
530 retval = do_matrix_index (1, j_arg); |
|
|
531 } |
|
212
|
532 else if (nr == 2 && is_one_zero (ri)) |
|
|
533 { |
|
|
534 retval = do_matrix_index (0, j_arg); |
|
|
535 } |
|
1
|
536 else |
|
|
537 { |
|
212
|
538 if (index_check (ri, "row") < 0) |
|
143
|
539 return tree_constant (); |
|
212
|
540 retval = do_matrix_index (ri, j_arg); |
|
1
|
541 } |
|
|
542 } |
|
|
543 break; |
|
|
544 case magic_colon: |
|
|
545 retval = do_matrix_index (magic_colon, j_arg); |
|
|
546 break; |
|
|
547 default: |
|
|
548 panic_impossible (); |
|
|
549 break; |
|
|
550 } |
|
|
551 |
|
|
552 return retval; |
|
|
553 } |
|
|
554 |
|
|
555 tree_constant |
|
164
|
556 tree_constant_rep::do_matrix_index (int i, const tree_constant& j_arg) const |
|
1
|
557 { |
|
|
558 tree_constant retval; |
|
|
559 |
|
|
560 tree_constant tmp_j = j_arg.make_numeric_or_range_or_magic (); |
|
|
561 |
|
|
562 tree_constant_rep::constant_type jtype = tmp_j.const_type (); |
|
|
563 |
|
|
564 int nr = rows (); |
|
|
565 int nc = columns (); |
|
|
566 |
|
|
567 switch (jtype) |
|
|
568 { |
|
|
569 case complex_scalar_constant: |
|
|
570 case scalar_constant: |
|
|
571 { |
|
|
572 int j = tree_to_mat_idx (tmp_j.double_value ()); |
|
143
|
573 if (index_check (j, "column") < 0) |
|
|
574 return tree_constant (); |
|
|
575 if (range_max_check (i, j, nr, nc) < 0) |
|
|
576 return tree_constant (); |
|
1
|
577 retval = do_matrix_index (i, j); |
|
|
578 } |
|
|
579 break; |
|
|
580 case complex_matrix_constant: |
|
|
581 case matrix_constant: |
|
|
582 { |
|
|
583 Matrix mj = tmp_j.matrix_value (); |
|
|
584 idx_vector jv (mj, user_pref.do_fortran_indexing, "column", nc); |
|
191
|
585 if (! jv) |
|
|
586 return tree_constant (); |
|
|
587 |
|
1
|
588 if (jv.length () == 0) |
|
|
589 { |
|
|
590 Matrix mtmp; |
|
|
591 retval = tree_constant (mtmp); |
|
|
592 } |
|
|
593 else |
|
|
594 { |
|
143
|
595 if (range_max_check (i, jv.max (), nr, nc) < 0) |
|
|
596 return tree_constant (); |
|
1
|
597 retval = do_matrix_index (i, jv); |
|
|
598 } |
|
|
599 } |
|
|
600 break; |
|
|
601 case string_constant: |
|
|
602 gripe_string_invalid (); |
|
|
603 break; |
|
|
604 case range_constant: |
|
|
605 { |
|
|
606 Range rj = tmp_j.range_value (); |
|
|
607 if (nc == 2 && is_zero_one (rj)) |
|
|
608 { |
|
|
609 retval = do_matrix_index (i, 1); |
|
|
610 } |
|
212
|
611 else if (nc == 2 && is_one_zero (rj)) |
|
|
612 { |
|
|
613 retval = do_matrix_index (i, 0); |
|
|
614 } |
|
1
|
615 else |
|
|
616 { |
|
212
|
617 if (index_check (rj, "column") < 0) |
|
143
|
618 return tree_constant (); |
|
212
|
619 if (range_max_check (i, tree_to_mat_idx (rj.max ()), nr, nc) < 0) |
|
143
|
620 return tree_constant (); |
|
1
|
621 retval = do_matrix_index (i, rj); |
|
|
622 } |
|
|
623 } |
|
|
624 break; |
|
|
625 case magic_colon: |
|
143
|
626 if (range_max_check (i, 0, nr, nc) < 0) |
|
|
627 return tree_constant (); |
|
1
|
628 retval = do_matrix_index (i, magic_colon); |
|
|
629 break; |
|
|
630 default: |
|
|
631 panic_impossible (); |
|
|
632 break; |
|
|
633 } |
|
|
634 |
|
|
635 return retval; |
|
|
636 } |
|
|
637 |
|
|
638 tree_constant |
|
164
|
639 tree_constant_rep::do_matrix_index (const idx_vector& iv, |
|
|
640 const tree_constant& j_arg) const |
|
1
|
641 { |
|
|
642 tree_constant retval; |
|
|
643 |
|
|
644 tree_constant tmp_j = j_arg.make_numeric_or_range_or_magic (); |
|
|
645 |
|
|
646 tree_constant_rep::constant_type jtype = tmp_j.const_type (); |
|
|
647 |
|
|
648 int nr = rows (); |
|
|
649 int nc = columns (); |
|
|
650 |
|
|
651 switch (jtype) |
|
|
652 { |
|
|
653 case complex_scalar_constant: |
|
|
654 case scalar_constant: |
|
|
655 { |
|
|
656 int j = tree_to_mat_idx (tmp_j.double_value ()); |
|
143
|
657 if (index_check (j, "column") < 0) |
|
|
658 return tree_constant (); |
|
|
659 if (range_max_check (iv.max (), j, nr, nc) < 0) |
|
|
660 return tree_constant (); |
|
1
|
661 retval = do_matrix_index (iv, j); |
|
|
662 } |
|
|
663 break; |
|
|
664 case complex_matrix_constant: |
|
|
665 case matrix_constant: |
|
|
666 { |
|
|
667 Matrix mj = tmp_j.matrix_value (); |
|
|
668 idx_vector jv (mj, user_pref.do_fortran_indexing, "column", nc); |
|
191
|
669 if (! jv) |
|
|
670 return tree_constant (); |
|
|
671 |
|
1
|
672 if (jv.length () == 0) |
|
|
673 { |
|
|
674 Matrix mtmp; |
|
|
675 retval = tree_constant (mtmp); |
|
|
676 } |
|
|
677 else |
|
|
678 { |
|
143
|
679 if (range_max_check (iv.max (), jv.max (), nr, nc) < 0) |
|
|
680 return tree_constant (); |
|
1
|
681 retval = do_matrix_index (iv, jv); |
|
|
682 } |
|
|
683 } |
|
|
684 break; |
|
|
685 case string_constant: |
|
|
686 gripe_string_invalid (); |
|
|
687 break; |
|
|
688 case range_constant: |
|
|
689 { |
|
|
690 Range rj = tmp_j.range_value (); |
|
|
691 if (nc == 2 && is_zero_one (rj)) |
|
|
692 { |
|
|
693 retval = do_matrix_index (iv, 1); |
|
|
694 } |
|
212
|
695 else if (nc == 2 && is_one_zero (rj)) |
|
|
696 { |
|
|
697 retval = do_matrix_index (iv, 0); |
|
|
698 } |
|
1
|
699 else |
|
|
700 { |
|
212
|
701 if (index_check (rj, "column") < 0) |
|
143
|
702 return tree_constant (); |
|
212
|
703 if (range_max_check (iv.max (), tree_to_mat_idx (rj.max ()), |
|
|
704 nr, nc) < 0) |
|
143
|
705 return tree_constant (); |
|
1
|
706 retval = do_matrix_index (iv, rj); |
|
|
707 } |
|
|
708 } |
|
|
709 break; |
|
|
710 case magic_colon: |
|
143
|
711 if (range_max_check (iv.max (), 0, nr, nc) < 0) |
|
|
712 return tree_constant (); |
|
1
|
713 retval = do_matrix_index (iv, magic_colon); |
|
|
714 break; |
|
|
715 default: |
|
|
716 panic_impossible (); |
|
|
717 break; |
|
|
718 } |
|
|
719 |
|
|
720 return retval; |
|
|
721 } |
|
|
722 |
|
|
723 tree_constant |
|
212
|
724 tree_constant_rep::do_matrix_index (const Range& ri, |
|
164
|
725 const tree_constant& j_arg) const |
|
1
|
726 { |
|
|
727 tree_constant retval; |
|
|
728 |
|
|
729 tree_constant tmp_j = j_arg.make_numeric_or_range_or_magic (); |
|
|
730 |
|
|
731 tree_constant_rep::constant_type jtype = tmp_j.const_type (); |
|
|
732 |
|
|
733 int nr = rows (); |
|
|
734 int nc = columns (); |
|
|
735 |
|
|
736 switch (jtype) |
|
|
737 { |
|
|
738 case complex_scalar_constant: |
|
|
739 case scalar_constant: |
|
|
740 { |
|
|
741 int j = tree_to_mat_idx (tmp_j.double_value ()); |
|
143
|
742 if (index_check (j, "column") < 0) |
|
|
743 return tree_constant (); |
|
212
|
744 if (range_max_check (tree_to_mat_idx (ri.max ()), j, nr, nc) < 0) |
|
143
|
745 return tree_constant (); |
|
1
|
746 retval = do_matrix_index (ri, j); |
|
|
747 } |
|
|
748 break; |
|
|
749 case complex_matrix_constant: |
|
|
750 case matrix_constant: |
|
|
751 { |
|
|
752 Matrix mj = tmp_j.matrix_value (); |
|
|
753 idx_vector jv (mj, user_pref.do_fortran_indexing, "column", nc); |
|
191
|
754 if (! jv) |
|
|
755 return tree_constant (); |
|
|
756 |
|
1
|
757 if (jv.length () == 0) |
|
|
758 { |
|
|
759 Matrix mtmp; |
|
|
760 retval = tree_constant (mtmp); |
|
|
761 } |
|
|
762 else |
|
|
763 { |
|
212
|
764 if (range_max_check (tree_to_mat_idx (ri.max ()), |
|
|
765 jv.max (), nr, nc) < 0) |
|
143
|
766 return tree_constant (); |
|
1
|
767 retval = do_matrix_index (ri, jv); |
|
|
768 } |
|
|
769 } |
|
|
770 break; |
|
|
771 case string_constant: |
|
|
772 gripe_string_invalid (); |
|
|
773 break; |
|
|
774 case range_constant: |
|
|
775 { |
|
|
776 Range rj = tmp_j.range_value (); |
|
|
777 if (nc == 2 && is_zero_one (rj)) |
|
|
778 { |
|
|
779 retval = do_matrix_index (ri, 1); |
|
|
780 } |
|
212
|
781 else if (nc == 2 && is_one_zero (rj)) |
|
|
782 { |
|
|
783 retval = do_matrix_index (ri, 0); |
|
|
784 } |
|
1
|
785 else |
|
|
786 { |
|
212
|
787 if (index_check (rj, "column") < 0) |
|
143
|
788 return tree_constant (); |
|
212
|
789 if (range_max_check (tree_to_mat_idx (ri.max ()), |
|
|
790 tree_to_mat_idx (rj.max ()), nr, nc) < 0) |
|
143
|
791 return tree_constant (); |
|
1
|
792 retval = do_matrix_index (ri, rj); |
|
|
793 } |
|
|
794 } |
|
|
795 break; |
|
|
796 case magic_colon: |
|
|
797 retval = do_matrix_index (ri, magic_colon); |
|
|
798 break; |
|
|
799 default: |
|
|
800 panic_impossible (); |
|
|
801 break; |
|
|
802 } |
|
|
803 |
|
|
804 return retval; |
|
|
805 } |
|
|
806 |
|
|
807 tree_constant |
|
|
808 tree_constant_rep::do_matrix_index (tree_constant_rep::constant_type mci, |
|
164
|
809 const tree_constant& j_arg) const |
|
1
|
810 { |
|
|
811 tree_constant retval; |
|
|
812 |
|
|
813 tree_constant tmp_j = j_arg.make_numeric_or_range_or_magic (); |
|
|
814 |
|
|
815 tree_constant_rep::constant_type jtype = tmp_j.const_type (); |
|
|
816 |
|
|
817 int nr = rows (); |
|
|
818 int nc = columns (); |
|
|
819 |
|
|
820 switch (jtype) |
|
|
821 { |
|
|
822 case complex_scalar_constant: |
|
|
823 case scalar_constant: |
|
|
824 { |
|
|
825 int j = tree_to_mat_idx (tmp_j.double_value ()); |
|
143
|
826 if (index_check (j, "column") < 0) |
|
|
827 return tree_constant (); |
|
|
828 if (range_max_check (0, j, nr, nc) < 0) |
|
|
829 return tree_constant (); |
|
1
|
830 retval = do_matrix_index (magic_colon, j); |
|
|
831 } |
|
|
832 break; |
|
|
833 case complex_matrix_constant: |
|
|
834 case matrix_constant: |
|
|
835 { |
|
|
836 Matrix mj = tmp_j.matrix_value (); |
|
|
837 idx_vector jv (mj, user_pref.do_fortran_indexing, "column", nc); |
|
191
|
838 if (! jv) |
|
|
839 return tree_constant (); |
|
|
840 |
|
1
|
841 if (jv.length () == 0) |
|
|
842 { |
|
|
843 Matrix mtmp; |
|
|
844 retval = tree_constant (mtmp); |
|
|
845 } |
|
|
846 else |
|
|
847 { |
|
143
|
848 if (range_max_check (0, jv.max (), nr, nc) < 0) |
|
|
849 return tree_constant (); |
|
1
|
850 retval = do_matrix_index (magic_colon, jv); |
|
|
851 } |
|
|
852 } |
|
|
853 break; |
|
|
854 case string_constant: |
|
|
855 gripe_string_invalid (); |
|
|
856 break; |
|
|
857 case range_constant: |
|
|
858 { |
|
|
859 Range rj = tmp_j.range_value (); |
|
|
860 if (nc == 2 && is_zero_one (rj)) |
|
|
861 { |
|
|
862 retval = do_matrix_index (magic_colon, 1); |
|
|
863 } |
|
212
|
864 else if (nc == 2 && is_one_zero (rj)) |
|
|
865 { |
|
|
866 retval = do_matrix_index (magic_colon, 0); |
|
|
867 } |
|
1
|
868 else |
|
|
869 { |
|
212
|
870 if (index_check (rj, "column") < 0) |
|
143
|
871 return tree_constant (); |
|
212
|
872 if (range_max_check (0, tree_to_mat_idx (rj.max ()), nr, nc) < 0) |
|
143
|
873 return tree_constant (); |
|
1
|
874 retval = do_matrix_index (magic_colon, rj); |
|
|
875 } |
|
|
876 } |
|
|
877 break; |
|
|
878 case magic_colon: |
|
|
879 retval = do_matrix_index (magic_colon, magic_colon); |
|
|
880 break; |
|
|
881 default: |
|
|
882 panic_impossible (); |
|
|
883 break; |
|
|
884 } |
|
|
885 |
|
|
886 return retval; |
|
|
887 } |
|
|
888 |
|
|
889 tree_constant |
|
164
|
890 tree_constant_rep::do_matrix_index (int i, int j) const |
|
1
|
891 { |
|
|
892 tree_constant retval; |
|
|
893 |
|
|
894 if (type_tag == matrix_constant) |
|
|
895 retval = tree_constant (matrix->elem (i, j)); |
|
|
896 else |
|
|
897 retval = tree_constant (complex_matrix->elem (i, j)); |
|
|
898 |
|
|
899 return retval; |
|
|
900 } |
|
|
901 |
|
|
902 tree_constant |
|
164
|
903 tree_constant_rep::do_matrix_index (int i, const idx_vector& jv) const |
|
1
|
904 { |
|
|
905 tree_constant retval; |
|
|
906 |
|
|
907 int jlen = jv.capacity (); |
|
|
908 |
|
|
909 CRMATRIX (m, cm, 1, jlen); |
|
|
910 |
|
|
911 for (int j = 0; j < jlen; j++) |
|
|
912 { |
|
|
913 int col = jv.elem (j); |
|
|
914 CRMATRIX_ASSIGN_REP_ELEM (m, cm, 0, j, i, col); |
|
|
915 } |
|
|
916 ASSIGN_CRMATRIX_TO (retval, m, cm); |
|
|
917 |
|
|
918 return retval; |
|
|
919 } |
|
|
920 |
|
|
921 tree_constant |
|
164
|
922 tree_constant_rep::do_matrix_index (int i, const Range& rj) const |
|
1
|
923 { |
|
|
924 tree_constant retval; |
|
|
925 |
|
|
926 int jlen = rj.nelem (); |
|
|
927 |
|
|
928 CRMATRIX (m, cm, 1, jlen); |
|
|
929 |
|
|
930 double b = rj.base (); |
|
|
931 double increment = rj.inc (); |
|
|
932 for (int j = 0; j < jlen; j++) |
|
|
933 { |
|
|
934 double tmp = b + j * increment; |
|
|
935 int col = tree_to_mat_idx (tmp); |
|
|
936 CRMATRIX_ASSIGN_REP_ELEM (m, cm, 0, j, i, col); |
|
|
937 } |
|
|
938 |
|
|
939 ASSIGN_CRMATRIX_TO (retval, m, cm); |
|
|
940 |
|
|
941 return retval; |
|
|
942 } |
|
|
943 |
|
|
944 tree_constant |
|
164
|
945 tree_constant_rep::do_matrix_index |
|
|
946 (int i, tree_constant_rep::constant_type mcj) const |
|
1
|
947 { |
|
|
948 assert (mcj == magic_colon); |
|
|
949 |
|
|
950 tree_constant retval; |
|
|
951 |
|
|
952 int nc = columns (); |
|
|
953 |
|
|
954 CRMATRIX (m, cm, 1, nc); |
|
|
955 |
|
|
956 for (int j = 0; j < nc; j++) |
|
|
957 { |
|
|
958 CRMATRIX_ASSIGN_REP_ELEM (m, cm, 0, j, i, j); |
|
|
959 } |
|
|
960 |
|
|
961 ASSIGN_CRMATRIX_TO (retval, m, cm); |
|
|
962 |
|
|
963 return retval; |
|
|
964 } |
|
|
965 |
|
|
966 tree_constant |
|
164
|
967 tree_constant_rep::do_matrix_index (const idx_vector& iv, int j) const |
|
1
|
968 { |
|
|
969 tree_constant retval; |
|
|
970 |
|
|
971 int ilen = iv.capacity (); |
|
|
972 |
|
|
973 CRMATRIX (m, cm, ilen, 1); |
|
|
974 |
|
|
975 for (int i = 0; i < ilen; i++) |
|
|
976 { |
|
|
977 int row = iv.elem (i); |
|
|
978 CRMATRIX_ASSIGN_REP_ELEM (m, cm, i, 0, row, j); |
|
|
979 } |
|
|
980 |
|
|
981 ASSIGN_CRMATRIX_TO (retval, m, cm); |
|
|
982 |
|
|
983 return retval; |
|
|
984 } |
|
|
985 |
|
|
986 tree_constant |
|
164
|
987 tree_constant_rep::do_matrix_index (const idx_vector& iv, |
|
|
988 const idx_vector& jv) const |
|
1
|
989 { |
|
|
990 tree_constant retval; |
|
|
991 |
|
|
992 int ilen = iv.capacity (); |
|
|
993 int jlen = jv.capacity (); |
|
|
994 |
|
|
995 CRMATRIX (m, cm, ilen, jlen); |
|
|
996 |
|
|
997 for (int i = 0; i < ilen; i++) |
|
|
998 { |
|
|
999 int row = iv.elem (i); |
|
|
1000 for (int j = 0; j < jlen; j++) |
|
|
1001 { |
|
|
1002 int col = jv.elem (j); |
|
|
1003 CRMATRIX_ASSIGN_REP_ELEM (m, cm, i, j, row, col); |
|
|
1004 } |
|
|
1005 } |
|
|
1006 |
|
|
1007 ASSIGN_CRMATRIX_TO (retval, m, cm); |
|
|
1008 |
|
|
1009 return retval; |
|
|
1010 } |
|
|
1011 |
|
|
1012 tree_constant |
|
164
|
1013 tree_constant_rep::do_matrix_index (const idx_vector& iv, |
|
|
1014 const Range& rj) const |
|
1
|
1015 { |
|
|
1016 tree_constant retval; |
|
|
1017 |
|
|
1018 int ilen = iv.capacity (); |
|
|
1019 int jlen = rj.nelem (); |
|
|
1020 |
|
|
1021 CRMATRIX (m, cm, ilen, jlen); |
|
|
1022 |
|
|
1023 double b = rj.base (); |
|
|
1024 double increment = rj.inc (); |
|
|
1025 |
|
|
1026 for (int i = 0; i < ilen; i++) |
|
|
1027 { |
|
|
1028 int row = iv.elem (i); |
|
|
1029 for (int j = 0; j < jlen; j++) |
|
|
1030 { |
|
|
1031 double tmp = b + j * increment; |
|
|
1032 int col = tree_to_mat_idx (tmp); |
|
|
1033 CRMATRIX_ASSIGN_REP_ELEM (m, cm, i, j, row, col); |
|
|
1034 } |
|
|
1035 } |
|
|
1036 |
|
|
1037 ASSIGN_CRMATRIX_TO (retval, m, cm); |
|
|
1038 |
|
|
1039 return retval; |
|
|
1040 } |
|
|
1041 |
|
|
1042 tree_constant |
|
164
|
1043 tree_constant_rep::do_matrix_index |
|
|
1044 (const idx_vector& iv, tree_constant_rep::constant_type mcj) const |
|
1
|
1045 { |
|
|
1046 assert (mcj == magic_colon); |
|
|
1047 |
|
|
1048 tree_constant retval; |
|
|
1049 |
|
|
1050 int nc = columns (); |
|
|
1051 int ilen = iv.capacity (); |
|
|
1052 |
|
|
1053 CRMATRIX (m, cm, ilen, nc); |
|
|
1054 |
|
|
1055 for (int j = 0; j < nc; j++) |
|
|
1056 { |
|
|
1057 for (int i = 0; i < ilen; i++) |
|
|
1058 { |
|
|
1059 int row = iv.elem (i); |
|
|
1060 CRMATRIX_ASSIGN_REP_ELEM (m, cm, i, j, row, j); |
|
|
1061 } |
|
|
1062 } |
|
|
1063 |
|
|
1064 ASSIGN_CRMATRIX_TO (retval, m, cm); |
|
|
1065 |
|
|
1066 return retval; |
|
|
1067 } |
|
|
1068 |
|
|
1069 tree_constant |
|
164
|
1070 tree_constant_rep::do_matrix_index (const Range& ri, int j) const |
|
1
|
1071 { |
|
|
1072 tree_constant retval; |
|
|
1073 |
|
|
1074 int ilen = ri.nelem (); |
|
|
1075 |
|
|
1076 CRMATRIX (m, cm, ilen, 1); |
|
|
1077 |
|
|
1078 double b = ri.base (); |
|
|
1079 double increment = ri.inc (); |
|
|
1080 for (int i = 0; i < ilen; i++) |
|
|
1081 { |
|
|
1082 double tmp = b + i * increment; |
|
|
1083 int row = tree_to_mat_idx (tmp); |
|
|
1084 CRMATRIX_ASSIGN_REP_ELEM (m, cm, i, 0, row, j); |
|
|
1085 } |
|
|
1086 |
|
|
1087 ASSIGN_CRMATRIX_TO (retval, m, cm); |
|
|
1088 |
|
|
1089 return retval; |
|
|
1090 } |
|
|
1091 |
|
|
1092 tree_constant |
|
164
|
1093 tree_constant_rep::do_matrix_index (const Range& ri, |
|
|
1094 const idx_vector& jv) const |
|
1
|
1095 { |
|
|
1096 tree_constant retval; |
|
|
1097 |
|
|
1098 int ilen = ri.nelem (); |
|
|
1099 int jlen = jv.capacity (); |
|
|
1100 |
|
|
1101 CRMATRIX (m, cm, ilen, jlen); |
|
|
1102 |
|
|
1103 double b = ri.base (); |
|
|
1104 double increment = ri.inc (); |
|
|
1105 for (int i = 0; i < ilen; i++) |
|
|
1106 { |
|
|
1107 double tmp = b + i * increment; |
|
|
1108 int row = tree_to_mat_idx (tmp); |
|
|
1109 for (int j = 0; j < jlen; j++) |
|
|
1110 { |
|
|
1111 int col = jv.elem (j); |
|
|
1112 CRMATRIX_ASSIGN_REP_ELEM (m, cm, i, j, row, col); |
|
|
1113 } |
|
|
1114 } |
|
|
1115 |
|
|
1116 ASSIGN_CRMATRIX_TO (retval, m, cm); |
|
|
1117 |
|
|
1118 return retval; |
|
|
1119 } |
|
|
1120 |
|
|
1121 tree_constant |
|
164
|
1122 tree_constant_rep::do_matrix_index (const Range& ri, const Range& rj) const |
|
1
|
1123 { |
|
|
1124 tree_constant retval; |
|
|
1125 |
|
|
1126 int ilen = ri.nelem (); |
|
|
1127 int jlen = rj.nelem (); |
|
|
1128 |
|
|
1129 CRMATRIX (m, cm, ilen, jlen); |
|
|
1130 |
|
|
1131 double ib = ri.base (); |
|
|
1132 double iinc = ri.inc (); |
|
|
1133 double jb = rj.base (); |
|
|
1134 double jinc = rj.inc (); |
|
|
1135 |
|
|
1136 for (int i = 0; i < ilen; i++) |
|
|
1137 { |
|
|
1138 double itmp = ib + i * iinc; |
|
|
1139 int row = tree_to_mat_idx (itmp); |
|
|
1140 for (int j = 0; j < jlen; j++) |
|
|
1141 { |
|
|
1142 double jtmp = jb + j * jinc; |
|
|
1143 int col = tree_to_mat_idx (jtmp); |
|
|
1144 |
|
|
1145 CRMATRIX_ASSIGN_REP_ELEM (m, cm, i, j, row, col); |
|
|
1146 } |
|
|
1147 } |
|
|
1148 |
|
|
1149 ASSIGN_CRMATRIX_TO (retval, m, cm); |
|
|
1150 |
|
|
1151 return retval; |
|
|
1152 } |
|
|
1153 |
|
|
1154 tree_constant |
|
164
|
1155 tree_constant_rep::do_matrix_index |
|
|
1156 (const Range& ri, tree_constant_rep::constant_type mcj) const |
|
1
|
1157 { |
|
|
1158 assert (mcj == magic_colon); |
|
|
1159 |
|
|
1160 tree_constant retval; |
|
|
1161 |
|
|
1162 int nc = columns (); |
|
|
1163 |
|
|
1164 int ilen = ri.nelem (); |
|
|
1165 |
|
|
1166 CRMATRIX (m, cm, ilen, nc); |
|
|
1167 |
|
|
1168 double ib = ri.base (); |
|
|
1169 double iinc = ri.inc (); |
|
|
1170 |
|
|
1171 for (int i = 0; i < ilen; i++) |
|
|
1172 { |
|
|
1173 double itmp = ib + i * iinc; |
|
|
1174 int row = tree_to_mat_idx (itmp); |
|
|
1175 for (int j = 0; j < nc; j++) |
|
|
1176 { |
|
|
1177 CRMATRIX_ASSIGN_REP_ELEM (m, cm, i, j, row, j); |
|
|
1178 } |
|
|
1179 } |
|
|
1180 |
|
|
1181 ASSIGN_CRMATRIX_TO (retval, m, cm); |
|
|
1182 |
|
|
1183 return retval; |
|
|
1184 } |
|
|
1185 |
|
|
1186 tree_constant |
|
|
1187 tree_constant_rep::do_matrix_index (tree_constant_rep::constant_type mci, |
|
164
|
1188 int j) const |
|
1
|
1189 { |
|
|
1190 assert (mci == magic_colon); |
|
|
1191 |
|
|
1192 tree_constant retval; |
|
|
1193 |
|
|
1194 int nr = rows (); |
|
|
1195 |
|
|
1196 CRMATRIX (m, cm, nr, 1); |
|
|
1197 |
|
|
1198 for (int i = 0; i < nr; i++) |
|
|
1199 { |
|
|
1200 CRMATRIX_ASSIGN_REP_ELEM (m, cm, i, 0, i, j); |
|
|
1201 } |
|
|
1202 |
|
|
1203 ASSIGN_CRMATRIX_TO (retval, m, cm); |
|
|
1204 |
|
|
1205 return retval; |
|
|
1206 } |
|
|
1207 |
|
|
1208 tree_constant |
|
|
1209 tree_constant_rep::do_matrix_index (tree_constant_rep::constant_type mci, |
|
164
|
1210 const idx_vector& jv) const |
|
1
|
1211 { |
|
|
1212 assert (mci == magic_colon); |
|
|
1213 |
|
|
1214 tree_constant retval; |
|
|
1215 |
|
|
1216 int nr = rows (); |
|
|
1217 int jlen = jv.capacity (); |
|
|
1218 |
|
|
1219 CRMATRIX (m, cm, nr, jlen); |
|
|
1220 |
|
|
1221 for (int i = 0; i < nr; i++) |
|
|
1222 { |
|
|
1223 for (int j = 0; j < jlen; j++) |
|
|
1224 { |
|
|
1225 int col = jv.elem (j); |
|
|
1226 CRMATRIX_ASSIGN_REP_ELEM (m, cm, i, j, i, col); |
|
|
1227 } |
|
|
1228 } |
|
|
1229 |
|
|
1230 ASSIGN_CRMATRIX_TO (retval, m, cm); |
|
|
1231 |
|
|
1232 return retval; |
|
|
1233 } |
|
|
1234 |
|
|
1235 tree_constant |
|
|
1236 tree_constant_rep::do_matrix_index (tree_constant_rep::constant_type mci, |
|
164
|
1237 const Range& rj) const |
|
1
|
1238 { |
|
|
1239 assert (mci == magic_colon); |
|
|
1240 |
|
|
1241 tree_constant retval; |
|
|
1242 |
|
|
1243 int nr = rows (); |
|
|
1244 int jlen = rj.nelem (); |
|
|
1245 |
|
|
1246 CRMATRIX (m, cm, nr, jlen); |
|
|
1247 |
|
|
1248 double jb = rj.base (); |
|
|
1249 double jinc = rj.inc (); |
|
|
1250 |
|
|
1251 for (int j = 0; j < jlen; j++) |
|
|
1252 { |
|
|
1253 double jtmp = jb + j * jinc; |
|
|
1254 int col = tree_to_mat_idx (jtmp); |
|
|
1255 for (int i = 0; i < nr; i++) |
|
|
1256 { |
|
|
1257 CRMATRIX_ASSIGN_REP_ELEM (m, cm, i, j, i, col); |
|
|
1258 } |
|
|
1259 } |
|
|
1260 |
|
|
1261 ASSIGN_CRMATRIX_TO (retval, m, cm); |
|
|
1262 |
|
|
1263 return retval; |
|
|
1264 } |
|
|
1265 |
|
|
1266 tree_constant |
|
|
1267 tree_constant_rep::do_matrix_index (tree_constant_rep::constant_type mci, |
|
164
|
1268 tree_constant_rep::constant_type mcj) const |
|
1
|
1269 { |
|
|
1270 assert (mci == magic_colon && mcj == magic_colon); |
|
|
1271 |
|
|
1272 return tree_constant (*this); |
|
|
1273 } |
|
|
1274 |
|
|
1275 tree_constant |
|
164
|
1276 tree_constant_rep::do_matrix_index |
|
|
1277 (tree_constant_rep::constant_type mci) const |
|
1
|
1278 { |
|
|
1279 assert (mci == magic_colon); |
|
|
1280 |
|
|
1281 tree_constant retval; |
|
|
1282 int nr = rows (); |
|
|
1283 int nc = columns (); |
|
|
1284 int size = nr * nc; |
|
|
1285 if (size > 0) |
|
|
1286 { |
|
|
1287 CRMATRIX (m, cm, size, 1); |
|
|
1288 int idx = 0; |
|
|
1289 for (int j = 0; j < nc; j++) |
|
|
1290 for (int i = 0; i < nr; i++) |
|
|
1291 { |
|
|
1292 CRMATRIX_ASSIGN_REP_ELEM (m, cm, idx, 0, i, j); |
|
|
1293 idx++; |
|
|
1294 } |
|
|
1295 ASSIGN_CRMATRIX_TO (retval, m, cm); |
|
|
1296 } |
|
|
1297 return retval; |
|
|
1298 } |
|
|
1299 |
|
|
1300 /* |
|
|
1301 ;;; Local Variables: *** |
|
|
1302 ;;; mode: C++ *** |
|
|
1303 ;;; page-delimiter: "^/\\*" *** |
|
|
1304 ;;; End: *** |
|
|
1305 */ |
|
|
1306 |
