Context Navigation

source: XMLIO_V2/external/include/blitz/array/resize.cc @ 80

Last change on this file since 80 was 80, checked in by ymipsl, 14 years ago
ajout lib externe
File size: 34.5 KB

Line
1	/***************************************************************************
2	* blitz/array/resize.cc Resizing of arrays
3	*
4	* Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
5	*
6	* This program is free software; you can redistribute it and/or
7	* modify it under the terms of the GNU General Public License
8	* as published by the Free Software Foundation; either version 2
9	* of the License, or (at your option) any later version.
10	*
11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* Suggestions: blitz-dev@oonumerics.org
17	* Bugs: blitz-bugs@oonumerics.org
18	*
19	* For more information, please see the Blitz++ Home Page:
20	* http://oonumerics.org/blitz/
21	*
22	****************************************************************************/
23	#ifndef BZ_ARRAYRESIZE_CC
24	#define BZ_ARRAYRESIZE_CC
25
26	#ifndef BZ_ARRAY_H
27	#error <blitz/array/resize.cc> must be included via <blitz/array.h>
28	#endif
29
30	#include <blitz/minmax.h>
31
32	BZ_NAMESPACE(blitz)
33
34	template<typename T_numtype, int N_rank>
35	void Array<T_numtype, N_rank>::resize(int extent0)
36	{
37	BZPRECONDITION(extent0 >= 0);
38	BZPRECONDITION(N_rank == 1);
39
40	if (extent0 != length_[0])
41	{
42	length_[0] = extent0;
43	setupStorage(0);
44	}
45	}
46
47	template<typename T_numtype, int N_rank>
48	void Array<T_numtype, N_rank>::resize(int extent0, int extent1)
49	{
50	BZPRECONDITION((extent0 >= 0) && (extent1 >= 0));
51	BZPRECONDITION(N_rank == 2);
52
53	if ((extent0 != length_[0]) \|\| (extent1 != length_[1]))
54	{
55	length_[0] = extent0;
56	length_[1] = extent1;
57	setupStorage(1);
58	}
59	}
60
61	template<typename T_numtype, int N_rank>
62	void Array<T_numtype, N_rank>::resize(int extent0, int extent1,
63	int extent2)
64	{
65	BZPRECONDITION((extent0 >= 0) && (extent1 >= 0) && (extent2 >= 0));
66	BZPRECONDITION(N_rank == 3);
67
68	if ((extent0 != length_[0]) \|\| (extent1 != length_[1])
69	\|\| (extent2 != length_[2]))
70	{
71	length_[0] = extent0;
72	length_[1] = extent1;
73	length_[2] = extent2;
74	setupStorage(2);
75	}
76	}
77
78
79	template<typename T_numtype, int N_rank>
80	void Array<T_numtype, N_rank>::resize(int extent0, int extent1,
81	int extent2, int extent3)
82	{
83	BZPRECONDITION((extent0 >= 0) && (extent1 >= 0) && (extent2 >= 0)
84	&& (extent3 >= 0));
85	BZPRECONDITION(N_rank == 4);
86
87	if ((extent0 != length_[0]) \|\| (extent1 != length_[1])
88	\|\| (extent2 != length_[2]) \|\| (extent3 != length_[3]))
89	{
90	length_[0] = extent0;
91	length_[1] = extent1;
92	length_[2] = extent2;
93	length_[3] = extent3;
94	setupStorage(3);
95	}
96	}
97
98	template<typename T_numtype, int N_rank>
99	void Array<T_numtype, N_rank>::resize(int extent0, int extent1,
100	int extent2, int extent3, int extent4)
101	{
102	BZPRECONDITION((extent0 >= 0) && (extent1 >= 0) && (extent2 >= 0)
103	&& (extent3 >= 0) && (extent4 >= 0));
104	BZPRECONDITION(N_rank == 5);
105
106	if ((extent0 != length_[0]) \|\| (extent1 != length_[1])
107	\|\| (extent2 != length_[2]) \|\| (extent3 != length_[3])
108	\|\| (extent4 != length_[4]))
109	{
110	length_[0] = extent0;
111	length_[1] = extent1;
112	length_[2] = extent2;
113	length_[3] = extent3;
114	length_[4] = extent4;
115	setupStorage(4);
116	}
117	}
118
119	template<typename T_numtype, int N_rank>
120	void Array<T_numtype, N_rank>::resize(int extent0, int extent1,
121	int extent2, int extent3, int extent4, int extent5)
122	{
123	BZPRECONDITION((extent0 >= 0) && (extent1 >= 0) && (extent2 >= 0)
124	&& (extent3 >= 0) && (extent4 >= 0) && (extent5 >= 0));
125	BZPRECONDITION(N_rank == 6);
126
127	if ((extent0 != length_[0]) \|\| (extent1 != length_[1])
128	\|\| (extent2 != length_[2]) \|\| (extent3 != length_[3])
129	\|\| (extent4 != length_[4]) \|\| (extent5 != length_[5]))
130	{
131	length_[0] = extent0;
132	length_[1] = extent1;
133	length_[2] = extent2;
134	length_[3] = extent3;
135	length_[4] = extent4;
136	length_[5] = extent5;
137	setupStorage(5);
138	}
139	}
140
141	template<typename T_numtype, int N_rank>
142	void Array<T_numtype, N_rank>::resize(int extent0, int extent1,
143	int extent2, int extent3, int extent4, int extent5,
144	int extent6)
145	{
146	BZPRECONDITION((extent0 >= 0) && (extent1 >= 0) && (extent2 >= 0)
147	&& (extent3 >= 0) && (extent4 >= 0) && (extent5 >= 0)
148	&& (extent6 >= 0));
149	BZPRECONDITION(N_rank == 7);
150
151	if ((extent0 != length_[0]) \|\| (extent1 != length_[1])
152	\|\| (extent2 != length_[2]) \|\| (extent3 != length_[3])
153	\|\| (extent4 != length_[4]) \|\| (extent5 != length_[5])
154	\|\| (extent6 != length_[6]))
155	{
156	length_[0] = extent0;
157	length_[1] = extent1;
158	length_[2] = extent2;
159	length_[3] = extent3;
160	length_[4] = extent4;
161	length_[5] = extent5;
162	length_[6] = extent6;
163	setupStorage(6);
164	}
165	}
166
167	template<typename T_numtype, int N_rank>
168	void Array<T_numtype, N_rank>::resize(int extent0, int extent1,
169	int extent2, int extent3, int extent4, int extent5,
170	int extent6, int extent7)
171	{
172	BZPRECONDITION((extent0 >= 0) && (extent1 >= 0) && (extent2 >= 0)
173	&& (extent3 >= 0) && (extent4 >= 0) && (extent5 >= 0)
174	&& (extent6 >= 0) && (extent7 >= 0));
175	BZPRECONDITION(N_rank == 8);
176
177	if ((extent0 != length_[0]) \|\| (extent1 != length_[1])
178	\|\| (extent2 != length_[2]) \|\| (extent3 != length_[3])
179	\|\| (extent4 != length_[4]) \|\| (extent5 != length_[5])
180	\|\| (extent6 != length_[6]) \|\| (extent7 != length_[7]))
181	{
182	length_[0] = extent0;
183	length_[1] = extent1;
184	length_[2] = extent2;
185	length_[3] = extent3;
186	length_[4] = extent4;
187	length_[5] = extent5;
188	length_[6] = extent6;
189	length_[7] = extent7;
190	setupStorage(7);
191	}
192	}
193
194	template<typename T_numtype, int N_rank>
195	void Array<T_numtype, N_rank>::resize(int extent0, int extent1,
196	int extent2, int extent3, int extent4, int extent5,
197	int extent6, int extent7, int extent8)
198	{
199	BZPRECONDITION((extent0 >= 0) && (extent1 >= 0) && (extent2 >= 0)
200	&& (extent3 >= 0) && (extent4 >= 0) && (extent5 >= 0)
201	&& (extent6 >= 0) && (extent7 >= 0) && (extent8 >= 0));
202	BZPRECONDITION(N_rank == 9);
203
204	if ((extent0 != length_[0]) \|\| (extent1 != length_[1])
205	\|\| (extent2 != length_[2]) \|\| (extent3 != length_[3])
206	\|\| (extent4 != length_[4]) \|\| (extent5 != length_[5])
207	\|\| (extent6 != length_[6]) \|\| (extent7 != length_[7])
208	\|\| (extent8 != length_[8]))
209	{
210	length_[0] = extent0;
211	length_[1] = extent1;
212	length_[2] = extent2;
213	length_[3] = extent3;
214	length_[4] = extent4;
215	length_[5] = extent5;
216	length_[6] = extent6;
217	length_[7] = extent7;
218	length_[8] = extent8;
219	setupStorage(8);
220	}
221	}
222
223
224	template<typename T_numtype, int N_rank>
225	void Array<T_numtype, N_rank>::resize(int extent0, int extent1,
226	int extent2, int extent3, int extent4, int extent5,
227	int extent6, int extent7, int extent8, int extent9)
228	{
229	BZPRECONDITION((extent0 >= 0) && (extent1 >= 0) && (extent2 >= 0)
230	&& (extent3 >= 0) && (extent4 >= 0) && (extent5 >= 0)
231	&& (extent6 >= 0) && (extent7 >= 0) && (extent8 >= 0)
232	&& (extent9 >= 0));
233	BZPRECONDITION(N_rank == 10);
234
235	if ((extent0 != length_[0]) \|\| (extent1 != length_[1])
236	\|\| (extent2 != length_[2]) \|\| (extent3 != length_[3])
237	\|\| (extent4 != length_[4]) \|\| (extent5 != length_[5])
238	\|\| (extent6 != length_[6]) \|\| (extent7 != length_[7])
239	\|\| (extent8 != length_[8]) \|\| (extent9 != length_[9]))
240	{
241	length_[0] = extent0;
242	length_[1] = extent1;
243	length_[2] = extent2;
244	length_[3] = extent3;
245	length_[4] = extent4;
246	length_[5] = extent5;
247	length_[6] = extent6;
248	length_[7] = extent7;
249	length_[8] = extent8;
250	length_[9] = extent9;
251	setupStorage(9);
252	}
253	}
254
255	template<typename T_numtype, int N_rank>
256	void Array<T_numtype, N_rank>::resize(int extent0, int extent1,
257	int extent2, int extent3, int extent4, int extent5,
258	int extent6, int extent7, int extent8, int extent9,
259	int extent10)
260	{
261	BZPRECONDITION((extent0 >= 0) && (extent1 >= 0) && (extent2 >= 0)
262	&& (extent3 >= 0) && (extent4 >= 0) && (extent5 >= 0)
263	&& (extent6 >= 0) && (extent7 >= 0) && (extent8 >= 0)
264	&& (extent9 >= 0) && (extent10 >= 0));
265	BZPRECONDITION(N_rank == 11);
266
267	if ((extent0 != length_[0]) \|\| (extent1 != length_[1])
268	\|\| (extent2 != length_[2]) \|\| (extent3 != length_[3])
269	\|\| (extent4 != length_[4]) \|\| (extent5 != length_[5])
270	\|\| (extent6 != length_[6]) \|\| (extent7 != length_[7])
271	\|\| (extent8 != length_[8]) \|\| (extent9 != length_[9])
272	\|\| (extent10 != length_[10]))
273	{
274	length_[0] = extent0;
275	length_[1] = extent1;
276	length_[2] = extent2;
277	length_[3] = extent3;
278	length_[4] = extent4;
279	length_[5] = extent5;
280	length_[6] = extent6;
281	length_[7] = extent7;
282	length_[8] = extent8;
283	length_[9] = extent9;
284	length_[10] = extent10;
285	setupStorage(10);
286	}
287	}
288
289
290	template<typename T_numtype, int N_rank>
291	void Array<T_numtype, N_rank>::resize(Range r0)
292	{
293	BZPRECONDITION(r0.isAscendingContiguous());
294
295	length_[0] = r0.length();
296	storage_.setBase(0, r0.first());
297
298	setupStorage(0);
299	}
300
301	template<typename T_numtype, int N_rank>
302	void Array<T_numtype, N_rank>::resize(Range r0, Range r1)
303	{
304	BZPRECONDITION(r0.isAscendingContiguous() &&
305	r1.isAscendingContiguous());
306
307	length_[0] = r0.length();
308	storage_.setBase(0, r0.first());
309	length_[1] = r1.length();
310	storage_.setBase(1, r1.first());
311
312	setupStorage(1);
313	}
314
315	template<typename T_numtype, int N_rank>
316	void Array<T_numtype, N_rank>::resize(Range r0, Range r1, Range r2)
317	{
318	BZPRECONDITION(r0.isAscendingContiguous() &&
319	r1.isAscendingContiguous() && r2.isAscendingContiguous());
320
321	length_[0] = r0.length();
322	storage_.setBase(0, r0.first());
323	length_[1] = r1.length();
324	storage_.setBase(1, r1.first());
325	length_[2] = r2.length();
326	storage_.setBase(2, r2.first());
327
328	setupStorage(2);
329	}
330
331	template<typename T_numtype, int N_rank>
332	void Array<T_numtype, N_rank>::resize(Range r0, Range r1, Range r2,
333	Range r3)
334	{
335	BZPRECONDITION(r0.isAscendingContiguous() &&
336	r1.isAscendingContiguous() && r2.isAscendingContiguous()
337	&& r3.isAscendingContiguous());
338
339	length_[0] = r0.length();
340	storage_.setBase(0, r0.first());
341	length_[1] = r1.length();
342	storage_.setBase(1, r1.first());
343	length_[2] = r2.length();
344	storage_.setBase(2, r2.first());
345	length_[3] = r3.length();
346	storage_.setBase(3, r3.first());
347
348	setupStorage(3);
349	}
350
351	template<typename T_numtype, int N_rank>
352	void Array<T_numtype, N_rank>::resize(Range r0, Range r1, Range r2,
353	Range r3, Range r4)
354	{
355	BZPRECONDITION(r0.isAscendingContiguous() &&
356	r1.isAscendingContiguous() && r2.isAscendingContiguous()
357	&& r3.isAscendingContiguous() && r4.isAscendingContiguous());
358
359	length_[0] = r0.length();
360	storage_.setBase(0, r0.first());
361	length_[1] = r1.length();
362	storage_.setBase(1, r1.first());
363	length_[2] = r2.length();
364	storage_.setBase(2, r2.first());
365	length_[3] = r3.length();
366	storage_.setBase(3, r3.first());
367	length_[4] = r4.length();
368	storage_.setBase(4, r4.first());
369
370	setupStorage(4);
371	}
372
373	template<typename T_numtype, int N_rank>
374	void Array<T_numtype, N_rank>::resize(Range r0, Range r1, Range r2,
375	Range r3, Range r4, Range r5)
376	{
377	BZPRECONDITION(r0.isAscendingContiguous() &&
378	r1.isAscendingContiguous() && r2.isAscendingContiguous()
379	&& r3.isAscendingContiguous() && r4.isAscendingContiguous()
380	&& r5.isAscendingContiguous());
381
382	length_[0] = r0.length();
383	storage_.setBase(0, r0.first());
384	length_[1] = r1.length();
385	storage_.setBase(1, r1.first());
386	length_[2] = r2.length();
387	storage_.setBase(2, r2.first());
388	length_[3] = r3.length();
389	storage_.setBase(3, r3.first());
390	length_[4] = r4.length();
391	storage_.setBase(4, r4.first());
392	length_[5] = r5.length();
393	storage_.setBase(5, r5.first());
394
395	setupStorage(5);
396	}
397
398	template<typename T_numtype, int N_rank>
399	void Array<T_numtype, N_rank>::resize(Range r0, Range r1, Range r2,
400	Range r3, Range r4, Range r5, Range r6)
401	{
402	BZPRECONDITION(r0.isAscendingContiguous() &&
403	r1.isAscendingContiguous() && r2.isAscendingContiguous()
404	&& r3.isAscendingContiguous() && r4.isAscendingContiguous()
405	&& r5.isAscendingContiguous() && r6.isAscendingContiguous());
406
407	length_[0] = r0.length();
408	storage_.setBase(0, r0.first());
409	length_[1] = r1.length();
410	storage_.setBase(1, r1.first());
411	length_[2] = r2.length();
412	storage_.setBase(2, r2.first());
413	length_[3] = r3.length();
414	storage_.setBase(3, r3.first());
415	length_[4] = r4.length();
416	storage_.setBase(4, r4.first());
417	length_[5] = r5.length();
418	storage_.setBase(5, r5.first());
419	length_[6] = r6.length();
420	storage_.setBase(6, r6.first());
421
422	setupStorage(6);
423	}
424
425	template<typename T_numtype, int N_rank>
426	void Array<T_numtype, N_rank>::resize(Range r0, Range r1, Range r2,
427	Range r3, Range r4, Range r5, Range r6, Range r7)
428	{
429	BZPRECONDITION(r0.isAscendingContiguous() &&
430	r1.isAscendingContiguous() && r2.isAscendingContiguous()
431	&& r3.isAscendingContiguous() && r4.isAscendingContiguous()
432	&& r5.isAscendingContiguous() && r6.isAscendingContiguous()
433	&& r7.isAscendingContiguous());
434
435	length_[0] = r0.length();
436	storage_.setBase(0, r0.first());
437	length_[1] = r1.length();
438	storage_.setBase(1, r1.first());
439	length_[2] = r2.length();
440	storage_.setBase(2, r2.first());
441	length_[3] = r3.length();
442	storage_.setBase(3, r3.first());
443	length_[4] = r4.length();
444	storage_.setBase(4, r4.first());
445	length_[5] = r5.length();
446	storage_.setBase(5, r5.first());
447	length_[6] = r6.length();
448	storage_.setBase(6, r6.first());
449	length_[7] = r7.length();
450	storage_.setBase(7, r7.first());
451
452	setupStorage(7);
453	}
454
455	template<typename T_numtype, int N_rank>
456	void Array<T_numtype, N_rank>::resize(Range r0, Range r1, Range r2,
457	Range r3, Range r4, Range r5, Range r6, Range r7, Range r8)
458	{
459	BZPRECONDITION(r0.isAscendingContiguous() &&
460	r1.isAscendingContiguous() && r2.isAscendingContiguous()
461	&& r3.isAscendingContiguous() && r4.isAscendingContiguous()
462	&& r5.isAscendingContiguous() && r6.isAscendingContiguous()
463	&& r7.isAscendingContiguous() && r8.isAscendingContiguous());
464
465	length_[0] = r0.length();
466	storage_.setBase(0, r0.first());
467	length_[1] = r1.length();
468	storage_.setBase(1, r1.first());
469	length_[2] = r2.length();
470	storage_.setBase(2, r2.first());
471	length_[3] = r3.length();
472	storage_.setBase(3, r3.first());
473	length_[4] = r4.length();
474	storage_.setBase(4, r4.first());
475	length_[5] = r5.length();
476	storage_.setBase(5, r5.first());
477	length_[6] = r6.length();
478	storage_.setBase(6, r6.first());
479	length_[7] = r7.length();
480	storage_.setBase(7, r7.first());
481	length_[8] = r8.length();
482	storage_.setBase(8, r8.first());
483
484	setupStorage(8);
485	}
486
487	template<typename T_numtype, int N_rank>
488	void Array<T_numtype, N_rank>::resize(Range r0, Range r1, Range r2,
489	Range r3, Range r4, Range r5, Range r6, Range r7, Range r8,
490	Range r9)
491	{
492	BZPRECONDITION(r0.isAscendingContiguous() &&
493	r1.isAscendingContiguous() && r2.isAscendingContiguous()
494	&& r3.isAscendingContiguous() && r4.isAscendingContiguous()
495	&& r5.isAscendingContiguous() && r6.isAscendingContiguous()
496	&& r7.isAscendingContiguous() && r8.isAscendingContiguous()
497	&& r9.isAscendingContiguous());
498
499	length_[0] = r0.length();
500	storage_.setBase(0, r0.first());
501	length_[1] = r1.length();
502	storage_.setBase(1, r1.first());
503	length_[2] = r2.length();
504	storage_.setBase(2, r2.first());
505	length_[3] = r3.length();
506	storage_.setBase(3, r3.first());
507	length_[4] = r4.length();
508	storage_.setBase(4, r4.first());
509	length_[5] = r5.length();
510	storage_.setBase(5, r5.first());
511	length_[6] = r6.length();
512	storage_.setBase(6, r6.first());
513	length_[7] = r7.length();
514	storage_.setBase(7, r7.first());
515	length_[8] = r8.length();
516	storage_.setBase(8, r8.first());
517	length_[9] = r9.length();
518	storage_.setBase(9, r9.first());
519
520	setupStorage(9);
521	}
522
523	template<typename T_numtype, int N_rank>
524	void Array<T_numtype, N_rank>::resize(Range r0, Range r1, Range r2,
525	Range r3, Range r4, Range r5, Range r6, Range r7, Range r8,
526	Range r9, Range r10)
527	{
528	BZPRECONDITION(r0.isAscendingContiguous() &&
529	r1.isAscendingContiguous() && r2.isAscendingContiguous()
530	&& r3.isAscendingContiguous() && r4.isAscendingContiguous()
531	&& r5.isAscendingContiguous() && r6.isAscendingContiguous()
532	&& r7.isAscendingContiguous() && r8.isAscendingContiguous()
533	&& r9.isAscendingContiguous() && r10.isAscendingContiguous());
534
535	length_[0] = r0.length();
536	storage_.setBase(0, r0.first());
537	length_[1] = r1.length();
538	storage_.setBase(1, r1.first());
539	length_[2] = r2.length();
540	storage_.setBase(2, r2.first());
541	length_[3] = r3.length();
542	storage_.setBase(3, r3.first());
543	length_[4] = r4.length();
544	storage_.setBase(4, r4.first());
545	length_[5] = r5.length();
546	storage_.setBase(5, r5.first());
547	length_[6] = r6.length();
548	storage_.setBase(6, r6.first());
549	length_[7] = r7.length();
550	storage_.setBase(7, r7.first());
551	length_[8] = r8.length();
552	storage_.setBase(8, r8.first());
553	length_[9] = r9.length();
554	storage_.setBase(9, r9.first());
555	length_[10] = r10.length();
556	storage_.setBase(10, r10.first());
557
558	setupStorage(10);
559	}
560
561
562	template<typename T_numtype, int N_rank>
563	void Array<T_numtype, N_rank>::resizeAndPreserve(int length0)
564	{
565	BZPRECONDITION(length0 > 0);
566	BZPRECONDITION(N_rank == 1);
567
568	if (length0 != length_[firstRank])
569	{
570	#if defined(__KCC) \|\| defined(__DECCXX)
571	// NEEDS_WORK: have to discard the base() parameter for EDG,
572	// because it gives the following bizarre error:
573
574	/*
575	* "blitz/tinyvec.h", line 421: error: the size of an array must be greater
576	* than zero
577	* T_numtype data_[N_length];
578	* ^
579	* detected during:
580	* instantiation of class "blitz::TinyVector<int, 0>" at line 273 of
581	* "./../blitz/array/resize.cc"
582	* instantiation of
583	* "void blitz::Array<int, 1>::resizeAndPreserve(int)"
584	*/
585	T_array B(length0, storage_);
586	#else
587	T_array B(base(), BZ_BLITZ_SCOPE(shape)(length0), storage_); // line 273
588	#endif
589	if (numElements())
590	{
591	Range overlap0 = Range(fromStart, minmax::min(B.ubound(0),
592	ubound(0)));
593	B(overlap0) = (*this)(overlap0);
594	}
595	reference(B);
596	}
597	}
598
599	template<typename T_numtype, int N_rank>
600	void Array<T_numtype, N_rank>::resizeAndPreserve(int length0, int length1)
601	{
602	BZPRECONDITION((length0 > 0) && (length1 > 0));
603	BZPRECONDITION(N_rank == 2);
604
605	if ((length0 != length_[0]) \|\| (length1 != length_[1]))
606	{
607	T_array B(base(), BZ_BLITZ_SCOPE(shape)(length0, length1), storage_);
608
609	if (numElements())
610	{
611	Range overlap0 = Range(fromStart, minmax::min(B.ubound(0),
612	ubound(0)));
613	Range overlap1 = Range(fromStart, minmax::min(B.ubound(1),
614	ubound(1)));
615	B(overlap0, overlap1) = (*this)(overlap0, overlap1);
616	}
617	reference(B);
618	}
619	}
620
621	template<typename T_numtype, int N_rank>
622	void Array<T_numtype, N_rank>::resizeAndPreserve(int length0, int length1,
623	int length2)
624	{
625	BZPRECONDITION((length0 > 0) && (length1 > 0) && (length2 > 0));
626	BZPRECONDITION(N_rank == 3);
627
628	if ((length0 != length_[0]) \|\| (length1 != length_[1])
629	\|\| (length2 != length_[2]))
630	{
631	T_array B(base(), BZ_BLITZ_SCOPE(shape)(length0, length1, length2),
632	storage_);
633	if (numElements())
634	{
635	Range overlap0 = Range(fromStart, minmax::min(B.ubound(0),
636	ubound(0)));
637	Range overlap1 = Range(fromStart, minmax::min(B.ubound(1),
638	ubound(1)));
639	Range overlap2 = Range(fromStart, minmax::min(B.ubound(2),
640	ubound(2)));
641	B(overlap0, overlap1, overlap2) = (*this)(overlap0, overlap1,
642	overlap2);
643	}
644	reference(B);
645	}
646	}
647
648	template<typename T_numtype, int N_rank>
649	void Array<T_numtype, N_rank>::resizeAndPreserve(int length0, int length1,
650	int length2, int length3)
651	{
652	BZPRECONDITION((length0 > 0) && (length1 > 0) && (length2 > 0)
653	&& (length3 > 0));
654	BZPRECONDITION(N_rank == 4);
655
656	if ((length0 != length_[0]) \|\| (length1 != length_[1])
657	\|\| (length2 != length_[2]) \|\| (length3 != length_[3]))
658	{
659	T_array B(base(), BZ_BLITZ_SCOPE(shape)(length0, length1,
660	length2, length3), storage_);
661
662	if (numElements())
663	{
664	Range overlap0 = Range(fromStart, minmax::min(B.ubound(0), ubound(0)));
665	Range overlap1 = Range(fromStart, minmax::min(B.ubound(1), ubound(1)));
666	Range overlap2 = Range(fromStart, minmax::min(B.ubound(2), ubound(2)));
667	Range overlap3 = Range(fromStart, minmax::min(B.ubound(3), ubound(3)));
668	B(overlap0, overlap1, overlap2, overlap3) = (*this)(overlap0,
669	overlap1, overlap2, overlap3);
670	}
671	reference(B);
672	}
673	}
674
675	template<typename T_numtype, int N_rank>
676	void Array<T_numtype, N_rank>::resizeAndPreserve(int length0, int length1,
677	int length2, int length3, int length4)
678	{
679	BZPRECONDITION((length0 > 0) && (length1 > 0) && (length2 > 0)
680	&& (length3 > 0) && (length4 > 0));
681	BZPRECONDITION(N_rank == 5);
682
683	if ((length0 != length_[0]) \|\| (length1 != length_[1])
684	\|\| (length2 != length_[2]) \|\| (length3 != length_[3])
685	\|\| (length4 != length_[4]))
686	{
687	T_array B(base(), BZ_BLITZ_SCOPE(shape)(length0, length1,
688	length2, length3, length4), storage_);
689
690	if (numElements())
691	{
692	Range overlap0 = Range(fromStart, minmax::min(B.ubound(0), ubound(0)));
693	Range overlap1 = Range(fromStart, minmax::min(B.ubound(1), ubound(1)));
694	Range overlap2 = Range(fromStart, minmax::min(B.ubound(2), ubound(2)));
695	Range overlap3 = Range(fromStart, minmax::min(B.ubound(3), ubound(3)));
696	Range overlap4 = Range(fromStart, minmax::min(B.ubound(4), ubound(4)));
697	B(overlap0, overlap1, overlap2, overlap3, overlap4) = (*this)
698	(overlap0, overlap1, overlap2, overlap3, overlap4);
699	}
700	reference(B);
701	}
702	}
703
704	template<typename T_numtype, int N_rank>
705	void Array<T_numtype, N_rank>::resizeAndPreserve(int length0, int length1,
706	int length2, int length3, int length4, int length5)
707	{
708	BZPRECONDITION((length0 > 0) && (length1 > 0) && (length2 > 0)
709	&& (length3 > 0) && (length4 > 0) && (length5 > 0));
710	BZPRECONDITION(N_rank == 6);
711
712	if ((length0 != length_[0]) \|\| (length1 != length_[1])
713	\|\| (length2 != length_[2]) \|\| (length3 != length_[3])
714	\|\| (length4 != length_[4]) \|\| (length5 != length_[5]))
715	{
716	T_array B(base(), BZ_BLITZ_SCOPE(shape)(length0, length1, length2,
717	length3, length4, length5), storage_);
718
719	if (numElements())
720	{
721	Range overlap0 = Range(fromStart, minmax::min(B.ubound(0), ubound(0)));
722	Range overlap1 = Range(fromStart, minmax::min(B.ubound(1), ubound(1)));
723	Range overlap2 = Range(fromStart, minmax::min(B.ubound(2), ubound(2)));
724	Range overlap3 = Range(fromStart, minmax::min(B.ubound(3), ubound(3)));
725	Range overlap4 = Range(fromStart, minmax::min(B.ubound(4), ubound(4)));
726	Range overlap5 = Range(fromStart, minmax::min(B.ubound(5), ubound(5)));
727	B(overlap0, overlap1, overlap2, overlap3, overlap4, overlap5)
728	= (*this)(overlap0, overlap1, overlap2, overlap3, overlap4,
729	overlap5);
730	}
731	reference(B);
732	}
733	}
734
735	/* Added by Julian Cummings */
736	template<typename T_numtype, int N_rank>
737	void Array<T_numtype, N_rank>::resizeAndPreserve(int length0, int length1,
738	int length2, int length3, int length4, int length5, int length6)
739	{
740	BZPRECONDITION((length0 > 0) && (length1 > 0) && (length2 > 0)
741	&& (length3 > 0) && (length4 > 0) && (length5 > 0) && (length6 > 0));
742	BZPRECONDITION(N_rank == 7);
743
744	if ((length0 != length_[0]) \|\| (length1 != length_[1])
745	\|\| (length2 != length_[2]) \|\| (length3 != length_[3])
746	\|\| (length4 != length_[4]) \|\| (length5 != length_[5])
747	\|\| (length6 != length_[6]))
748	{
749	T_array B(base(), BZ_BLITZ_SCOPE(shape)(length0, length1, length2,
750	length3, length4, length5, length6), storage_);
751
752	if (numElements())
753	{
754	Range overlap0 = Range(fromStart, minmax::min(B.ubound(0),
755	ubound(0)));
756	Range overlap1 = Range(fromStart, minmax::min(B.ubound(1),
757	ubound(1)));
758	Range overlap2 = Range(fromStart, minmax::min(B.ubound(2),
759	ubound(2)));
760	Range overlap3 = Range(fromStart, minmax::min(B.ubound(3),
761	ubound(3)));
762	Range overlap4 = Range(fromStart, minmax::min(B.ubound(4),
763	ubound(4)));
764	Range overlap5 = Range(fromStart, minmax::min(B.ubound(5),
765	ubound(5)));
766	Range overlap6 = Range(fromStart, minmax::min(B.ubound(6),
767	ubound(6)));
768	B(overlap0, overlap1, overlap2, overlap3, overlap4, overlap5,
769	overlap6)
770	= (*this)(overlap0, overlap1, overlap2, overlap3, overlap4,
771	overlap5, overlap6);
772	}
773	reference(B);
774	}
775	}
776
777	/* Added by Julian Cummings */
778	template<typename T_numtype, int N_rank>
779	void Array<T_numtype, N_rank>::resizeAndPreserve(int length0, int length1,
780	int length2, int length3, int length4, int length5, int length6,
781	int length7)
782	{
783	BZPRECONDITION((length0 > 0) && (length1 > 0) && (length2 > 0)
784	&& (length3 > 0) && (length4 > 0) && (length5 > 0) && (length6 > 0)
785	&& (length7 > 0));
786	BZPRECONDITION(N_rank == 8);
787
788	if ((length0 != length_[0]) \|\| (length1 != length_[1])
789	\|\| (length2 != length_[2]) \|\| (length3 != length_[3])
790	\|\| (length4 != length_[4]) \|\| (length5 != length_[5])
791	\|\| (length6 != length_[6]) \|\| (length7 != length_[7]))
792	{
793	T_array B(base(), BZ_BLITZ_SCOPE(shape)(length0, length1, length2,
794	length3, length4, length5, length6, length7), storage_);
795
796	if (numElements())
797	{
798	Range overlap0 = Range(fromStart, minmax::min(B.ubound(0),
799	ubound(0)));
800	Range overlap1 = Range(fromStart, minmax::min(B.ubound(1),
801	ubound(1)));
802	Range overlap2 = Range(fromStart, minmax::min(B.ubound(2),
803	ubound(2)));
804	Range overlap3 = Range(fromStart, minmax::min(B.ubound(3),
805	ubound(3)));
806	Range overlap4 = Range(fromStart, minmax::min(B.ubound(4),
807	ubound(4)));
808	Range overlap5 = Range(fromStart, minmax::min(B.ubound(5),
809	ubound(5)));
810	Range overlap6 = Range(fromStart, minmax::min(B.ubound(6),
811	ubound(6)));
812	Range overlap7 = Range(fromStart, minmax::min(B.ubound(7),
813	ubound(7)));
814	B(overlap0, overlap1, overlap2, overlap3, overlap4, overlap5,
815	overlap6, overlap7)
816	= (*this)(overlap0, overlap1, overlap2, overlap3, overlap4,
817	overlap5, overlap6, overlap7);
818	}
819	reference(B);
820	}
821	}
822
823	/* Added by Julian Cummings */
824	template<typename T_numtype, int N_rank>
825	void Array<T_numtype, N_rank>::resizeAndPreserve(int length0, int length1,
826	int length2, int length3, int length4, int length5, int length6,
827	int length7, int length8)
828	{
829	BZPRECONDITION((length0 > 0) && (length1 > 0) && (length2 > 0)
830	&& (length3 > 0) && (length4 > 0) && (length5 > 0) && (length6 > 0)
831	&& (length7 > 0) && (length8 > 0));
832	BZPRECONDITION(N_rank == 9);
833
834	if ((length0 != length_[0]) \|\| (length1 != length_[1])
835	\|\| (length2 != length_[2]) \|\| (length3 != length_[3])
836	\|\| (length4 != length_[4]) \|\| (length5 != length_[5])
837	\|\| (length6 != length_[6]) \|\| (length7 != length_[7])
838	\|\| (length8 != length_[8]))
839	{
840	T_array B(base(), BZ_BLITZ_SCOPE(shape)(length0, length1, length2,
841	length3, length4, length5, length6, length7, length8), storage_);
842
843	if (numElements())
844	{
845	Range overlap0 = Range(fromStart, minmax::min(B.ubound(0),
846	ubound(0)));
847	Range overlap1 = Range(fromStart, minmax::min(B.ubound(1),
848	ubound(1)));
849	Range overlap2 = Range(fromStart, minmax::min(B.ubound(2),
850	ubound(2)));
851	Range overlap3 = Range(fromStart, minmax::min(B.ubound(3),
852	ubound(3)));
853	Range overlap4 = Range(fromStart, minmax::min(B.ubound(4),
854	ubound(4)));
855	Range overlap5 = Range(fromStart, minmax::min(B.ubound(5),
856	ubound(5)));
857	Range overlap6 = Range(fromStart, minmax::min(B.ubound(6),
858	ubound(6)));
859	Range overlap7 = Range(fromStart, minmax::min(B.ubound(7),
860	ubound(7)));
861	Range overlap8 = Range(fromStart, minmax::min(B.ubound(8),
862	ubound(8)));
863	B(overlap0, overlap1, overlap2, overlap3, overlap4, overlap5,
864	overlap6, overlap7, overlap8)
865	= (*this)(overlap0, overlap1, overlap2, overlap3, overlap4,
866	overlap5, overlap6, overlap7, overlap8);
867	}
868	reference(B);
869	}
870	}
871
872	/* Added by Julian Cummings */
873	template<typename T_numtype, int N_rank>
874	void Array<T_numtype, N_rank>::resizeAndPreserve(int length0, int length1,
875	int length2, int length3, int length4, int length5, int length6,
876	int length7, int length8, int length9)
877	{
878	BZPRECONDITION((length0 > 0) && (length1 > 0) && (length2 > 0)
879	&& (length3 > 0) && (length4 > 0) && (length5 > 0) && (length6 > 0)
880	&& (length7 > 0) && (length8 > 0) && (length9 > 0));
881	BZPRECONDITION(N_rank == 10);
882
883	if ((length0 != length_[0]) \|\| (length1 != length_[1])
884	\|\| (length2 != length_[2]) \|\| (length3 != length_[3])
885	\|\| (length4 != length_[4]) \|\| (length5 != length_[5])
886	\|\| (length6 != length_[6]) \|\| (length7 != length_[7])
887	\|\| (length8 != length_[8]) \|\| (length9 != length_[9]))
888	{
889	T_array B(base(), BZ_BLITZ_SCOPE(shape)(length0, length1, length2,
890	length3, length4, length5, length6, length7, length8, length9),
891	storage_);
892
893	if (numElements())
894	{
895	Range overlap0 = Range(fromStart, minmax::min(B.ubound(0),
896	ubound(0)));
897	Range overlap1 = Range(fromStart, minmax::min(B.ubound(1),
898	ubound(1)));
899	Range overlap2 = Range(fromStart, minmax::min(B.ubound(2),
900	ubound(2)));
901	Range overlap3 = Range(fromStart, minmax::min(B.ubound(3),
902	ubound(3)));
903	Range overlap4 = Range(fromStart, minmax::min(B.ubound(4),
904	ubound(4)));
905	Range overlap5 = Range(fromStart, minmax::min(B.ubound(5),
906	ubound(5)));
907	Range overlap6 = Range(fromStart, minmax::min(B.ubound(6),
908	ubound(6)));
909	Range overlap7 = Range(fromStart, minmax::min(B.ubound(7),
910	ubound(7)));
911	Range overlap8 = Range(fromStart, minmax::min(B.ubound(8),
912	ubound(8)));
913	Range overlap9 = Range(fromStart, minmax::min(B.ubound(9),
914	ubound(9)));
915	B(overlap0, overlap1, overlap2, overlap3, overlap4, overlap5,
916	overlap6, overlap7, overlap8, overlap9)
917	= (*this)(overlap0, overlap1, overlap2, overlap3, overlap4,
918	overlap5, overlap6, overlap7, overlap8, overlap9);
919	}
920	reference(B);
921	}
922	}
923
924	/* Added by Julian Cummings */
925	template<typename T_numtype, int N_rank>
926	void Array<T_numtype, N_rank>::resizeAndPreserve(int length0, int length1,
927	int length2, int length3, int length4, int length5, int length6,
928	int length7, int length8, int length9, int length10)
929	{
930	BZPRECONDITION((length0 > 0) && (length1 > 0) && (length2 > 0)
931	&& (length3 > 0) && (length4 > 0) && (length5 > 0) && (length6 > 0)
932	&& (length7 > 0) && (length8 > 0) && (length9 > 0) && (length10 > 0));
933	BZPRECONDITION(N_rank == 11);
934
935	if ((length0 != length_[0]) \|\| (length1 != length_[1])
936	\|\| (length2 != length_[2]) \|\| (length3 != length_[3])
937	\|\| (length4 != length_[4]) \|\| (length5 != length_[5])
938	\|\| (length6 != length_[6]) \|\| (length7 != length_[7])
939	\|\| (length8 != length_[8]) \|\| (length9 != length_[9])
940	\|\| (length10 != length_[10]))
941	{
942	T_array B(base(), BZ_BLITZ_SCOPE(shape)(length0, length1, length2,
943	length3, length4, length5, length6, length7, length8, length9,
944	length10), storage_);
945
946	if (numElements())
947	{
948	Range overlap0 = Range(fromStart, minmax::min(B.ubound(0),
949	ubound(0)));
950	Range overlap1 = Range(fromStart, minmax::min(B.ubound(1),
951	ubound(1)));
952	Range overlap2 = Range(fromStart, minmax::min(B.ubound(2),
953	ubound(2)));
954	Range overlap3 = Range(fromStart, minmax::min(B.ubound(3),
955	ubound(3)));
956	Range overlap4 = Range(fromStart, minmax::min(B.ubound(4),
957	ubound(4)));
958	Range overlap5 = Range(fromStart, minmax::min(B.ubound(5),
959	ubound(5)));
960	Range overlap6 = Range(fromStart, minmax::min(B.ubound(6),
961	ubound(6)));
962	Range overlap7 = Range(fromStart, minmax::min(B.ubound(7),
963	ubound(7)));
964	Range overlap8 = Range(fromStart, minmax::min(B.ubound(8),
965	ubound(8)));
966	Range overlap9 = Range(fromStart, minmax::min(B.ubound(9),
967	ubound(9)));
968	Range overlap10 = Range(fromStart, minmax::min(B.ubound(10),
969	ubound(10)));
970	}
971	reference(B);
972	}
973	}
974
975	template<typename T_numtype, int N_rank>
976	void Array<T_numtype, N_rank>::resize(const TinyVector<int,N_rank>& extent)
977	{
978	// NEEDS_WORK -- don't resize if unnecessary
979	// BZPRECONDITION(all(extent > 0));
980	// if (any(extent != length_))
981	// {
982	length_ = extent;
983	setupStorage(N_rank);
984	// }
985	}
986
987	/* Added by Julian Cummings */
988	template<typename T_numtype, int N_rank>
989	void Array<T_numtype, N_rank>::resizeAndPreserve(
990	const TinyVector<int,N_rank>& extent)
991	{
992	// NEEDS_WORK -- don't resize if unnecessary
993	// BZPRECONDITION(all(extent > 0));
994	// if (any(extent != length_))
995	// {
996	T_array B(base(), extent, storage_);
997
998	if (numElements())
999	{
1000	TinyVector<int,N_rank> ub;
1001	for (int d=0; d < N_rank; ++d)
1002	ub(d) = minmax::min(B.ubound(d),ubound(d));
1003	RectDomain<N_rank> overlap(lbound(),ub);
1004	B(overlap) = (*this)(overlap);
1005	}
1006	reference(B);
1007	// }
1008	}
1009
1010	BZ_NAMESPACE_END
1011
1012	#endif // BZ_ARRAYRESIZE_CC

Note: See TracBrowser for help on using the repository browser.

Download in other formats: