source: XIOS/dev/dev_olga/src/extern/blitz/include/blitz/array/indirect.h @ 1022

Last change on this file since 1022 was 1022, checked in by mhnguyen, 7 years ago
File size: 22.9 KB
Line 
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
38BZ_NAMESPACE(blitz)
39
40template<typename T_array, typename T_index>
41class IndirectArray {
42
43public:
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
51protected:
52    T_array& array_;
53    T_index& index_;
54};
55
56// Forward declarations
57template<typename T_array, typename T_arrayiter, typename T_subdomain, typename T_expr>
58inline void applyOverSubdomain(const T_array& array, T_arrayiter& arrayIter,
59    T_subdomain subdomain, T_expr expr);
60template<typename T_array, typename T_arrayiter, int N_rank, typename T_expr>
61inline void applyOverSubdomain(const T_array& array, T_arrayiter& arrayIter,
62    RectDomain<N_rank> subdomain,
63    T_expr expr);
64
65template<typename T_array, typename T_index> template<typename T_rhs>
66void 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
83template<typename T_array, typename T_arrayiter, typename T_subdomain, typename T_expr>
84inline 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>
101template<typename T_array, typename T_arrayiter, int N_rank, typename T_expr>
102inline 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
197template<typename T_container>
198CartesianProduct<TinyVector<int,2>,T_container,2>
199indexSet(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
206template<typename T_container>
207CartesianProduct<TinyVector<int,3>,T_container,3>
208indexSet(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
217template<typename T_container>
218CartesianProduct<TinyVector<int,4>,T_container,4>
219indexSet(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
229template<typename T_container>
230CartesianProduct<TinyVector<int,5>,T_container,5>
231indexSet(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
243template<typename T_container>
244CartesianProduct<TinyVector<int,6>,T_container,6>
245indexSet(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
258template<typename T_container>
259CartesianProduct<TinyVector<int,7>,T_container,7>
260indexSet(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
275template<typename T_container>
276CartesianProduct<TinyVector<int,8>,T_container,8>
277indexSet(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
293template<typename T_container>
294CartesianProduct<TinyVector<int,9>,T_container,9>
295indexSet(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
313template<typename T_container>
314CartesianProduct<TinyVector<int,10>,T_container,10>
315indexSet(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
334template<typename T_container>
335CartesianProduct<TinyVector<int,11>,T_container,11>
336indexSet(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
368template<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>
371struct cp_findContainerType {
372    typedef T1 T_container;
373};
374
375template<typename T2, typename T3, typename T4, typename T5, typename T6,
376         typename T7, typename T8, typename T9, typename T10, typename T11>
377struct 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
393template<typename T, typename T2>
394struct cp_traits {
395    typedef T T_container;
396
397    static const T_container& make(const T& x)
398    { return x; }
399};
400
401template<typename T2>
402struct 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
417template<typename T1, typename T2>
418CartesianProduct<TinyVector<int,2>, _bz_typename
419    cp_findContainerType<T1,T2>::T_container,2> 
420indexSet(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
430template<typename T1, typename T2, typename T3>
431CartesianProduct<TinyVector<int,3>, _bz_typename
432    cp_findContainerType<T1,T2,T3>::T_container, 3>
433indexSet(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
444template<typename T1, typename T2, typename T3, typename T4>
445CartesianProduct<TinyVector<int,4>, _bz_typename
446    cp_findContainerType<T1,T2,T3,T4>::T_container, 4>
447indexSet(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
459template<typename T1, typename T2, typename T3, typename T4, typename T5>
460CartesianProduct<TinyVector<int,5>, _bz_typename
461    cp_findContainerType<T1,T2,T3,T4,T5>::T_container, 5>
462indexSet(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
475template<typename T1, typename T2, typename T3, typename T4, typename T5,
476         typename T6>
477CartesianProduct<TinyVector<int,6>, _bz_typename
478    cp_findContainerType<T1,T2,T3,T4,T5,T6>::T_container, 6>
479indexSet(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
494template<typename T1, typename T2, typename T3, typename T4, typename T5,
495         typename T6, typename T7>
496CartesianProduct<TinyVector<int,7>, _bz_typename
497    cp_findContainerType<T1,T2,T3,T4,T5,T6,T7>::T_container, 7>
498indexSet(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
515template<typename T1, typename T2, typename T3, typename T4, typename T5,
516         typename T6, typename T7, typename T8>
517CartesianProduct<TinyVector<int,8>, _bz_typename
518    cp_findContainerType<T1,T2,T3,T4,T5,T6,T7,T8>::T_container, 8>
519indexSet(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
537template<typename T1, typename T2, typename T3, typename T4, typename T5,
538         typename T6, typename T7, typename T8, typename T9>
539CartesianProduct<TinyVector<int,9>, _bz_typename
540    cp_findContainerType<T1,T2,T3,T4,T5,T6,T7,T8,T9>::T_container, 9>
541indexSet(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
560template<typename T1, typename T2, typename T3, typename T4, typename T5,
561         typename T6, typename T7, typename T8, typename T9, typename T10>
562CartesianProduct<TinyVector<int,10>, _bz_typename
563    cp_findContainerType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>::T_container, 10>
564indexSet(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
584template<typename T1, typename T2, typename T3, typename T4, typename T5,
585         typename T6, typename T7, typename T8, typename T9, typename T10,
586         typename T11>
587CartesianProduct<TinyVector<int,11>, _bz_typename
588    cp_findContainerType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::T_container, 11>
589indexSet(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
611BZ_NAMESPACE_END
612
613#endif // BZ_ARRAY_INDIRECT_H
Note: See TracBrowser for help on using the repository browser.