source: XMLIO_V2/external/include/blitz/array/cartesian.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: 10.0 KB
Line 
1/***************************************************************************
2 * blitz/array/cartesian.h  Cartesian product of indirection containers
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_ARRAY_CARTESIAN_H
24#define BZ_ARRAY_CARTESIAN_H
25
26BZ_NAMESPACE(blitz)
27
28/*
29 * CartesianProduct<T_tuple,T_container> is an adaptor which represents
30 * the cartesian product of several containers. 
31 */
32
33// forward declaration of iterator
34template<typename T_tuple, typename T_container, int N_containers>
35class CartesianProductIterator;
36
37struct _cp_end_tag { };
38
39template<typename T_tuple, typename T_container, int N_containers>
40class CartesianProduct {
41public:
42    typedef T_tuple value_type;
43    typedef T_tuple& reference;
44    typedef const T_tuple& const_reference;
45    typedef CartesianProductIterator<T_tuple,T_container,N_containers> iterator;
46    typedef int difference_type;
47    typedef int size_type;
48
49    iterator begin()
50    { return iterator(*this); }
51
52    iterator end()
53    { return iterator(_cp_end_tag()); }
54
55    CartesianProduct(const T_container& container0, 
56        const T_container& container1)
57    { 
58        BZPRECONDITION(N_containers == 2);
59        containers_[0] = &container0;
60        containers_[1] = &container1;
61    }
62
63    CartesianProduct(const T_container& container0, 
64        const T_container& container1,
65        const T_container& container2)
66    { 
67        BZPRECONDITION(N_containers == 3);
68        containers_[0] = &container0;
69        containers_[1] = &container1;
70        containers_[2] = &container2;
71    }
72
73    CartesianProduct(const T_container& container0, 
74        const T_container& container1,
75        const T_container& container2,
76        const T_container& container3)
77    { 
78        BZPRECONDITION(N_containers == 4);
79        containers_[0] = &container0;
80        containers_[1] = &container1;
81        containers_[2] = &container2;
82        containers_[3] = &container3;
83    }
84
85    CartesianProduct(const T_container& container0, 
86        const T_container& container1,
87        const T_container& container2,
88        const T_container& container3,
89        const T_container& container4)
90    { 
91        BZPRECONDITION(N_containers == 5);
92        containers_[0] = &container0;
93        containers_[1] = &container1;
94        containers_[2] = &container2;
95        containers_[3] = &container3;
96        containers_[4] = &container4;
97    }
98
99    CartesianProduct(const T_container& container0, 
100        const T_container& container1,
101        const T_container& container2,
102        const T_container& container3,
103        const T_container& container4,
104        const T_container& container5)
105    { 
106        BZPRECONDITION(N_containers == 6);
107        containers_[0] = &container0;
108        containers_[1] = &container1;
109        containers_[2] = &container2;
110        containers_[3] = &container3;
111        containers_[4] = &container4;
112        containers_[5] = &container5;
113    }
114
115    CartesianProduct(const T_container& container0, 
116        const T_container& container1,
117        const T_container& container2,
118        const T_container& container3,
119        const T_container& container4,
120        const T_container& container5,
121        const T_container& container6)
122    { 
123        BZPRECONDITION(N_containers == 7);
124        containers_[0] = &container0;
125        containers_[1] = &container1;
126        containers_[2] = &container2;
127        containers_[3] = &container3;
128        containers_[4] = &container4;
129        containers_[5] = &container5;
130        containers_[6] = &container6;
131    }
132
133    CartesianProduct(const T_container& container0, 
134        const T_container& container1,
135        const T_container& container2,
136        const T_container& container3,
137        const T_container& container4,
138        const T_container& container5,
139        const T_container& container6,
140        const T_container& container7)
141    { 
142        BZPRECONDITION(N_containers == 8);
143        containers_[0] = &container0;
144        containers_[1] = &container1;
145        containers_[2] = &container2;
146        containers_[3] = &container3;
147        containers_[4] = &container4;
148        containers_[5] = &container5;
149        containers_[6] = &container6;
150        containers_[7] = &container7;
151    }
152
153    CartesianProduct(const T_container& container0, 
154        const T_container& container1,
155        const T_container& container2,
156        const T_container& container3,
157        const T_container& container4,
158        const T_container& container5,
159        const T_container& container6,
160        const T_container& container7,
161        const T_container& container8)
162    { 
163        BZPRECONDITION(N_containers == 9);
164        containers_[0] = &container0;
165        containers_[1] = &container1;
166        containers_[2] = &container2;
167        containers_[3] = &container3;
168        containers_[4] = &container4;
169        containers_[5] = &container5;
170        containers_[6] = &container6;
171        containers_[7] = &container7;
172        containers_[8] = &container8;
173    }
174
175    CartesianProduct(const T_container& container0, 
176        const T_container& container1,
177        const T_container& container2,
178        const T_container& container3,
179        const T_container& container4,
180        const T_container& container5,
181        const T_container& container6,
182        const T_container& container7,
183        const T_container& container8,
184        const T_container& container9)
185    { 
186        BZPRECONDITION(N_containers == 10);
187        containers_[0] = &container0;
188        containers_[1] = &container1;
189        containers_[2] = &container2;
190        containers_[3] = &container3;
191        containers_[4] = &container4;
192        containers_[5] = &container5;
193        containers_[6] = &container6;
194        containers_[7] = &container7;
195        containers_[8] = &container8;
196        containers_[9] = &container9;
197    }
198
199    CartesianProduct(const T_container& container0, 
200        const T_container& container1,
201        const T_container& container2,
202        const T_container& container3,
203        const T_container& container4,
204        const T_container& container5,
205        const T_container& container6,
206        const T_container& container7,
207        const T_container& container8,
208        const T_container& container9,
209        const T_container& container10)
210    { 
211        BZPRECONDITION(N_containers == 11);
212        containers_[0] = &container0;
213        containers_[1] = &container1;
214        containers_[2] = &container2;
215        containers_[3] = &container3;
216        containers_[4] = &container4;
217        containers_[5] = &container5;
218        containers_[6] = &container6;
219        containers_[7] = &container7;
220        containers_[8] = &container8;
221        containers_[9] = &container9;
222        containers_[10] = &container10;
223    }
224
225    const T_container& operator[](int i)
226    { return *(containers_[i]); }
227
228    void debugDump();
229
230protected:
231    const T_container* containers_[N_containers]; 
232};
233
234template<typename T_tuple, typename T_container, int N_containers>
235void CartesianProduct<T_tuple,T_container,N_containers>::debugDump()
236{
237    cout << "Dump of CartesianProduct<..,..," << N_containers << ">" << endl;
238    for (int i=0; i < N_containers; ++i)
239    {
240        cout << "Container " << (i+1) << ": ";
241        _bz_typename T_container::const_iterator iter = containers_[i]->begin(),
242            end = containers_[i]->end();
243        for (; iter != end; ++iter)
244            cout << (*iter) << '\t'; 
245    }
246}
247
248template<typename T_tuple, typename T_container, int N_containers>
249class CartesianProductIterator {
250public:
251    typedef _bz_typename T_container::const_iterator citerator;
252    typedef CartesianProductIterator<T_tuple,T_container,N_containers> iterator;
253    typedef CartesianProduct<T_tuple,T_container,N_containers> T_cp;
254
255    CartesianProductIterator(T_cp& container)
256    {
257        for (int i=0; i < N_containers; ++i)
258        {
259            firstiters_[i] = container[i].begin();
260            iters_[i] = firstiters_[i];
261            enditers_[i] = container[i].end();
262            tuple_[i] = *iters_[i];
263        }
264
265        endflag_ = false;
266    }
267
268    void operator++();
269
270    CartesianProductIterator(_cp_end_tag)
271    {
272        endflag_ = true;
273    }
274
275    bool operator==(const iterator& x) const
276    {
277        return (endflag_ == x.endflag_);
278    }
279
280    bool operator!=(const iterator& x) const
281    {   
282        return endflag_ != x.endflag_;
283    }
284
285    const T_tuple& operator*() const
286    { return tuple_; }
287
288protected:
289    citerator iters_[N_containers];
290    citerator firstiters_[N_containers];
291    citerator enditers_[N_containers];
292    T_tuple   tuple_;
293    bool      endflag_;
294};
295
296template<typename T_tuple, typename T_container, int N_containers>
297void CartesianProductIterator<T_tuple, T_container, 
298    N_containers>::operator++()
299{
300    // Usual stack-style increment
301    const int Nminus1 = N_containers - 1;
302
303    int i = Nminus1;
304
305    // Short-circuit for most common case
306    // (just increment the last iterator)
307
308    if((++iters_[i]) != enditers_[i])
309    {
310        tuple_[i] = *iters_[i];
311        return;
312    }
313
314    // Less common cases
315
316    for (--i; i >= 0; --i)
317    {
318        ++iters_[i];
319        if (iters_[i] != enditers_[i])
320            break;
321    }
322
323    if (i == -1)
324    {
325        endflag_ = true;
326        return;
327    }
328
329    tuple_[i] = *iters_[i];
330
331    for (++i; i < N_containers; ++i) 
332    {
333        iters_[i] = firstiters_[i];
334        tuple_[i] = *iters_[i];
335    }
336}
337
338BZ_NAMESPACE_END
339
340#endif // BZ_ARRAY_CARTESIAN_H
341
Note: See TracBrowser for help on using the repository browser.