1 // -*- C++ -*-
2 /***************************************************************************
3 * blitz/array/indirect.h Array indirection
4 *
5 * $Id$
6 *
7 * Copyright (C) 1997-2011 Todd Veldhuizen <tveldhui@acm.org>
8 *
9 * This file is a part of Blitz.
10 *
11 * Blitz is free software: you can redistribute it and/or modify
12 * it under the terms of the GNU Lesser General Public License
13 * as published by the Free Software Foundation, either version 3
14 * of the License, or (at your option) any later version.
15 *
16 * Blitz is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with Blitz. If not, see <http://www.gnu.org/licenses/>.
23 *
24 * Suggestions: blitz-devel@lists.sourceforge.net
25 * Bugs: blitz-support@lists.sourceforge.net
26 *
27 * For more information, please see the Blitz++ Home Page:
28 * https://sourceforge.net/projects/blitz/
29 *
30 ****************************************************************************/
31
32 #ifndef BZ_ARRAY_INDIRECT_H
33 #define BZ_ARRAY_INDIRECT_H
34
35 #include <blitz/array/asexpr.h>
36 #include <blitz/array/cartesian.h>
37
38 namespace blitz {
39
40 template<typename T_array, typename T_index>
41 class IndirectArray {
42
43 public:
IndirectArray(T_array & array,T_index & index)44 IndirectArray(T_array& array, T_index& index)
45 : array_(array), index_(index)
46 { }
47
48 template<typename T_expr>
49 void operator=(T_expr expr);
50
51 protected:
52 T_array& array_;
53 T_index& index_;
54 };
55
56 // Forward declarations
57 template<typename T_array, typename T_arrayiter, typename T_subdomain, typename T_expr>
58 inline void applyOverSubdomain(const T_array& array, T_arrayiter& arrayIter,
59 T_subdomain subdomain, T_expr expr);
60 template<typename T_array, typename T_arrayiter, int N_rank, typename T_expr>
61 inline void applyOverSubdomain(const T_array& array, T_arrayiter& arrayIter,
62 RectDomain<N_rank> subdomain,
63 T_expr expr);
64
65 template<typename T_array, typename T_index> template<typename T_rhs>
66 void IndirectArray<T_array, T_index>::operator=(T_rhs rhs)
67 {
68 typedef _bz_typename asExpr<T_rhs>::T_expr T_expr;
69 T_expr expr(rhs);
70
71 _bz_typename T_array::T_iterator arrayIter(array_);
72
73 _bz_typename T_index::iterator iter = index_.begin(),
74 end = index_.end();
75
76 for (; iter != end; ++iter)
77 {
78 _bz_typename T_index::value_type subdomain = *iter;
79 applyOverSubdomain(array_, arrayIter, subdomain, expr);
80 }
81 }
82
83 template<typename T_array, typename T_arrayiter, typename T_subdomain, typename T_expr>
applyOverSubdomain(const T_array & BZ_DEBUG_PARAM (array),T_arrayiter & arrayIter,T_subdomain subdomain,T_expr expr)84 inline void applyOverSubdomain(const T_array& BZ_DEBUG_PARAM(array), T_arrayiter& arrayIter,
85 T_subdomain subdomain, T_expr expr)
86 {
87 BZPRECHECK(array.isInRange(subdomain),
88 "In indirection using an STL container of TinyVector<int,"
89 << array.rank() << ">, one of the" << endl << "positions is out of"
90 " range: " << endl << subdomain << endl
91 << "Array lower bounds: " << array.lbound() << endl
92 << "Array upper bounds: " << array.ubound() << endl)
93
94 arrayIter.moveTo(subdomain);
95 expr.moveTo(subdomain);
96
97 *const_cast<_bz_typename T_arrayiter::T_numtype*>(arrayIter.data()) = *expr;
98 }
99
100 // Specialization for RectDomain<N>
101 template<typename T_array, typename T_arrayiter, int N_rank, typename T_expr>
applyOverSubdomain(const T_array & BZ_DEBUG_PARAM (array),T_arrayiter & arrayIter,RectDomain<N_rank> subdomain,T_expr expr)102 inline void applyOverSubdomain(const T_array& BZ_DEBUG_PARAM(array), T_arrayiter& arrayIter,
103 RectDomain<N_rank> subdomain,
104 T_expr expr)
105 {
106 typedef _bz_typename T_array::T_numtype T_numtype;
107
108 // Assume that the RectDomain<N_rank> is a 1-D strip.
109 // Find the dimension in which the strip is oriented. This
110 // variable is static so that we cache the value; likely to be
111 // the same for all strips within a container.
112
113 static int stripDim = 0;
114
115 if (subdomain.lbound(stripDim) == subdomain.ubound(stripDim))
116 {
117 // Cached value was wrong, find the correct value of stripDim
118 for (stripDim=0; stripDim < N_rank; ++stripDim)
119 if (subdomain.lbound(stripDim) != subdomain.ubound(stripDim))
120 break;
121
122 // Handle case where the strip is just a single point
123 if (stripDim == N_rank)
124 stripDim = 0;
125 }
126
127 #ifdef BZ_DEBUG
128 // Check that this is in fact a 1D strip
129 for (int i=0; i < N_rank; ++i)
130 if ((i != stripDim) && (subdomain.lbound(i) != subdomain.ubound(i)))
131 BZPRECHECK(0, "In indirection using an STL container of RectDomain<"
132 << N_rank << ">, one of" << endl << "the RectDomain objects was not"
133 " a one-dimensional strip:" << endl << "RectDomain<" << N_rank
134 << ">::lbound() = " << subdomain.lbound() << endl
135 << "RectDomain<" << N_rank << ">::ubound() = " << subdomain.ubound())
136 #endif
137
138 // Check that the start and end position are in range
139 BZPRECHECK(array.isInRange(subdomain.lbound()),
140 "In indirection using an STL container of RectDomain<"
141 << N_rank << ">, one of" << endl << "the RectDomain objects has a"
142 " lbound which is out of range:" << endl
143 << subdomain.lbound() << endl
144 << "Array lower bounds: " << array.lbound() << endl
145 << "Array upper bounds: " << array.ubound() << endl)
146
147 BZPRECHECK(array.isInRange(subdomain.ubound()),
148 "In indirection using an STL container of RectDomain<"
149 << N_rank << ">, one of" << endl << "the RectDomain objects has a"
150 " ubound which is out of range:" << endl
151 << subdomain.lbound() << endl
152 << "Array lower bounds: " << array.lbound() << endl
153 << "Array upper bounds: " << array.ubound() << endl)
154
155 // Position at the beginning of the strip
156 arrayIter.moveTo(subdomain.lbound());
157 expr.moveTo(subdomain.lbound());
158
159 // Loop through the strip
160
161 #ifdef BZ_USE_FAST_READ_ARRAY_EXPR
162
163 bool useUnitStride = arrayIter.isUnitStride(stripDim)
164 && expr.isUnitStride(stripDim);
165
166 int lbound = subdomain.lbound(stripDim);
167 int ubound = subdomain.ubound(stripDim);
168
169 if (useUnitStride)
170 {
171 T_numtype* restrict data = const_cast<T_numtype*>(arrayIter.data());
172
173 int length = ubound - lbound + 1;
174 for (int i=0; i < length; ++i)
175 *data++ = expr.fastRead(i);
176 }
177 else {
178 #endif
179
180 arrayIter.loadStride(stripDim);
181 expr.loadStride(stripDim);
182
183 for (int i=lbound; i <= ubound; ++i)
184 {
185 *const_cast<_bz_typename T_arrayiter::T_numtype*>(arrayIter.data())
186 = *expr;
187 expr.advance();
188 arrayIter.advance();
189 }
190
191 #ifdef BZ_USE_FAST_READ_ARRAY_EXPR
192 }
193 #endif
194 }
195
196 // Global functions for cartesian product of index sets
197 template<typename T_container>
198 CartesianProduct<TinyVector<int,2>,T_container,2>
indexSet(const T_container & container0,const T_container & container1)199 indexSet(const T_container& container0, const T_container& container1)
200 {
201 return CartesianProduct<TinyVector<int,2>,T_container,2>(
202 const_cast<T_container&>(container0),
203 const_cast<T_container&>(container1));
204 }
205
206 template<typename T_container>
207 CartesianProduct<TinyVector<int,3>,T_container,3>
indexSet(const T_container & container0,const T_container & container1,const T_container & container2)208 indexSet(const T_container& container0, const T_container& container1,
209 const T_container& container2)
210 {
211 return CartesianProduct<TinyVector<int,3>,T_container,3>(
212 const_cast<T_container&>(container0),
213 const_cast<T_container&>(container1),
214 const_cast<T_container&>(container2));
215 }
216
217 template<typename T_container>
218 CartesianProduct<TinyVector<int,4>,T_container,4>
indexSet(const T_container & container0,const T_container & container1,const T_container & container2,const T_container & container3)219 indexSet(const T_container& container0, const T_container& container1,
220 const T_container& container2, const T_container& container3)
221 {
222 return CartesianProduct<TinyVector<int,4>,T_container,4>(
223 const_cast<T_container&>(container0),
224 const_cast<T_container&>(container1),
225 const_cast<T_container&>(container2),
226 const_cast<T_container&>(container3));
227 }
228
229 template<typename T_container>
230 CartesianProduct<TinyVector<int,5>,T_container,5>
indexSet(const T_container & container0,const T_container & container1,const T_container & container2,const T_container & container3,const T_container & container4)231 indexSet(const T_container& container0, const T_container& container1,
232 const T_container& container2, const T_container& container3,
233 const T_container& container4)
234 {
235 return CartesianProduct<TinyVector<int,5>,T_container,5>(
236 const_cast<T_container&>(container0),
237 const_cast<T_container&>(container1),
238 const_cast<T_container&>(container2),
239 const_cast<T_container&>(container3),
240 const_cast<T_container&>(container4));
241 }
242
243 template<typename T_container>
244 CartesianProduct<TinyVector<int,6>,T_container,6>
indexSet(const T_container & container0,const T_container & container1,const T_container & container2,const T_container & container3,const T_container & container4,const T_container & container5)245 indexSet(const T_container& container0, const T_container& container1,
246 const T_container& container2, const T_container& container3,
247 const T_container& container4, const T_container& container5)
248 {
249 return CartesianProduct<TinyVector<int,6>,T_container,6>(
250 const_cast<T_container&>(container0),
251 const_cast<T_container&>(container1),
252 const_cast<T_container&>(container2),
253 const_cast<T_container&>(container3),
254 const_cast<T_container&>(container4),
255 const_cast<T_container&>(container5));
256 }
257
258 template<typename T_container>
259 CartesianProduct<TinyVector<int,7>,T_container,7>
indexSet(const T_container & container0,const T_container & container1,const T_container & container2,const T_container & container3,const T_container & container4,const T_container & container5,const T_container & container6)260 indexSet(const T_container& container0, const T_container& container1,
261 const T_container& container2, const T_container& container3,
262 const T_container& container4, const T_container& container5,
263 const T_container& container6)
264 {
265 return CartesianProduct<TinyVector<int,7>,T_container,7>(
266 const_cast<T_container&>(container0),
267 const_cast<T_container&>(container1),
268 const_cast<T_container&>(container2),
269 const_cast<T_container&>(container3),
270 const_cast<T_container&>(container4),
271 const_cast<T_container&>(container5),
272 const_cast<T_container&>(container6));
273 }
274
275 template<typename T_container>
276 CartesianProduct<TinyVector<int,8>,T_container,8>
indexSet(const T_container & container0,const T_container & container1,const T_container & container2,const T_container & container3,const T_container & container4,const T_container & container5,const T_container & container6,const T_container & container7)277 indexSet(const T_container& container0, const T_container& container1,
278 const T_container& container2, const T_container& container3,
279 const T_container& container4, const T_container& container5,
280 const T_container& container6, const T_container& container7)
281 {
282 return CartesianProduct<TinyVector<int,8>,T_container,8>(
283 const_cast<T_container&>(container0),
284 const_cast<T_container&>(container1),
285 const_cast<T_container&>(container2),
286 const_cast<T_container&>(container3),
287 const_cast<T_container&>(container4),
288 const_cast<T_container&>(container5),
289 const_cast<T_container&>(container6),
290 const_cast<T_container&>(container7));
291 }
292
293 template<typename T_container>
294 CartesianProduct<TinyVector<int,9>,T_container,9>
indexSet(const T_container & container0,const T_container & container1,const T_container & container2,const T_container & container3,const T_container & container4,const T_container & container5,const T_container & container6,const T_container & container7,const T_container & container8)295 indexSet(const T_container& container0, const T_container& container1,
296 const T_container& container2, const T_container& container3,
297 const T_container& container4, const T_container& container5,
298 const T_container& container6, const T_container& container7,
299 const T_container& container8)
300 {
301 return CartesianProduct<TinyVector<int,9>,T_container,9>(
302 const_cast<T_container&>(container0),
303 const_cast<T_container&>(container1),
304 const_cast<T_container&>(container2),
305 const_cast<T_container&>(container3),
306 const_cast<T_container&>(container4),
307 const_cast<T_container&>(container5),
308 const_cast<T_container&>(container6),
309 const_cast<T_container&>(container7),
310 const_cast<T_container&>(container8));
311 }
312
313 template<typename T_container>
314 CartesianProduct<TinyVector<int,10>,T_container,10>
indexSet(const T_container & container0,const T_container & container1,const T_container & container2,const T_container & container3,const T_container & container4,const T_container & container5,const T_container & container6,const T_container & container7,const T_container & container8,const T_container & container9)315 indexSet(const T_container& container0, const T_container& container1,
316 const T_container& container2, const T_container& container3,
317 const T_container& container4, const T_container& container5,
318 const T_container& container6, const T_container& container7,
319 const T_container& container8, const T_container& container9)
320 {
321 return CartesianProduct<TinyVector<int,10>,T_container,10>(
322 const_cast<T_container&>(container0),
323 const_cast<T_container&>(container1),
324 const_cast<T_container&>(container2),
325 const_cast<T_container&>(container3),
326 const_cast<T_container&>(container4),
327 const_cast<T_container&>(container5),
328 const_cast<T_container&>(container6),
329 const_cast<T_container&>(container7),
330 const_cast<T_container&>(container8),
331 const_cast<T_container&>(container9));
332 }
333
334 template<typename T_container>
335 CartesianProduct<TinyVector<int,11>,T_container,11>
indexSet(const T_container & container0,const T_container & container1,const T_container & container2,const T_container & container3,const T_container & container4,const T_container & container5,const T_container & container6,const T_container & container7,const T_container & container8,const T_container & container9,const T_container & container10)336 indexSet(const T_container& container0, const T_container& container1,
337 const T_container& container2, const T_container& container3,
338 const T_container& container4, const T_container& container5,
339 const T_container& container6, const T_container& container7,
340 const T_container& container8, const T_container& container9,
341 const T_container& container10)
342 {
343 return CartesianProduct<TinyVector<int,11>,T_container,11>(
344 const_cast<T_container&>(container0),
345 const_cast<T_container&>(container1),
346 const_cast<T_container&>(container2),
347 const_cast<T_container&>(container3),
348 const_cast<T_container&>(container4),
349 const_cast<T_container&>(container5),
350 const_cast<T_container&>(container6),
351 const_cast<T_container&>(container7),
352 const_cast<T_container&>(container8),
353 const_cast<T_container&>(container9),
354 const_cast<T_container&>(container10));
355 }
356
357 // Mixture of singletons and containers, e.g. A[indexSet(I,3,K)]
358
359 // cp_findContainerType<T1,T2,T3,...,Tn>::T_container
360 // The set of parameters T1, T2, T3, ... Tn is a mixture of
361 // int and T_container. This traits class finds the container
362 // type, and sets T_container.
363 //
364 // e.g. cp_findContainerType<int,int,list<int>,int>::T_container is list<int>
365 // cp_findContainerType<int,deque<int>,deque<int>>::T_container
366 // is deque<int>
367
368 template<typename T1, typename T2, typename T3=int, typename T4=int,
369 typename T5=int, typename T6=int, typename T7=int, typename T8=int,
370 typename T9=int, typename T10=int, typename T11=int>
371 struct cp_findContainerType {
372 typedef T1 T_container;
373 };
374
375 template<typename T2, typename T3, typename T4, typename T5, typename T6,
376 typename T7, typename T8, typename T9, typename T10, typename T11>
377 struct cp_findContainerType<int,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> {
378 typedef _bz_typename
379 cp_findContainerType<T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::T_container
380 T_container;
381 };
382
383
384 // The cp_traits class handles promotion of singleton integers to
385 // containers. It takes two template parameters:
386 // T = argument type
387 // T2 = container type
388 // If T is an integer, then a container of type T2 is created and the
389 // integer is inserted. This container is returned.
390 // Otherwise, T is assumed to be the same type as T2, and the original
391 // container is returned.
392
393 template<typename T, typename T2>
394 struct cp_traits {
395 typedef T T_container;
396
397 static const T_container& make(const T& x)
398 { return x; }
399 };
400
401 template<typename T2>
402 struct cp_traits<int,T2> {
403 typedef T2 T_container;
404
405 static T2 make(int x)
406 {
407 T2 singleton;
408 singleton.push_back(x);
409 return singleton;
410 }
411 };
412
413 // These versions of indexSet() allow mixtures of integer
414 // and container arguments. At least one integer must be
415 // specified.
416
417 template<typename T1, typename T2>
418 CartesianProduct<TinyVector<int,2>, _bz_typename
419 cp_findContainerType<T1,T2>::T_container,2>
420 indexSet(const T1& c1, const T2& c2)
421 {
422 typedef _bz_typename cp_findContainerType<T1,T2>::T_container
423 T_container;
424
425 return CartesianProduct<TinyVector<int,2>, T_container, 2>(
426 cp_traits<T1,T_container>::make(c1),
427 cp_traits<T2,T_container>::make(c2));
428 }
429
430 template<typename T1, typename T2, typename T3>
431 CartesianProduct<TinyVector<int,3>, _bz_typename
432 cp_findContainerType<T1,T2,T3>::T_container, 3>
433 indexSet(const T1& c1, const T2& c2, const T3& c3)
434 {
435 typedef _bz_typename cp_findContainerType<T1,T2,T3>::T_container
436 T_container;
437
438 return CartesianProduct<TinyVector<int,3>, T_container, 3>(
439 cp_traits<T1,T_container>::make(c1),
440 cp_traits<T2,T_container>::make(c2),
441 cp_traits<T3,T_container>::make(c3));
442 }
443
444 template<typename T1, typename T2, typename T3, typename T4>
445 CartesianProduct<TinyVector<int,4>, _bz_typename
446 cp_findContainerType<T1,T2,T3,T4>::T_container, 4>
447 indexSet(const T1& c1, const T2& c2, const T3& c3, const T4& c4)
448 {
449 typedef _bz_typename cp_findContainerType<T1,T2,T3,T4>::T_container
450 T_container;
451
452 return CartesianProduct<TinyVector<int,4>, T_container, 4>(
453 cp_traits<T1,T_container>::make(c1),
454 cp_traits<T2,T_container>::make(c2),
455 cp_traits<T3,T_container>::make(c3),
456 cp_traits<T4,T_container>::make(c4));
457 }
458
459 template<typename T1, typename T2, typename T3, typename T4, typename T5>
460 CartesianProduct<TinyVector<int,5>, _bz_typename
461 cp_findContainerType<T1,T2,T3,T4,T5>::T_container, 5>
462 indexSet(const T1& c1, const T2& c2, const T3& c3, const T4& c4, const T5& c5)
463 {
464 typedef _bz_typename cp_findContainerType<T1,T2,T3,T4,T5>::T_container
465 T_container;
466
467 return CartesianProduct<TinyVector<int,5>, T_container, 5>(
468 cp_traits<T1,T_container>::make(c1),
469 cp_traits<T2,T_container>::make(c2),
470 cp_traits<T3,T_container>::make(c3),
471 cp_traits<T4,T_container>::make(c4),
472 cp_traits<T5,T_container>::make(c5));
473 }
474
475 template<typename T1, typename T2, typename T3, typename T4, typename T5,
476 typename T6>
477 CartesianProduct<TinyVector<int,6>, _bz_typename
478 cp_findContainerType<T1,T2,T3,T4,T5,T6>::T_container, 6>
479 indexSet(const T1& c1, const T2& c2, const T3& c3, const T4& c4, const T5& c5,
480 const T6& c6)
481 {
482 typedef _bz_typename cp_findContainerType<T1,T2,T3,T4,T5,T6>::T_container
483 T_container;
484
485 return CartesianProduct<TinyVector<int,6>, T_container, 6>(
486 cp_traits<T1,T_container>::make(c1),
487 cp_traits<T2,T_container>::make(c2),
488 cp_traits<T3,T_container>::make(c3),
489 cp_traits<T4,T_container>::make(c4),
490 cp_traits<T5,T_container>::make(c5),
491 cp_traits<T6,T_container>::make(c6));
492 }
493
494 template<typename T1, typename T2, typename T3, typename T4, typename T5,
495 typename T6, typename T7>
496 CartesianProduct<TinyVector<int,7>, _bz_typename
497 cp_findContainerType<T1,T2,T3,T4,T5,T6,T7>::T_container, 7>
498 indexSet(const T1& c1, const T2& c2, const T3& c3, const T4& c4, const T5& c5,
499 const T6& c6, const T7& c7)
500 {
501 typedef _bz_typename
502 cp_findContainerType<T1,T2,T3,T4,T5,T6,T7>::T_container
503 T_container;
504
505 return CartesianProduct<TinyVector<int,7>, T_container, 7>(
506 cp_traits<T1,T_container>::make(c1),
507 cp_traits<T2,T_container>::make(c2),
508 cp_traits<T3,T_container>::make(c3),
509 cp_traits<T4,T_container>::make(c4),
510 cp_traits<T5,T_container>::make(c5),
511 cp_traits<T6,T_container>::make(c6),
512 cp_traits<T7,T_container>::make(c7));
513 }
514
515 template<typename T1, typename T2, typename T3, typename T4, typename T5,
516 typename T6, typename T7, typename T8>
517 CartesianProduct<TinyVector<int,8>, _bz_typename
518 cp_findContainerType<T1,T2,T3,T4,T5,T6,T7,T8>::T_container, 8>
519 indexSet(const T1& c1, const T2& c2, const T3& c3, const T4& c4, const T5& c5,
520 const T6& c6, const T7& c7, const T8& c8)
521 {
522 typedef _bz_typename
523 cp_findContainerType<T1,T2,T3,T4,T5,T6,T7,T8>::T_container
524 T_container;
525
526 return CartesianProduct<TinyVector<int,8>, T_container, 8>(
527 cp_traits<T1,T_container>::make(c1),
528 cp_traits<T2,T_container>::make(c2),
529 cp_traits<T3,T_container>::make(c3),
530 cp_traits<T4,T_container>::make(c4),
531 cp_traits<T5,T_container>::make(c5),
532 cp_traits<T6,T_container>::make(c6),
533 cp_traits<T7,T_container>::make(c7),
534 cp_traits<T8,T_container>::make(c8));
535 }
536
537 template<typename T1, typename T2, typename T3, typename T4, typename T5,
538 typename T6, typename T7, typename T8, typename T9>
539 CartesianProduct<TinyVector<int,9>, _bz_typename
540 cp_findContainerType<T1,T2,T3,T4,T5,T6,T7,T8,T9>::T_container, 9>
541 indexSet(const T1& c1, const T2& c2, const T3& c3, const T4& c4, const T5& c5,
542 const T6& c6, const T7& c7, const T8& c8, const T9& c9)
543 {
544 typedef _bz_typename
545 cp_findContainerType<T1,T2,T3,T4,T5,T6,T7,T8,T9>::T_container
546 T_container;
547
548 return CartesianProduct<TinyVector<int,9>, T_container, 9>(
549 cp_traits<T1,T_container>::make(c1),
550 cp_traits<T2,T_container>::make(c2),
551 cp_traits<T3,T_container>::make(c3),
552 cp_traits<T4,T_container>::make(c4),
553 cp_traits<T5,T_container>::make(c5),
554 cp_traits<T6,T_container>::make(c6),
555 cp_traits<T7,T_container>::make(c7),
556 cp_traits<T8,T_container>::make(c8),
557 cp_traits<T9,T_container>::make(c9));
558 }
559
560 template<typename T1, typename T2, typename T3, typename T4, typename T5,
561 typename T6, typename T7, typename T8, typename T9, typename T10>
562 CartesianProduct<TinyVector<int,10>, _bz_typename
563 cp_findContainerType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>::T_container, 10>
564 indexSet(const T1& c1, const T2& c2, const T3& c3, const T4& c4, const T5& c5,
565 const T6& c6, const T7& c7, const T8& c8, const T9& c9, const T10& c10)
566 {
567 typedef _bz_typename
568 cp_findContainerType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>::T_container
569 T_container;
570
571 return CartesianProduct<TinyVector<int,10>, T_container, 10>(
572 cp_traits<T1,T_container>::make(c1),
573 cp_traits<T2,T_container>::make(c2),
574 cp_traits<T3,T_container>::make(c3),
575 cp_traits<T4,T_container>::make(c4),
576 cp_traits<T5,T_container>::make(c5),
577 cp_traits<T6,T_container>::make(c6),
578 cp_traits<T7,T_container>::make(c7),
579 cp_traits<T8,T_container>::make(c8),
580 cp_traits<T9,T_container>::make(c9),
581 cp_traits<T10,T_container>::make(c10));
582 }
583
584 template<typename T1, typename T2, typename T3, typename T4, typename T5,
585 typename T6, typename T7, typename T8, typename T9, typename T10,
586 typename T11>
587 CartesianProduct<TinyVector<int,11>, _bz_typename
588 cp_findContainerType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::T_container, 11>
589 indexSet(const T1& c1, const T2& c2, const T3& c3, const T4& c4, const T5& c5,
590 const T6& c6, const T7& c7, const T8& c8, const T9& c9, const T10& c10,
591 const T11& c11)
592 {
593 typedef _bz_typename
594 cp_findContainerType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::T_container
595 T_container;
596
597 return CartesianProduct<TinyVector<int,11>, T_container, 11>(
598 cp_traits<T1,T_container>::make(c1),
599 cp_traits<T2,T_container>::make(c2),
600 cp_traits<T3,T_container>::make(c3),
601 cp_traits<T4,T_container>::make(c4),
602 cp_traits<T5,T_container>::make(c5),
603 cp_traits<T6,T_container>::make(c6),
604 cp_traits<T7,T_container>::make(c7),
605 cp_traits<T8,T_container>::make(c8),
606 cp_traits<T9,T_container>::make(c9),
607 cp_traits<T10,T_container>::make(c10),
608 cp_traits<T11,T_container>::make(c11));
609 }
610
611 }
612
613 #endif // BZ_ARRAY_INDIRECT_H
614