source: XMLIO_V2/external/include/blitz/array/map.h @ 80

Last change on this file since 80 was 80, checked in by ymipsl, 14 years ago

ajout lib externe
  • Property svn:eol-style set to native
File size: 14.9 KB
Line 
1// -*- C++ -*-
2/***************************************************************************
3 * blitz/array/map.h      Declaration of the ArrayIndexMapping class
4 *
5 * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * Suggestions:          blitz-dev@oonumerics.org
18 * Bugs:                 blitz-bugs@oonumerics.org
19 *
20 * For more information, please see the Blitz++ Home Page:
21 *    http://oonumerics.org/blitz/
22 *
23 ****************************************************************************/
24
25/*
26 * ArrayIndexMapping is used to implement tensor array notation.  For
27 * example:
28 *
29 * Array<float, 2> A, B;
30 * firstIndex i;
31 * secondIndex j;
32 * thirdIndex k;
33 * Array<float, 3> C = A(i,j) * B(j,k);
34 *
35 * For expression templates purposes, something like B(j,k) is represented
36 * by an instance of class ArrayIndexMapping.  This class maps an array onto
37 * the destination array coordinate system, e.g. B(j,k) -> C(i,j,k)
38 */
39
40#ifndef BZ_ARRAYMAP_H
41#define BZ_ARRAYMAP_H
42
43#ifndef BZ_ARRAY_H
44 #error <blitz/array/map.h> must be included via <blitz/array.h>
45#endif
46
47BZ_NAMESPACE(blitz)
48
49/*
50 * _bz_doArrayIndexMapping is a helper class.  It is specialized for
51 * ranks 1, 2, 3, ..., 11.
52 */
53
54template<int N_rank>
55struct _bz_doArrayIndexMapping {
56    template<typename T_numtype, int N_destRank>
57    static T_numtype map(const Array<T_numtype, N_rank>&, 
58        const TinyVector<int,N_destRank>&, int, int, int, int, int, int,
59        int, int, int, int, int)
60    {
61        // If you try to use an array index mapping on an array with
62        // rank greater than 11, then you'll get a precondition failure
63        // here.
64        BZPRECONDITION(0);
65        return T_numtype();
66    }
67};
68
69template<>
70struct _bz_doArrayIndexMapping<1> {
71    template<typename T_numtype, int N_destRank>
72    static T_numtype map(const Array<T_numtype, 1>& array,
73        const TinyVector<int,N_destRank>& index, int i0, int, int, int, int, 
74        int, int, int, int, int, int)
75    {
76        return array(index[i0]);
77    }
78};
79
80
81template<>
82struct _bz_doArrayIndexMapping<2> {
83    template<typename T_numtype, int N_destRank>
84    static T_numtype map(const Array<T_numtype, 2>& array,
85        const TinyVector<int,N_destRank>& index, int i0, int i1, int, 
86        int, int, int, int, int, int, int, int)
87    {
88        return array(index[i0], index[i1]);
89    }
90};
91
92template<>
93struct _bz_doArrayIndexMapping<3> {
94    template<typename T_numtype, int N_destRank>
95    static T_numtype map(const Array<T_numtype, 3>& array,
96        const TinyVector<int,N_destRank>& index, int i0, int i1, int i2,
97        int, int, int, int, int, int, int, int)
98    {
99        return array(index[i0], index[i1], index[i2]);
100    }
101};
102
103template<>
104struct _bz_doArrayIndexMapping<4> {
105    template<typename T_numtype, int N_destRank>
106    static T_numtype map(const Array<T_numtype, 4>& array,
107        const TinyVector<int,N_destRank>& index, int i0, int i1, int i2,
108        int i3, int, int, int, int, int, int, int)
109    {
110        return array(index[i0], index[i1], index[i2], index[i3]);
111    }
112};
113
114template<>
115struct _bz_doArrayIndexMapping<5> {
116    template<typename T_numtype, int N_destRank>
117    static T_numtype map(const Array<T_numtype, 5>& array,
118        const TinyVector<int,N_destRank>& index, int i0, int i1, int i2,
119        int i3, int i4, int, int, int, int, int, int)
120    {
121        return array(index[i0], index[i1], index[i2], index[i3], index[i4]);
122    }
123};
124
125template<>
126struct _bz_doArrayIndexMapping<6> {
127    template<typename T_numtype, int N_destRank>
128    static T_numtype map(const Array<T_numtype, 6>& array,
129        const TinyVector<int,N_destRank>& index, int i0, int i1, int i2,
130        int i3, int i4, int i5, int, int, int, int, int)
131    {
132        return array(index[i0], index[i1], index[i2], index[i3], index[i4],
133            index[i5]);
134    }
135};
136
137template<>
138struct _bz_doArrayIndexMapping<7> {
139    template<typename T_numtype, int N_destRank>
140    static T_numtype map(const Array<T_numtype, 7>& array,
141        const TinyVector<int,N_destRank>& index, int i0, int i1, int i2,
142        int i3, int i4, int i5, int i6, int, int, int, int)
143    {
144        return array(index[i0], index[i1], index[i2], index[i3], index[i4],
145            index[i5], index[i6]);
146    }
147};
148
149template<>
150struct _bz_doArrayIndexMapping<8> {
151    template<typename T_numtype, int N_destRank>
152    static T_numtype map(const Array<T_numtype, 8>& array,
153        const TinyVector<int,N_destRank>& index, int i0, int i1, int i2,
154        int i3, int i4, int i5, int i6, int i7, int, int, int)
155    {
156        return array(index[i0], index[i1], index[i2], index[i3], index[i4],
157            index[i5], index[i6], index[i7]);
158    }
159};
160
161template<>
162struct _bz_doArrayIndexMapping<9> {
163    template<typename T_numtype, int N_destRank>
164    static T_numtype map(const Array<T_numtype, 9>& array,
165        const TinyVector<int,N_destRank>& index, int i0, int i1, int i2,
166        int i3, int i4, int i5, int i6, int i7, int i8, int, int)
167    {
168        return array(index[i0], index[i1], index[i2], index[i3], index[i4],
169            index[i5], index[i6], index[i7], index[i8]);
170    }
171};
172
173template<>
174struct _bz_doArrayIndexMapping<10> {
175    template<typename T_numtype, int N_destRank>
176    static T_numtype map(const Array<T_numtype, 10>& array,
177        const TinyVector<int,N_destRank>& index, int i0, int i1, int i2,
178        int i3, int i4, int i5, int i6, int i7, int i8, int i9, int)
179    {
180        return array(index[i0], index[i1], index[i2], index[i3], index[i4],
181            index[i5], index[i6], index[i7], index[i8], index[i9]);
182    }
183};
184
185template<>
186struct _bz_doArrayIndexMapping<11> {
187    template<typename T_numtype, int N_destRank>
188    static T_numtype map(const Array<T_numtype, 11>& array,
189        const TinyVector<int,N_destRank>& index, int i0, int i1, int i2,
190        int i3, int i4, int i5, int i6, int i7, int i8, int i9, int i10)
191    {
192        return array(index[i0], index[i1], index[i2], index[i3], index[i4],
193            index[i5], index[i6], index[i7], index[i8], index[i9],
194            index[i10]);
195    }
196};
197
198template<typename P_numtype, int N_rank, int N_map0, int N_map1=0, int N_map2=0,
199    int N_map3=0, int N_map4=0, int N_map5=0, int N_map6=0, int N_map7=0, 
200    int N_map8=0, int N_map9=0, int N_map10=0>
201class ArrayIndexMapping {
202public:
203    typedef P_numtype T_numtype;
204    typedef const Array<T_numtype,N_rank>& T_ctorArg1;
205    typedef int                            T_ctorArg2;    // dummy
206
207    /*
208     * This enum block finds the maximum of the N_map0, N_map1, ..., N_map10
209     * parameters and stores it in maxRank10.  The rank of the expression is
210     * then maxRank10 + 1, since the IndexPlaceholders start at 0 rather than
211     * 1. 
212     */
213    static const int
214        maxRank1 = (N_map0 > N_map1) ? N_map0 : N_map1,
215        maxRank2 = (N_map2 > maxRank1) ? N_map2 : maxRank1,
216        maxRank3 = (N_map3 > maxRank2) ? N_map3 : maxRank2,
217        maxRank4 = (N_map4 > maxRank3) ? N_map4 : maxRank3,
218        maxRank5 = (N_map5 > maxRank4) ? N_map5 : maxRank4,
219        maxRank6 = (N_map6 > maxRank5) ? N_map6 : maxRank5,
220        maxRank7 = (N_map7 > maxRank6) ? N_map7 : maxRank6,
221        maxRank8 = (N_map8 > maxRank7) ? N_map8 : maxRank7,
222        maxRank9 = (N_map9 > maxRank8) ? N_map9 : maxRank8,
223        maxRank10 = (N_map10 > maxRank9) ? N_map10 : maxRank9;
224
225    static const int 
226        numArrayOperands = 1, 
227        numIndexPlaceholders = 1,
228        rank = maxRank10 + 1;
229
230    ArrayIndexMapping(const Array<T_numtype, N_rank>& array)
231        : array_(array)
232    { 
233    }
234
235    ArrayIndexMapping(const ArrayIndexMapping<T_numtype,N_rank,N_map0,
236        N_map1,N_map2,N_map3,N_map4,N_map5,N_map6,N_map7,N_map8,N_map9,
237        N_map10>& z)
238        : array_(z.array_)
239    { 
240    }
241
242#ifdef BZ_ARRAY_EXPR_PASS_INDEX_BY_VALUE
243    template<int N_destRank>
244    T_numtype operator()(TinyVector<int, N_destRank> i)
245    {
246        return _bz_doArrayIndexMapping<N_rank>::map(array_, i,
247            N_map0, N_map1, N_map2, N_map3, N_map4, N_map5, N_map6,
248            N_map7, N_map8, N_map9, N_map10);
249    }
250#else
251    template<int N_destRank>
252    T_numtype operator()(const TinyVector<int, N_destRank>& i)
253    {
254        return _bz_doArrayIndexMapping<N_rank>::map(array_, i,
255            N_map0, N_map1, N_map2, N_map3, N_map4, N_map5, N_map6,
256            N_map7, N_map8, N_map9, N_map10);
257    }
258#endif
259
260    int ascending(int rank)
261    {
262        if (N_map0 == rank)
263            return array_.isRankStoredAscending(0);
264        else if ((N_map1 == rank) && (N_rank > 1))
265            return array_.isRankStoredAscending(1);
266        else if ((N_map2 == rank) && (N_rank > 2))
267            return array_.isRankStoredAscending(2);
268        else if ((N_map3 == rank) && (N_rank > 3))
269            return array_.isRankStoredAscending(3);
270        else if ((N_map4 == rank) && (N_rank > 4))
271            return array_.isRankStoredAscending(4);
272        else if ((N_map5 == rank) && (N_rank > 5))
273            return array_.isRankStoredAscending(5);
274        else if ((N_map6 == rank) && (N_rank > 6))
275            return array_.isRankStoredAscending(6);
276        else if ((N_map7 == rank) && (N_rank > 7))
277            return array_.isRankStoredAscending(7);
278        else if ((N_map8 == rank) && (N_rank > 8))
279            return array_.isRankStoredAscending(8);
280        else if ((N_map9 == rank) && (N_rank > 9))
281            return array_.isRankStoredAscending(9);
282        else if ((N_map10 == rank) && (N_rank > 10))
283            return array_.isRankStoredAscending(10);
284        else
285            return INT_MIN;   // tiny(int());
286    }
287
288    int ordering(int rank)
289    {
290        if (N_map0 == rank)
291            return array_.ordering(0);
292        else if ((N_map1 == rank) && (N_rank > 1))
293            return array_.ordering(1);
294        else if ((N_map2 == rank) && (N_rank > 2))
295            return array_.ordering(2);
296        else if ((N_map3 == rank) && (N_rank > 3))
297            return array_.ordering(3);
298        else if ((N_map4 == rank) && (N_rank > 4))
299            return array_.ordering(4);
300        else if ((N_map5 == rank) && (N_rank > 5))
301            return array_.ordering(5);
302        else if ((N_map6 == rank) && (N_rank > 6))
303            return array_.ordering(6);
304        else if ((N_map7 == rank) && (N_rank > 7))
305            return array_.ordering(7);
306        else if ((N_map8 == rank) && (N_rank > 8))
307            return array_.ordering(8);
308        else if ((N_map9 == rank) && (N_rank > 9))
309            return array_.ordering(9);
310        else if ((N_map10 == rank) && (N_rank > 10))
311            return array_.ordering(10);
312        else
313            return INT_MIN;   // tiny(int());
314    }
315
316    int lbound(int rank)
317    { 
318        if (N_map0 == rank)   
319            return array_.lbound(0);
320        else if ((N_map1 == rank) && (N_rank > 1))
321            return array_.lbound(1);
322        else if ((N_map2 == rank) && (N_rank > 2))
323            return array_.lbound(2);
324        else if ((N_map3 == rank) && (N_rank > 3))
325            return array_.lbound(3);
326        else if ((N_map4 == rank) && (N_rank > 4))
327            return array_.lbound(4);
328        else if ((N_map5 == rank) && (N_rank > 5))
329            return array_.lbound(5);
330        else if ((N_map6 == rank) && (N_rank > 6))
331            return array_.lbound(6);
332        else if ((N_map7 == rank) && (N_rank > 7))
333            return array_.lbound(7);
334        else if ((N_map8 == rank) && (N_rank > 8))
335            return array_.lbound(8);
336        else if ((N_map9 == rank) && (N_rank > 9))
337            return array_.lbound(9);
338        else if ((N_map10 == rank) && (N_rank > 10))
339            return array_.lbound(10);
340        else
341            return INT_MIN;   // tiny(int());
342    }
343
344    int ubound(int rank)
345    {   
346        if (N_map0 == rank)
347            return array_.ubound(0);
348        else if ((N_map1 == rank) && (N_rank > 1))
349            return array_.ubound(1);
350        else if ((N_map2 == rank) && (N_rank > 2))
351            return array_.ubound(2);
352        else if ((N_map3 == rank) && (N_rank > 3))
353            return array_.ubound(3);
354        else if ((N_map4 == rank) && (N_rank > 4))
355            return array_.ubound(4);
356        else if ((N_map5 == rank) && (N_rank > 5))
357            return array_.ubound(5);
358        else if ((N_map6 == rank) && (N_rank > 6))
359            return array_.ubound(6);
360        else if ((N_map7 == rank) && (N_rank > 7))
361            return array_.ubound(7);
362        else if ((N_map8 == rank) && (N_rank > 8))
363            return array_.ubound(8);
364        else if ((N_map9 == rank) && (N_rank > 9))
365            return array_.ubound(9);
366        else if ((N_map10 == rank) && (N_rank > 10))
367            return array_.ubound(10);
368        else
369            return INT_MAX;   // huge(int());
370    }
371
372    // If you have a precondition failure on this routine, it means
373    // you are trying to use stack iteration mode on an expression
374    // which contains an index placeholder.  You must use index
375    // iteration mode instead.
376    int operator*()
377    {
378        BZPRECONDITION(0);
379        return 0;
380    }
381
382    // See operator*() note
383    void push(int)
384    {
385        BZPRECONDITION(0);
386    }
387
388    // See operator*() note
389    void pop(int)
390    {
391        BZPRECONDITION(0);
392    }
393
394    // See operator*() note
395    void advance()
396    {
397        BZPRECONDITION(0);
398    }
399
400    // See operator*() note
401    void advance(int)
402    {
403        BZPRECONDITION(0);
404    }
405
406    // See operator*() note
407    void loadStride(int)
408    {
409        BZPRECONDITION(0);
410    }
411
412    bool isUnitStride(int) const
413    {
414        BZPRECONDITION(0);
415        return false;
416    }
417
418    void advanceUnitStride()
419    {
420        BZPRECONDITION(0);
421    }
422
423    bool canCollapse(int,int) const
424    {   BZPRECONDITION(0);  return false; }
425
426    T_numtype operator[](int)
427    {   
428        BZPRECONDITION(0);
429        return T_numtype();
430    }
431
432    T_numtype fastRead(int)
433    {
434        BZPRECONDITION(0);
435        return T_numtype();
436    }
437
438    int suggestStride(int) const
439    {
440        BZPRECONDITION(0);
441        return 0;
442    }
443
444    bool isStride(int,int) const
445    {
446        BZPRECONDITION(0);
447        return true;
448    }
449
450    template<int N_rank2>
451    void moveTo(const TinyVector<int,N_rank2>&)
452    {
453        BZPRECONDITION(0);
454        return ;
455    }
456
457    void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat&) const
458    {
459        // NEEDS_WORK-- do real formatting for reductions
460        str += "map[NEEDS_WORK]";
461    }
462
463    template<typename T_shape>
464    bool shapeCheck(const T_shape&) const
465    { 
466        // NEEDS_WORK-- do a real shape check (tricky)
467        return true; 
468    }
469
470private:
471    ArrayIndexMapping() : array_( Array<T_numtype, N_rank>() ) { }
472
473    const Array<T_numtype, N_rank>& array_;
474};
475
476BZ_NAMESPACE_END
477
478#endif // BZ_ARRAYMAP_H
479
Note: See TracBrowser for help on using the repository browser.