← Back to branch summary

~ubuntu-branches/ubuntu/raring/blitz++/raring

« back to all changes in this revision

Viewing changes to blitz/array/indirect.h

  • Committer: Bazaar Package Importer
  • Author(s): Konstantinos Margaritis
  • Date: 2005-02-28 20:25:01 UTC
  • mfrom: (2.1.2 hoary)
  • Revision ID: james.westby@ubuntu.com-20050228202501-3i4f2sknnprsqfhz
Tags: 1:0.8-4
http://bugs.debian.org/297323
Added missing build-depends (Closes: #297323)

Show diffs side-by-side

added added

removed removed

Lines of Context:
blitz/array/indirect.h
 
1
/***************************************************************************
 
2
 * blitz/array/indirect.h  Array indirection
 
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
 
1
24
#ifndef BZ_ARRAY_INDIRECT_H
2
25
#define BZ_ARRAY_INDIRECT_H
3
26
 
6
29
 
7
30
BZ_NAMESPACE(blitz)
8
31
 
9
 
template<class T_array, class T_index>
 
32
template<typename T_array, typename T_index>
10
33
class IndirectArray {
11
34
 
12
35
public:
14
37
        : array_(array), index_(index)
15
38
    { }
16
39
 
17
 
    template<class T_expr>
 
40
    template<typename T_expr>
18
41
    void operator=(T_expr expr);
19
42
 
20
43
protected:
23
46
};
24
47
 
25
48
// Forward declarations
26
 
template<class T_array, class T_arrayiter, class T_subdomain, class T_expr>
 
49
template<typename T_array, typename T_arrayiter, typename T_subdomain, typename T_expr>
27
50
inline void applyOverSubdomain(const T_array& array, T_arrayiter& arrayIter,
28
51
    T_subdomain subdomain, T_expr expr);
29
 
template<class T_array, class T_arrayiter, int N_rank, class T_expr>
 
52
template<typename T_array, typename T_arrayiter, int N_rank, typename T_expr>
30
53
inline void applyOverSubdomain(const T_array& array, T_arrayiter& arrayIter,
31
54
    RectDomain<N_rank> subdomain,
32
55
    T_expr expr);
33
56
 
34
 
template<class T_array, class T_index> template<class T_rhs>
 
57
template<typename T_array, typename T_index> template<typename T_rhs>
35
58
void IndirectArray<T_array, T_index>::operator=(T_rhs rhs)
36
59
{
37
60
    typedef _bz_typename asExpr<T_rhs>::T_expr T_expr;
49
72
    }
50
73
}
51
74
 
52
 
template<class T_array, class T_arrayiter, class T_subdomain, class T_expr>
53
 
inline void applyOverSubdomain(const T_array& array, T_arrayiter& arrayIter, 
 
75
template<typename T_array, typename T_arrayiter, typename T_subdomain, typename T_expr>
 
76
inline void applyOverSubdomain(const T_array& BZ_DEBUG_PARAM(array), T_arrayiter& arrayIter, 
54
77
    T_subdomain subdomain, T_expr expr)
55
78
{
56
79
    BZPRECHECK(array.isInRange(subdomain),
67
90
}
68
91
 
69
92
// Specialization for RectDomain<N>
70
 
template<class T_array, class T_arrayiter, int N_rank, class T_expr>
71
 
inline void applyOverSubdomain(const T_array& array, T_arrayiter& arrayIter, 
 
93
template<typename T_array, typename T_arrayiter, int N_rank, typename T_expr>
 
94
inline void applyOverSubdomain(const T_array& BZ_DEBUG_PARAM(array), T_arrayiter& arrayIter, 
72
95
    RectDomain<N_rank> subdomain,
73
96
    T_expr expr)
74
97
{
129
152
 
130
153
#ifdef BZ_USE_FAST_READ_ARRAY_EXPR
131
154
 
132
 
    _bz_bool useUnitStride = arrayIter.isUnitStride(stripDim)
 
155
    bool useUnitStride = arrayIter.isUnitStride(stripDim)
133
156
          && expr.isUnitStride(stripDim);
134
157
 
135
158
    int lbound = subdomain.lbound(stripDim); 
137
160
 
138
161
    if (useUnitStride)
139
162
    {
140
 
        T_numtype* _bz_restrict data = const_cast<T_numtype*>(arrayIter.data());
 
163
        T_numtype* restrict data = const_cast<T_numtype*>(arrayIter.data());
141
164
 
142
165
        int length = ubound - lbound + 1;
143
166
        for (int i=0; i < length; ++i)
144
 
            data[i] = expr.fastRead(i);
 
167
            *data++ = expr.fastRead(i);
145
168
    }
146
169
    else {
147
170
#endif
163
186
}
164
187
 
165
188
// Global functions for cartesian product of index sets
166
 
template<class T_container>
 
189
template<typename T_container>
167
190
CartesianProduct<TinyVector<int,2>,T_container,2>
168
191
indexSet(const T_container& container0, const T_container& container1)
169
192
{
172
195
        const_cast<T_container&>(container1));
173
196
}
174
197
 
175
 
template<class T_container>
 
198
template<typename T_container>
176
199
CartesianProduct<TinyVector<int,3>,T_container,3>
177
200
indexSet(const T_container& container0, const T_container& container1,
178
201
    const T_container& container2)
183
206
        const_cast<T_container&>(container2));
184
207
}
185
208
 
 
209
template<typename T_container>
 
210
CartesianProduct<TinyVector<int,4>,T_container,4>
 
211
indexSet(const T_container& container0, const T_container& container1,
 
212
    const T_container& container2, const T_container& container3)
 
213
{
 
214
    return CartesianProduct<TinyVector<int,4>,T_container,4>(
 
215
        const_cast<T_container&>(container0), 
 
216
        const_cast<T_container&>(container1), 
 
217
        const_cast<T_container&>(container2),
 
218
        const_cast<T_container&>(container3));
 
219
}
 
220
 
 
221
template<typename T_container>
 
222
CartesianProduct<TinyVector<int,5>,T_container,5>
 
223
indexSet(const T_container& container0, const T_container& container1,
 
224
    const T_container& container2, const T_container& container3,
 
225
    const T_container& container4)
 
226
{
 
227
    return CartesianProduct<TinyVector<int,5>,T_container,5>(
 
228
        const_cast<T_container&>(container0), 
 
229
        const_cast<T_container&>(container1), 
 
230
        const_cast<T_container&>(container2),
 
231
        const_cast<T_container&>(container3),
 
232
        const_cast<T_container&>(container4));
 
233
}
 
234
 
 
235
template<typename T_container>
 
236
CartesianProduct<TinyVector<int,6>,T_container,6>
 
237
indexSet(const T_container& container0, const T_container& container1,
 
238
    const T_container& container2, const T_container& container3,
 
239
    const T_container& container4, const T_container& container5)
 
240
{
 
241
    return CartesianProduct<TinyVector<int,6>,T_container,6>(
 
242
        const_cast<T_container&>(container0), 
 
243
        const_cast<T_container&>(container1), 
 
244
        const_cast<T_container&>(container2),
 
245
        const_cast<T_container&>(container3),
 
246
        const_cast<T_container&>(container4),
 
247
        const_cast<T_container&>(container5));
 
248
}
 
249
 
 
250
template<typename T_container>
 
251
CartesianProduct<TinyVector<int,7>,T_container,7>
 
252
indexSet(const T_container& container0, const T_container& container1,
 
253
    const T_container& container2, const T_container& container3,
 
254
    const T_container& container4, const T_container& container5,
 
255
    const T_container& container6)
 
256
{
 
257
    return CartesianProduct<TinyVector<int,7>,T_container,7>(
 
258
        const_cast<T_container&>(container0), 
 
259
        const_cast<T_container&>(container1), 
 
260
        const_cast<T_container&>(container2),
 
261
        const_cast<T_container&>(container3),
 
262
        const_cast<T_container&>(container4),
 
263
        const_cast<T_container&>(container5),
 
264
        const_cast<T_container&>(container6));
 
265
}
 
266
 
 
267
template<typename T_container>
 
268
CartesianProduct<TinyVector<int,8>,T_container,8>
 
269
indexSet(const T_container& container0, const T_container& container1,
 
270
    const T_container& container2, const T_container& container3,
 
271
    const T_container& container4, const T_container& container5,
 
272
    const T_container& container6, const T_container& container7)
 
273
{
 
274
    return CartesianProduct<TinyVector<int,8>,T_container,8>(
 
275
        const_cast<T_container&>(container0), 
 
276
        const_cast<T_container&>(container1), 
 
277
        const_cast<T_container&>(container2),
 
278
        const_cast<T_container&>(container3),
 
279
        const_cast<T_container&>(container4),
 
280
        const_cast<T_container&>(container5),
 
281
        const_cast<T_container&>(container6),
 
282
        const_cast<T_container&>(container7));
 
283
}
 
284
 
 
285
template<typename T_container>
 
286
CartesianProduct<TinyVector<int,9>,T_container,9>
 
287
indexSet(const T_container& container0, const T_container& container1,
 
288
    const T_container& container2, const T_container& container3,
 
289
    const T_container& container4, const T_container& container5,
 
290
    const T_container& container6, const T_container& container7,
 
291
    const T_container& container8)
 
292
{
 
293
    return CartesianProduct<TinyVector<int,9>,T_container,9>(
 
294
        const_cast<T_container&>(container0), 
 
295
        const_cast<T_container&>(container1), 
 
296
        const_cast<T_container&>(container2),
 
297
        const_cast<T_container&>(container3),
 
298
        const_cast<T_container&>(container4),
 
299
        const_cast<T_container&>(container5),
 
300
        const_cast<T_container&>(container6),
 
301
        const_cast<T_container&>(container7),
 
302
        const_cast<T_container&>(container8));
 
303
}
 
304
 
 
305
template<typename T_container>
 
306
CartesianProduct<TinyVector<int,10>,T_container,10>
 
307
indexSet(const T_container& container0, const T_container& container1,
 
308
    const T_container& container2, const T_container& container3,
 
309
    const T_container& container4, const T_container& container5,
 
310
    const T_container& container6, const T_container& container7,
 
311
    const T_container& container8, const T_container& container9)
 
312
{
 
313
    return CartesianProduct<TinyVector<int,10>,T_container,10>(
 
314
        const_cast<T_container&>(container0), 
 
315
        const_cast<T_container&>(container1), 
 
316
        const_cast<T_container&>(container2),
 
317
        const_cast<T_container&>(container3),
 
318
        const_cast<T_container&>(container4),
 
319
        const_cast<T_container&>(container5),
 
320
        const_cast<T_container&>(container6),
 
321
        const_cast<T_container&>(container7),
 
322
        const_cast<T_container&>(container8),
 
323
        const_cast<T_container&>(container9));
 
324
}
 
325
 
 
326
template<typename T_container>
 
327
CartesianProduct<TinyVector<int,11>,T_container,11>
 
328
indexSet(const T_container& container0, const T_container& container1,
 
329
    const T_container& container2, const T_container& container3,
 
330
    const T_container& container4, const T_container& container5,
 
331
    const T_container& container6, const T_container& container7,
 
332
    const T_container& container8, const T_container& container9,
 
333
    const T_container& container10)
 
334
{
 
335
    return CartesianProduct<TinyVector<int,11>,T_container,11>(
 
336
        const_cast<T_container&>(container0), 
 
337
        const_cast<T_container&>(container1), 
 
338
        const_cast<T_container&>(container2),
 
339
        const_cast<T_container&>(container3),
 
340
        const_cast<T_container&>(container4),
 
341
        const_cast<T_container&>(container5),
 
342
        const_cast<T_container&>(container6),
 
343
        const_cast<T_container&>(container7),
 
344
        const_cast<T_container&>(container8),
 
345
        const_cast<T_container&>(container9),
 
346
        const_cast<T_container&>(container10));
 
347
}
 
348
 
186
349
// Mixture of singletons and containers, e.g. A[indexSet(I,3,K)]
187
350
 
188
351
// cp_findContainerType<T1,T2,T3,...,Tn>::T_container
194
357
//      cp_findContainerType<int,deque<int>,deque<int>>::T_container 
195
358
//        is deque<int>
196
359
 
197
 
template<class T1, class T2, class T3=int, class T4=int>
 
360
template<typename T1, typename T2, typename T3=int, typename T4=int,
 
361
         typename T5=int, typename T6=int, typename T7=int, typename T8=int,
 
362
         typename T9=int, typename T10=int, typename T11=int>
198
363
struct cp_findContainerType {
199
364
    typedef T1 T_container;
200
365
};
201
366
 
202
 
template<class T2, class T3, class T4>
203
 
struct cp_findContainerType<int,T2,T3,T4> {
204
 
    typedef _bz_typename cp_findContainerType<T2,T3,T4>::T_container T_container;
 
367
template<typename T2, typename T3, typename T4, typename T5, typename T6,
 
368
         typename T7, typename T8, typename T9, typename T10, typename T11>
 
369
struct cp_findContainerType<int,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> {
 
370
    typedef _bz_typename
 
371
        cp_findContainerType<T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::T_container
 
372
        T_container;
205
373
};
206
374
 
207
375
 
214
382
// Otherwise, T is assumed to be the same type as T2, and the original
215
383
// container is returned.
216
384
 
217
 
template<class T, class T2>
 
385
template<typename T, typename T2>
218
386
struct cp_traits {
219
387
    typedef T T_container;
220
388
 
222
390
    { return x; }
223
391
};
224
392
 
225
 
template<class T2>
 
393
template<typename T2>
226
394
struct cp_traits<int,T2> {
227
395
    typedef T2 T_container;
228
396
 
238
406
// and container arguments.  At least one integer must be
239
407
// specified.
240
408
 
241
 
template<class T1, class T2>
 
409
template<typename T1, typename T2>
242
410
CartesianProduct<TinyVector<int,2>, _bz_typename 
243
411
    cp_findContainerType<T1,T2>::T_container,2> 
244
412
indexSet(const T1& c1, const T2& c2)
251
419
          cp_traits<T2,T_container>::make(c2));
252
420
}
253
421
 
254
 
template<class T1, class T2, class T3>
 
422
template<typename T1, typename T2, typename T3>
255
423
CartesianProduct<TinyVector<int,3>, _bz_typename
256
424
    cp_findContainerType<T1,T2,T3>::T_container, 3>
257
425
indexSet(const T1& c1, const T2& c2, const T3& c3)
265
433
          cp_traits<T3,T_container>::make(c3));
266
434
}
267
435
 
 
436
template<typename T1, typename T2, typename T3, typename T4>
 
437
CartesianProduct<TinyVector<int,4>, _bz_typename
 
438
    cp_findContainerType<T1,T2,T3,T4>::T_container, 4>
 
439
indexSet(const T1& c1, const T2& c2, const T3& c3, const T4& c4)
 
440
{
 
441
    typedef _bz_typename cp_findContainerType<T1,T2,T3,T4>::T_container
 
442
        T_container;
 
443
 
 
444
    return CartesianProduct<TinyVector<int,4>, T_container, 4>(
 
445
          cp_traits<T1,T_container>::make(c1),
 
446
          cp_traits<T2,T_container>::make(c2),
 
447
          cp_traits<T3,T_container>::make(c3),
 
448
          cp_traits<T4,T_container>::make(c4));
 
449
}
 
450
 
 
451
template<typename T1, typename T2, typename T3, typename T4, typename T5>
 
452
CartesianProduct<TinyVector<int,5>, _bz_typename
 
453
    cp_findContainerType<T1,T2,T3,T4,T5>::T_container, 5>
 
454
indexSet(const T1& c1, const T2& c2, const T3& c3, const T4& c4, const T5& c5)
 
455
{
 
456
    typedef _bz_typename cp_findContainerType<T1,T2,T3,T4,T5>::T_container
 
457
        T_container;
 
458
 
 
459
    return CartesianProduct<TinyVector<int,5>, T_container, 5>(
 
460
          cp_traits<T1,T_container>::make(c1),
 
461
          cp_traits<T2,T_container>::make(c2),
 
462
          cp_traits<T3,T_container>::make(c3),
 
463
          cp_traits<T4,T_container>::make(c4),
 
464
          cp_traits<T5,T_container>::make(c5));
 
465
}
 
466
 
 
467
template<typename T1, typename T2, typename T3, typename T4, typename T5,
 
468
         typename T6>
 
469
CartesianProduct<TinyVector<int,6>, _bz_typename
 
470
    cp_findContainerType<T1,T2,T3,T4,T5,T6>::T_container, 6>
 
471
indexSet(const T1& c1, const T2& c2, const T3& c3, const T4& c4, const T5& c5,
 
472
    const T6& c6)
 
473
{
 
474
    typedef _bz_typename cp_findContainerType<T1,T2,T3,T4,T5,T6>::T_container
 
475
        T_container;
 
476
 
 
477
    return CartesianProduct<TinyVector<int,6>, T_container, 6>(
 
478
          cp_traits<T1,T_container>::make(c1),
 
479
          cp_traits<T2,T_container>::make(c2),
 
480
          cp_traits<T3,T_container>::make(c3),
 
481
          cp_traits<T4,T_container>::make(c4),
 
482
          cp_traits<T5,T_container>::make(c5),
 
483
          cp_traits<T6,T_container>::make(c6));
 
484
}
 
485
 
 
486
template<typename T1, typename T2, typename T3, typename T4, typename T5,
 
487
         typename T6, typename T7>
 
488
CartesianProduct<TinyVector<int,7>, _bz_typename
 
489
    cp_findContainerType<T1,T2,T3,T4,T5,T6,T7>::T_container, 7>
 
490
indexSet(const T1& c1, const T2& c2, const T3& c3, const T4& c4, const T5& c5,
 
491
    const T6& c6, const T7& c7)
 
492
{
 
493
    typedef _bz_typename
 
494
        cp_findContainerType<T1,T2,T3,T4,T5,T6,T7>::T_container
 
495
        T_container;
 
496
 
 
497
    return CartesianProduct<TinyVector<int,7>, T_container, 7>(
 
498
          cp_traits<T1,T_container>::make(c1),
 
499
          cp_traits<T2,T_container>::make(c2),
 
500
          cp_traits<T3,T_container>::make(c3),
 
501
          cp_traits<T4,T_container>::make(c4),
 
502
          cp_traits<T5,T_container>::make(c5),
 
503
          cp_traits<T6,T_container>::make(c6),
 
504
          cp_traits<T7,T_container>::make(c7));
 
505
}
 
506
 
 
507
template<typename T1, typename T2, typename T3, typename T4, typename T5,
 
508
         typename T6, typename T7, typename T8>
 
509
CartesianProduct<TinyVector<int,8>, _bz_typename
 
510
    cp_findContainerType<T1,T2,T3,T4,T5,T6,T7,T8>::T_container, 8>
 
511
indexSet(const T1& c1, const T2& c2, const T3& c3, const T4& c4, const T5& c5,
 
512
    const T6& c6, const T7& c7, const T8& c8)
 
513
{
 
514
    typedef _bz_typename
 
515
        cp_findContainerType<T1,T2,T3,T4,T5,T6,T7,T8>::T_container
 
516
        T_container;
 
517
 
 
518
    return CartesianProduct<TinyVector<int,8>, T_container, 8>(
 
519
          cp_traits<T1,T_container>::make(c1),
 
520
          cp_traits<T2,T_container>::make(c2),
 
521
          cp_traits<T3,T_container>::make(c3),
 
522
          cp_traits<T4,T_container>::make(c4),
 
523
          cp_traits<T5,T_container>::make(c5),
 
524
          cp_traits<T6,T_container>::make(c6),
 
525
          cp_traits<T7,T_container>::make(c7),
 
526
          cp_traits<T8,T_container>::make(c8));
 
527
}
 
528
 
 
529
template<typename T1, typename T2, typename T3, typename T4, typename T5,
 
530
         typename T6, typename T7, typename T8, typename T9>
 
531
CartesianProduct<TinyVector<int,9>, _bz_typename
 
532
    cp_findContainerType<T1,T2,T3,T4,T5,T6,T7,T8,T9>::T_container, 9>
 
533
indexSet(const T1& c1, const T2& c2, const T3& c3, const T4& c4, const T5& c5,
 
534
    const T6& c6, const T7& c7, const T8& c8, const T9& c9)
 
535
{
 
536
    typedef _bz_typename
 
537
        cp_findContainerType<T1,T2,T3,T4,T5,T6,T7,T8,T9>::T_container
 
538
        T_container;
 
539
 
 
540
    return CartesianProduct<TinyVector<int,9>, T_container, 9>(
 
541
          cp_traits<T1,T_container>::make(c1),
 
542
          cp_traits<T2,T_container>::make(c2),
 
543
          cp_traits<T3,T_container>::make(c3),
 
544
          cp_traits<T4,T_container>::make(c4),
 
545
          cp_traits<T5,T_container>::make(c5),
 
546
          cp_traits<T6,T_container>::make(c6),
 
547
          cp_traits<T7,T_container>::make(c7),
 
548
          cp_traits<T8,T_container>::make(c8),
 
549
          cp_traits<T9,T_container>::make(c9));
 
550
}
 
551
 
 
552
template<typename T1, typename T2, typename T3, typename T4, typename T5,
 
553
         typename T6, typename T7, typename T8, typename T9, typename T10>
 
554
CartesianProduct<TinyVector<int,10>, _bz_typename
 
555
    cp_findContainerType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>::T_container, 10>
 
556
indexSet(const T1& c1, const T2& c2, const T3& c3, const T4& c4, const T5& c5,
 
557
    const T6& c6, const T7& c7, const T8& c8, const T9& c9, const T10& c10)
 
558
{
 
559
    typedef _bz_typename
 
560
        cp_findContainerType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>::T_container
 
561
        T_container;
 
562
 
 
563
    return CartesianProduct<TinyVector<int,10>, T_container, 10>(
 
564
          cp_traits<T1,T_container>::make(c1),
 
565
          cp_traits<T2,T_container>::make(c2),
 
566
          cp_traits<T3,T_container>::make(c3),
 
567
          cp_traits<T4,T_container>::make(c4),
 
568
          cp_traits<T5,T_container>::make(c5),
 
569
          cp_traits<T6,T_container>::make(c6),
 
570
          cp_traits<T7,T_container>::make(c7),
 
571
          cp_traits<T8,T_container>::make(c8),
 
572
          cp_traits<T9,T_container>::make(c9),
 
573
          cp_traits<T10,T_container>::make(c10));
 
574
}
 
575
 
 
576
template<typename T1, typename T2, typename T3, typename T4, typename T5,
 
577
         typename T6, typename T7, typename T8, typename T9, typename T10,
 
578
         typename T11>
 
579
CartesianProduct<TinyVector<int,11>, _bz_typename
 
580
    cp_findContainerType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::T_container, 11>
 
581
indexSet(const T1& c1, const T2& c2, const T3& c3, const T4& c4, const T5& c5,
 
582
    const T6& c6, const T7& c7, const T8& c8, const T9& c9, const T10& c10,
 
583
    const T11& c11)
 
584
{
 
585
    typedef _bz_typename
 
586
        cp_findContainerType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::T_container
 
587
        T_container;
 
588
 
 
589
    return CartesianProduct<TinyVector<int,11>, T_container, 11>(
 
590
          cp_traits<T1,T_container>::make(c1),
 
591
          cp_traits<T2,T_container>::make(c2),
 
592
          cp_traits<T3,T_container>::make(c3),
 
593
          cp_traits<T4,T_container>::make(c4),
 
594
          cp_traits<T5,T_container>::make(c5),
 
595
          cp_traits<T6,T_container>::make(c6),
 
596
          cp_traits<T7,T_container>::make(c7),
 
597
          cp_traits<T8,T_container>::make(c8),
 
598
          cp_traits<T9,T_container>::make(c9),
 
599
          cp_traits<T10,T_container>::make(c10),
 
600
          cp_traits<T11,T_container>::make(c11));
 
601
}
 
602
 
268
603
BZ_NAMESPACE_END
269
604
 
270
605
#endif // BZ_ARRAY_INDIRECT_H