Add basicUnsafeThaw
[darcs-mirrors/vector.git] / internal / unbox-tuple-instances
1 #ifdef DEFINE_INSTANCES
2 data instance MVector s (a, b)
3     = MV_2 {-# UNPACK #-} !Int !(MVector s a)
4                                !(MVector s b)
5 data instance Vector (a, b)
6     = V_2 {-# UNPACK #-} !Int !(Vector a)
7                               !(Vector b)
8 instance (Unbox a, Unbox b) => Unbox (a, b)
9 instance (Unbox a, Unbox b) => M.MVector MVector (a, b) where
10   {-# INLINE basicLength  #-}
11   basicLength (MV_2 n_ as bs) = n_
12   {-# INLINE basicUnsafeSlice  #-}
13   basicUnsafeSlice i_ m_ (MV_2 n_ as bs)
14       = MV_2 m_ (M.basicUnsafeSlice i_ m_ as)
15                 (M.basicUnsafeSlice i_ m_ bs)
16   {-# INLINE basicOverlaps  #-}
17   basicOverlaps (MV_2 n_1 as1 bs1) (MV_2 n_2 as2 bs2)
18       = M.basicOverlaps as1 as2
19         || M.basicOverlaps bs1 bs2
20   {-# INLINE basicUnsafeNew  #-}
21   basicUnsafeNew n_
22       = do
23           as <- M.basicUnsafeNew n_
24           bs <- M.basicUnsafeNew n_
25           return $ MV_2 n_ as bs
26   {-# INLINE basicUnsafeReplicate  #-}
27   basicUnsafeReplicate n_ (a, b)
28       = do
29           as <- M.basicUnsafeReplicate n_ a
30           bs <- M.basicUnsafeReplicate n_ b
31           return $ MV_2 n_ as bs
32   {-# INLINE basicUnsafeRead  #-}
33   basicUnsafeRead (MV_2 n_ as bs) i_
34       = do
35           a <- M.basicUnsafeRead as i_
36           b <- M.basicUnsafeRead bs i_
37           return (a, b)
38   {-# INLINE basicUnsafeWrite  #-}
39   basicUnsafeWrite (MV_2 n_ as bs) i_ (a, b)
40       = do
41           M.basicUnsafeWrite as i_ a
42           M.basicUnsafeWrite bs i_ b
43   {-# INLINE basicClear  #-}
44   basicClear (MV_2 n_ as bs)
45       = do
46           M.basicClear as
47           M.basicClear bs
48   {-# INLINE basicSet  #-}
49   basicSet (MV_2 n_ as bs) (a, b)
50       = do
51           M.basicSet as a
52           M.basicSet bs b
53   {-# INLINE basicUnsafeCopy  #-}
54   basicUnsafeCopy (MV_2 n_1 as1 bs1) (MV_2 n_2 as2 bs2)
55       = do
56           M.basicUnsafeCopy as1 as2
57           M.basicUnsafeCopy bs1 bs2
58   {-# INLINE basicUnsafeGrow  #-}
59   basicUnsafeGrow (MV_2 n_ as bs) m_
60       = do
61           as' <- M.basicUnsafeGrow as m_
62           bs' <- M.basicUnsafeGrow bs m_
63           return $ MV_2 (m_+n_) as' bs'
64 instance (Unbox a, Unbox b) => G.Vector Vector (a, b) where
65   {-# INLINE basicUnsafeFreeze  #-}
66   basicUnsafeFreeze (MV_2 n_ as bs)
67       = do
68           as' <- G.basicUnsafeFreeze as
69           bs' <- G.basicUnsafeFreeze bs
70           return $ V_2 n_ as' bs'
71   {-# INLINE basicUnsafeThaw  #-}
72   basicUnsafeThaw (V_2 n_ as bs)
73       = do
74           as' <- G.basicUnsafeThaw as
75           bs' <- G.basicUnsafeThaw bs
76           return $ MV_2 n_ as' bs'
77   {-# INLINE basicLength  #-}
78   basicLength (V_2 n_ as bs) = n_
79   {-# INLINE basicUnsafeSlice  #-}
80   basicUnsafeSlice i_ m_ (V_2 n_ as bs)
81       = V_2 m_ (G.basicUnsafeSlice i_ m_ as)
82                (G.basicUnsafeSlice i_ m_ bs)
83   {-# INLINE basicUnsafeIndexM  #-}
84   basicUnsafeIndexM (V_2 n_ as bs) i_
85       = do
86           a <- G.basicUnsafeIndexM as i_
87           b <- G.basicUnsafeIndexM bs i_
88           return (a, b)
89   {-# INLINE basicUnsafeCopy  #-}
90   basicUnsafeCopy (MV_2 n_1 as1 bs1) (V_2 n_2 as2 bs2)
91       = do
92           G.basicUnsafeCopy as1 as2
93           G.basicUnsafeCopy bs1 bs2
94   {-# INLINE elemseq  #-}
95   elemseq _ (a, b)
96       = G.elemseq (undefined :: Vector a) a
97         . G.elemseq (undefined :: Vector b) b
98 #endif
99 #ifdef DEFINE_MUTABLE
100 -- | /O(1)/ Zip 2 vectors
101 zip :: (Unbox a, Unbox b) => MVector s a ->
102                              MVector s b -> MVector s (a, b)
103 {-# INLINE_STREAM zip #-}
104 zip as bs = MV_2 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs)
105   where len = length as `min` length bs
106 -- | /O(1)/ Unzip 2 vectors
107 unzip :: (Unbox a, Unbox b) => MVector s (a, b) -> (MVector s a,
108                                                     MVector s b)
109 {-# INLINE unzip #-}
110 unzip (MV_2 n_ as bs) = (as, bs)
111 #endif
112 #ifdef DEFINE_IMMUTABLE
113 -- | /O(1)/ Zip 2 vectors
114 zip :: (Unbox a, Unbox b) => Vector a -> Vector b -> Vector (a, b)
115 {-# INLINE_STREAM zip #-}
116 zip as bs = V_2 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs)
117   where len = length as `min` length bs
118 {-# RULES "stream/zip [Vector.Unboxed]" forall as bs .
119   G.stream (zip as bs) = Stream.zipWith (,) (G.stream as)
120                                             (G.stream bs)
121   #-}
122 -- | /O(1)/ Unzip 2 vectors
123 unzip :: (Unbox a, Unbox b) => Vector (a, b) -> (Vector a,
124                                                  Vector b)
125 {-# INLINE unzip #-}
126 unzip (V_2 n_ as bs) = (as, bs)
127 #endif
128 #ifdef DEFINE_INSTANCES
129 data instance MVector s (a, b, c)
130     = MV_3 {-# UNPACK #-} !Int !(MVector s a)
131                                !(MVector s b)
132                                !(MVector s c)
133 data instance Vector (a, b, c)
134     = V_3 {-# UNPACK #-} !Int !(Vector a)
135                               !(Vector b)
136                               !(Vector c)
137 instance (Unbox a, Unbox b, Unbox c) => Unbox (a, b, c)
138 instance (Unbox a,
139           Unbox b,
140           Unbox c) => M.MVector MVector (a, b, c) where
141   {-# INLINE basicLength  #-}
142   basicLength (MV_3 n_ as bs cs) = n_
143   {-# INLINE basicUnsafeSlice  #-}
144   basicUnsafeSlice i_ m_ (MV_3 n_ as bs cs)
145       = MV_3 m_ (M.basicUnsafeSlice i_ m_ as)
146                 (M.basicUnsafeSlice i_ m_ bs)
147                 (M.basicUnsafeSlice i_ m_ cs)
148   {-# INLINE basicOverlaps  #-}
149   basicOverlaps (MV_3 n_1 as1 bs1 cs1) (MV_3 n_2 as2 bs2 cs2)
150       = M.basicOverlaps as1 as2
151         || M.basicOverlaps bs1 bs2
152         || M.basicOverlaps cs1 cs2
153   {-# INLINE basicUnsafeNew  #-}
154   basicUnsafeNew n_
155       = do
156           as <- M.basicUnsafeNew n_
157           bs <- M.basicUnsafeNew n_
158           cs <- M.basicUnsafeNew n_
159           return $ MV_3 n_ as bs cs
160   {-# INLINE basicUnsafeReplicate  #-}
161   basicUnsafeReplicate n_ (a, b, c)
162       = do
163           as <- M.basicUnsafeReplicate n_ a
164           bs <- M.basicUnsafeReplicate n_ b
165           cs <- M.basicUnsafeReplicate n_ c
166           return $ MV_3 n_ as bs cs
167   {-# INLINE basicUnsafeRead  #-}
168   basicUnsafeRead (MV_3 n_ as bs cs) i_
169       = do
170           a <- M.basicUnsafeRead as i_
171           b <- M.basicUnsafeRead bs i_
172           c <- M.basicUnsafeRead cs i_
173           return (a, b, c)
174   {-# INLINE basicUnsafeWrite  #-}
175   basicUnsafeWrite (MV_3 n_ as bs cs) i_ (a, b, c)
176       = do
177           M.basicUnsafeWrite as i_ a
178           M.basicUnsafeWrite bs i_ b
179           M.basicUnsafeWrite cs i_ c
180   {-# INLINE basicClear  #-}
181   basicClear (MV_3 n_ as bs cs)
182       = do
183           M.basicClear as
184           M.basicClear bs
185           M.basicClear cs
186   {-# INLINE basicSet  #-}
187   basicSet (MV_3 n_ as bs cs) (a, b, c)
188       = do
189           M.basicSet as a
190           M.basicSet bs b
191           M.basicSet cs c
192   {-# INLINE basicUnsafeCopy  #-}
193   basicUnsafeCopy (MV_3 n_1 as1 bs1 cs1) (MV_3 n_2 as2 bs2 cs2)
194       = do
195           M.basicUnsafeCopy as1 as2
196           M.basicUnsafeCopy bs1 bs2
197           M.basicUnsafeCopy cs1 cs2
198   {-# INLINE basicUnsafeGrow  #-}
199   basicUnsafeGrow (MV_3 n_ as bs cs) m_
200       = do
201           as' <- M.basicUnsafeGrow as m_
202           bs' <- M.basicUnsafeGrow bs m_
203           cs' <- M.basicUnsafeGrow cs m_
204           return $ MV_3 (m_+n_) as' bs' cs'
205 instance (Unbox a,
206           Unbox b,
207           Unbox c) => G.Vector Vector (a, b, c) where
208   {-# INLINE basicUnsafeFreeze  #-}
209   basicUnsafeFreeze (MV_3 n_ as bs cs)
210       = do
211           as' <- G.basicUnsafeFreeze as
212           bs' <- G.basicUnsafeFreeze bs
213           cs' <- G.basicUnsafeFreeze cs
214           return $ V_3 n_ as' bs' cs'
215   {-# INLINE basicUnsafeThaw  #-}
216   basicUnsafeThaw (V_3 n_ as bs cs)
217       = do
218           as' <- G.basicUnsafeThaw as
219           bs' <- G.basicUnsafeThaw bs
220           cs' <- G.basicUnsafeThaw cs
221           return $ MV_3 n_ as' bs' cs'
222   {-# INLINE basicLength  #-}
223   basicLength (V_3 n_ as bs cs) = n_
224   {-# INLINE basicUnsafeSlice  #-}
225   basicUnsafeSlice i_ m_ (V_3 n_ as bs cs)
226       = V_3 m_ (G.basicUnsafeSlice i_ m_ as)
227                (G.basicUnsafeSlice i_ m_ bs)
228                (G.basicUnsafeSlice i_ m_ cs)
229   {-# INLINE basicUnsafeIndexM  #-}
230   basicUnsafeIndexM (V_3 n_ as bs cs) i_
231       = do
232           a <- G.basicUnsafeIndexM as i_
233           b <- G.basicUnsafeIndexM bs i_
234           c <- G.basicUnsafeIndexM cs i_
235           return (a, b, c)
236   {-# INLINE basicUnsafeCopy  #-}
237   basicUnsafeCopy (MV_3 n_1 as1 bs1 cs1) (V_3 n_2 as2 bs2 cs2)
238       = do
239           G.basicUnsafeCopy as1 as2
240           G.basicUnsafeCopy bs1 bs2
241           G.basicUnsafeCopy cs1 cs2
242   {-# INLINE elemseq  #-}
243   elemseq _ (a, b, c)
244       = G.elemseq (undefined :: Vector a) a
245         . G.elemseq (undefined :: Vector b) b
246         . G.elemseq (undefined :: Vector c) c
247 #endif
248 #ifdef DEFINE_MUTABLE
249 -- | /O(1)/ Zip 3 vectors
250 zip3 :: (Unbox a, Unbox b, Unbox c) => MVector s a ->
251                                        MVector s b ->
252                                        MVector s c -> MVector s (a, b, c)
253 {-# INLINE_STREAM zip3 #-}
254 zip3 as bs cs = MV_3 len (unsafeSlice 0 len as)
255                          (unsafeSlice 0 len bs)
256                          (unsafeSlice 0 len cs)
257   where len = length as `min` length bs `min` length cs
258 -- | /O(1)/ Unzip 3 vectors
259 unzip3 :: (Unbox a,
260            Unbox b,
261            Unbox c) => MVector s (a, b, c) -> (MVector s a,
262                                                MVector s b,
263                                                MVector s c)
264 {-# INLINE unzip3 #-}
265 unzip3 (MV_3 n_ as bs cs) = (as, bs, cs)
266 #endif
267 #ifdef DEFINE_IMMUTABLE
268 -- | /O(1)/ Zip 3 vectors
269 zip3 :: (Unbox a, Unbox b, Unbox c) => Vector a ->
270                                        Vector b ->
271                                        Vector c -> Vector (a, b, c)
272 {-# INLINE_STREAM zip3 #-}
273 zip3 as bs cs = V_3 len (unsafeSlice 0 len as)
274                         (unsafeSlice 0 len bs)
275                         (unsafeSlice 0 len cs)
276   where len = length as `min` length bs `min` length cs
277 {-# RULES "stream/zip3 [Vector.Unboxed]" forall as bs cs .
278   G.stream (zip3 as bs cs) = Stream.zipWith3 (, ,) (G.stream as)
279                                                    (G.stream bs)
280                                                    (G.stream cs)
281   #-}
282 -- | /O(1)/ Unzip 3 vectors
283 unzip3 :: (Unbox a,
284            Unbox b,
285            Unbox c) => Vector (a, b, c) -> (Vector a, Vector b, Vector c)
286 {-# INLINE unzip3 #-}
287 unzip3 (V_3 n_ as bs cs) = (as, bs, cs)
288 #endif
289 #ifdef DEFINE_INSTANCES
290 data instance MVector s (a, b, c, d)
291     = MV_4 {-# UNPACK #-} !Int !(MVector s a)
292                                !(MVector s b)
293                                !(MVector s c)
294                                !(MVector s d)
295 data instance Vector (a, b, c, d)
296     = V_4 {-# UNPACK #-} !Int !(Vector a)
297                               !(Vector b)
298                               !(Vector c)
299                               !(Vector d)
300 instance (Unbox a, Unbox b, Unbox c, Unbox d) => Unbox (a, b, c, d)
301 instance (Unbox a,
302           Unbox b,
303           Unbox c,
304           Unbox d) => M.MVector MVector (a, b, c, d) where
305   {-# INLINE basicLength  #-}
306   basicLength (MV_4 n_ as bs cs ds) = n_
307   {-# INLINE basicUnsafeSlice  #-}
308   basicUnsafeSlice i_ m_ (MV_4 n_ as bs cs ds)
309       = MV_4 m_ (M.basicUnsafeSlice i_ m_ as)
310                 (M.basicUnsafeSlice i_ m_ bs)
311                 (M.basicUnsafeSlice i_ m_ cs)
312                 (M.basicUnsafeSlice i_ m_ ds)
313   {-# INLINE basicOverlaps  #-}
314   basicOverlaps (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2 bs2 cs2 ds2)
315       = M.basicOverlaps as1 as2
316         || M.basicOverlaps bs1 bs2
317         || M.basicOverlaps cs1 cs2
318         || M.basicOverlaps ds1 ds2
319   {-# INLINE basicUnsafeNew  #-}
320   basicUnsafeNew n_
321       = do
322           as <- M.basicUnsafeNew n_
323           bs <- M.basicUnsafeNew n_
324           cs <- M.basicUnsafeNew n_
325           ds <- M.basicUnsafeNew n_
326           return $ MV_4 n_ as bs cs ds
327   {-# INLINE basicUnsafeReplicate  #-}
328   basicUnsafeReplicate n_ (a, b, c, d)
329       = do
330           as <- M.basicUnsafeReplicate n_ a
331           bs <- M.basicUnsafeReplicate n_ b
332           cs <- M.basicUnsafeReplicate n_ c
333           ds <- M.basicUnsafeReplicate n_ d
334           return $ MV_4 n_ as bs cs ds
335   {-# INLINE basicUnsafeRead  #-}
336   basicUnsafeRead (MV_4 n_ as bs cs ds) i_
337       = do
338           a <- M.basicUnsafeRead as i_
339           b <- M.basicUnsafeRead bs i_
340           c <- M.basicUnsafeRead cs i_
341           d <- M.basicUnsafeRead ds i_
342           return (a, b, c, d)
343   {-# INLINE basicUnsafeWrite  #-}
344   basicUnsafeWrite (MV_4 n_ as bs cs ds) i_ (a, b, c, d)
345       = do
346           M.basicUnsafeWrite as i_ a
347           M.basicUnsafeWrite bs i_ b
348           M.basicUnsafeWrite cs i_ c
349           M.basicUnsafeWrite ds i_ d
350   {-# INLINE basicClear  #-}
351   basicClear (MV_4 n_ as bs cs ds)
352       = do
353           M.basicClear as
354           M.basicClear bs
355           M.basicClear cs
356           M.basicClear ds
357   {-# INLINE basicSet  #-}
358   basicSet (MV_4 n_ as bs cs ds) (a, b, c, d)
359       = do
360           M.basicSet as a
361           M.basicSet bs b
362           M.basicSet cs c
363           M.basicSet ds d
364   {-# INLINE basicUnsafeCopy  #-}
365   basicUnsafeCopy (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2
366                                                        bs2
367                                                        cs2
368                                                        ds2)
369       = do
370           M.basicUnsafeCopy as1 as2
371           M.basicUnsafeCopy bs1 bs2
372           M.basicUnsafeCopy cs1 cs2
373           M.basicUnsafeCopy ds1 ds2
374   {-# INLINE basicUnsafeGrow  #-}
375   basicUnsafeGrow (MV_4 n_ as bs cs ds) m_
376       = do
377           as' <- M.basicUnsafeGrow as m_
378           bs' <- M.basicUnsafeGrow bs m_
379           cs' <- M.basicUnsafeGrow cs m_
380           ds' <- M.basicUnsafeGrow ds m_
381           return $ MV_4 (m_+n_) as' bs' cs' ds'
382 instance (Unbox a,
383           Unbox b,
384           Unbox c,
385           Unbox d) => G.Vector Vector (a, b, c, d) where
386   {-# INLINE basicUnsafeFreeze  #-}
387   basicUnsafeFreeze (MV_4 n_ as bs cs ds)
388       = do
389           as' <- G.basicUnsafeFreeze as
390           bs' <- G.basicUnsafeFreeze bs
391           cs' <- G.basicUnsafeFreeze cs
392           ds' <- G.basicUnsafeFreeze ds
393           return $ V_4 n_ as' bs' cs' ds'
394   {-# INLINE basicUnsafeThaw  #-}
395   basicUnsafeThaw (V_4 n_ as bs cs ds)
396       = do
397           as' <- G.basicUnsafeThaw as
398           bs' <- G.basicUnsafeThaw bs
399           cs' <- G.basicUnsafeThaw cs
400           ds' <- G.basicUnsafeThaw ds
401           return $ MV_4 n_ as' bs' cs' ds'
402   {-# INLINE basicLength  #-}
403   basicLength (V_4 n_ as bs cs ds) = n_
404   {-# INLINE basicUnsafeSlice  #-}
405   basicUnsafeSlice i_ m_ (V_4 n_ as bs cs ds)
406       = V_4 m_ (G.basicUnsafeSlice i_ m_ as)
407                (G.basicUnsafeSlice i_ m_ bs)
408                (G.basicUnsafeSlice i_ m_ cs)
409                (G.basicUnsafeSlice i_ m_ ds)
410   {-# INLINE basicUnsafeIndexM  #-}
411   basicUnsafeIndexM (V_4 n_ as bs cs ds) i_
412       = do
413           a <- G.basicUnsafeIndexM as i_
414           b <- G.basicUnsafeIndexM bs i_
415           c <- G.basicUnsafeIndexM cs i_
416           d <- G.basicUnsafeIndexM ds i_
417           return (a, b, c, d)
418   {-# INLINE basicUnsafeCopy  #-}
419   basicUnsafeCopy (MV_4 n_1 as1 bs1 cs1 ds1) (V_4 n_2 as2
420                                                       bs2
421                                                       cs2
422                                                       ds2)
423       = do
424           G.basicUnsafeCopy as1 as2
425           G.basicUnsafeCopy bs1 bs2
426           G.basicUnsafeCopy cs1 cs2
427           G.basicUnsafeCopy ds1 ds2
428   {-# INLINE elemseq  #-}
429   elemseq _ (a, b, c, d)
430       = G.elemseq (undefined :: Vector a) a
431         . G.elemseq (undefined :: Vector b) b
432         . G.elemseq (undefined :: Vector c) c
433         . G.elemseq (undefined :: Vector d) d
434 #endif
435 #ifdef DEFINE_MUTABLE
436 -- | /O(1)/ Zip 4 vectors
437 zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => MVector s a ->
438                                                 MVector s b ->
439                                                 MVector s c ->
440                                                 MVector s d -> MVector s (a, b, c, d)
441 {-# INLINE_STREAM zip4 #-}
442 zip4 as bs cs ds = MV_4 len (unsafeSlice 0 len as)
443                             (unsafeSlice 0 len bs)
444                             (unsafeSlice 0 len cs)
445                             (unsafeSlice 0 len ds)
446   where
447     len = length as `min` length bs `min` length cs `min` length ds
448 -- | /O(1)/ Unzip 4 vectors
449 unzip4 :: (Unbox a,
450            Unbox b,
451            Unbox c,
452            Unbox d) => MVector s (a, b, c, d) -> (MVector s a,
453                                                   MVector s b,
454                                                   MVector s c,
455                                                   MVector s d)
456 {-# INLINE unzip4 #-}
457 unzip4 (MV_4 n_ as bs cs ds) = (as, bs, cs, ds)
458 #endif
459 #ifdef DEFINE_IMMUTABLE
460 -- | /O(1)/ Zip 4 vectors
461 zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vector a ->
462                                                 Vector b ->
463                                                 Vector c ->
464                                                 Vector d -> Vector (a, b, c, d)
465 {-# INLINE_STREAM zip4 #-}
466 zip4 as bs cs ds = V_4 len (unsafeSlice 0 len as)
467                            (unsafeSlice 0 len bs)
468                            (unsafeSlice 0 len cs)
469                            (unsafeSlice 0 len ds)
470   where
471     len = length as `min` length bs `min` length cs `min` length ds
472 {-# RULES "stream/zip4 [Vector.Unboxed]" forall as bs cs ds .
473   G.stream (zip4 as bs cs ds) = Stream.zipWith4 (, , ,) (G.stream as)
474                                                         (G.stream bs)
475                                                         (G.stream cs)
476                                                         (G.stream ds)
477   #-}
478 -- | /O(1)/ Unzip 4 vectors
479 unzip4 :: (Unbox a,
480            Unbox b,
481            Unbox c,
482            Unbox d) => Vector (a, b, c, d) -> (Vector a,
483                                                Vector b,
484                                                Vector c,
485                                                Vector d)
486 {-# INLINE unzip4 #-}
487 unzip4 (V_4 n_ as bs cs ds) = (as, bs, cs, ds)
488 #endif
489 #ifdef DEFINE_INSTANCES
490 data instance MVector s (a, b, c, d, e)
491     = MV_5 {-# UNPACK #-} !Int !(MVector s a)
492                                !(MVector s b)
493                                !(MVector s c)
494                                !(MVector s d)
495                                !(MVector s e)
496 data instance Vector (a, b, c, d, e)
497     = V_5 {-# UNPACK #-} !Int !(Vector a)
498                               !(Vector b)
499                               !(Vector c)
500                               !(Vector d)
501                               !(Vector e)
502 instance (Unbox a,
503           Unbox b,
504           Unbox c,
505           Unbox d,
506           Unbox e) => Unbox (a, b, c, d, e)
507 instance (Unbox a,
508           Unbox b,
509           Unbox c,
510           Unbox d,
511           Unbox e) => M.MVector MVector (a, b, c, d, e) where
512   {-# INLINE basicLength  #-}
513   basicLength (MV_5 n_ as bs cs ds es) = n_
514   {-# INLINE basicUnsafeSlice  #-}
515   basicUnsafeSlice i_ m_ (MV_5 n_ as bs cs ds es)
516       = MV_5 m_ (M.basicUnsafeSlice i_ m_ as)
517                 (M.basicUnsafeSlice i_ m_ bs)
518                 (M.basicUnsafeSlice i_ m_ cs)
519                 (M.basicUnsafeSlice i_ m_ ds)
520                 (M.basicUnsafeSlice i_ m_ es)
521   {-# INLINE basicOverlaps  #-}
522   basicOverlaps (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
523                                                          bs2
524                                                          cs2
525                                                          ds2
526                                                          es2)
527       = M.basicOverlaps as1 as2
528         || M.basicOverlaps bs1 bs2
529         || M.basicOverlaps cs1 cs2
530         || M.basicOverlaps ds1 ds2
531         || M.basicOverlaps es1 es2
532   {-# INLINE basicUnsafeNew  #-}
533   basicUnsafeNew n_
534       = do
535           as <- M.basicUnsafeNew n_
536           bs <- M.basicUnsafeNew n_
537           cs <- M.basicUnsafeNew n_
538           ds <- M.basicUnsafeNew n_
539           es <- M.basicUnsafeNew n_
540           return $ MV_5 n_ as bs cs ds es
541   {-# INLINE basicUnsafeReplicate  #-}
542   basicUnsafeReplicate n_ (a, b, c, d, e)
543       = do
544           as <- M.basicUnsafeReplicate n_ a
545           bs <- M.basicUnsafeReplicate n_ b
546           cs <- M.basicUnsafeReplicate n_ c
547           ds <- M.basicUnsafeReplicate n_ d
548           es <- M.basicUnsafeReplicate n_ e
549           return $ MV_5 n_ as bs cs ds es
550   {-# INLINE basicUnsafeRead  #-}
551   basicUnsafeRead (MV_5 n_ as bs cs ds es) i_
552       = do
553           a <- M.basicUnsafeRead as i_
554           b <- M.basicUnsafeRead bs i_
555           c <- M.basicUnsafeRead cs i_
556           d <- M.basicUnsafeRead ds i_
557           e <- M.basicUnsafeRead es i_
558           return (a, b, c, d, e)
559   {-# INLINE basicUnsafeWrite  #-}
560   basicUnsafeWrite (MV_5 n_ as bs cs ds es) i_ (a, b, c, d, e)
561       = do
562           M.basicUnsafeWrite as i_ a
563           M.basicUnsafeWrite bs i_ b
564           M.basicUnsafeWrite cs i_ c
565           M.basicUnsafeWrite ds i_ d
566           M.basicUnsafeWrite es i_ e
567   {-# INLINE basicClear  #-}
568   basicClear (MV_5 n_ as bs cs ds es)
569       = do
570           M.basicClear as
571           M.basicClear bs
572           M.basicClear cs
573           M.basicClear ds
574           M.basicClear es
575   {-# INLINE basicSet  #-}
576   basicSet (MV_5 n_ as bs cs ds es) (a, b, c, d, e)
577       = do
578           M.basicSet as a
579           M.basicSet bs b
580           M.basicSet cs c
581           M.basicSet ds d
582           M.basicSet es e
583   {-# INLINE basicUnsafeCopy  #-}
584   basicUnsafeCopy (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
585                                                            bs2
586                                                            cs2
587                                                            ds2
588                                                            es2)
589       = do
590           M.basicUnsafeCopy as1 as2
591           M.basicUnsafeCopy bs1 bs2
592           M.basicUnsafeCopy cs1 cs2
593           M.basicUnsafeCopy ds1 ds2
594           M.basicUnsafeCopy es1 es2
595   {-# INLINE basicUnsafeGrow  #-}
596   basicUnsafeGrow (MV_5 n_ as bs cs ds es) m_
597       = do
598           as' <- M.basicUnsafeGrow as m_
599           bs' <- M.basicUnsafeGrow bs m_
600           cs' <- M.basicUnsafeGrow cs m_
601           ds' <- M.basicUnsafeGrow ds m_
602           es' <- M.basicUnsafeGrow es m_
603           return $ MV_5 (m_+n_) as' bs' cs' ds' es'
604 instance (Unbox a,
605           Unbox b,
606           Unbox c,
607           Unbox d,
608           Unbox e) => G.Vector Vector (a, b, c, d, e) where
609   {-# INLINE basicUnsafeFreeze  #-}
610   basicUnsafeFreeze (MV_5 n_ as bs cs ds es)
611       = do
612           as' <- G.basicUnsafeFreeze as
613           bs' <- G.basicUnsafeFreeze bs
614           cs' <- G.basicUnsafeFreeze cs
615           ds' <- G.basicUnsafeFreeze ds
616           es' <- G.basicUnsafeFreeze es
617           return $ V_5 n_ as' bs' cs' ds' es'
618   {-# INLINE basicUnsafeThaw  #-}
619   basicUnsafeThaw (V_5 n_ as bs cs ds es)
620       = do
621           as' <- G.basicUnsafeThaw as
622           bs' <- G.basicUnsafeThaw bs
623           cs' <- G.basicUnsafeThaw cs
624           ds' <- G.basicUnsafeThaw ds
625           es' <- G.basicUnsafeThaw es
626           return $ MV_5 n_ as' bs' cs' ds' es'
627   {-# INLINE basicLength  #-}
628   basicLength (V_5 n_ as bs cs ds es) = n_
629   {-# INLINE basicUnsafeSlice  #-}
630   basicUnsafeSlice i_ m_ (V_5 n_ as bs cs ds es)
631       = V_5 m_ (G.basicUnsafeSlice i_ m_ as)
632                (G.basicUnsafeSlice i_ m_ bs)
633                (G.basicUnsafeSlice i_ m_ cs)
634                (G.basicUnsafeSlice i_ m_ ds)
635                (G.basicUnsafeSlice i_ m_ es)
636   {-# INLINE basicUnsafeIndexM  #-}
637   basicUnsafeIndexM (V_5 n_ as bs cs ds es) i_
638       = do
639           a <- G.basicUnsafeIndexM as i_
640           b <- G.basicUnsafeIndexM bs i_
641           c <- G.basicUnsafeIndexM cs i_
642           d <- G.basicUnsafeIndexM ds i_
643           e <- G.basicUnsafeIndexM es i_
644           return (a, b, c, d, e)
645   {-# INLINE basicUnsafeCopy  #-}
646   basicUnsafeCopy (MV_5 n_1 as1 bs1 cs1 ds1 es1) (V_5 n_2 as2
647                                                           bs2
648                                                           cs2
649                                                           ds2
650                                                           es2)
651       = do
652           G.basicUnsafeCopy as1 as2
653           G.basicUnsafeCopy bs1 bs2
654           G.basicUnsafeCopy cs1 cs2
655           G.basicUnsafeCopy ds1 ds2
656           G.basicUnsafeCopy es1 es2
657   {-# INLINE elemseq  #-}
658   elemseq _ (a, b, c, d, e)
659       = G.elemseq (undefined :: Vector a) a
660         . G.elemseq (undefined :: Vector b) b
661         . G.elemseq (undefined :: Vector c) c
662         . G.elemseq (undefined :: Vector d) d
663         . G.elemseq (undefined :: Vector e) e
664 #endif
665 #ifdef DEFINE_MUTABLE
666 -- | /O(1)/ Zip 5 vectors
667 zip5 :: (Unbox a,
668          Unbox b,
669          Unbox c,
670          Unbox d,
671          Unbox e) => MVector s a ->
672                      MVector s b ->
673                      MVector s c ->
674                      MVector s d ->
675                      MVector s e -> MVector s (a, b, c, d, e)
676 {-# INLINE_STREAM zip5 #-}
677 zip5 as bs cs ds es = MV_5 len (unsafeSlice 0 len as)
678                                (unsafeSlice 0 len bs)
679                                (unsafeSlice 0 len cs)
680                                (unsafeSlice 0 len ds)
681                                (unsafeSlice 0 len es)
682   where
683     len = length as `min`
684           length bs `min`
685           length cs `min`
686           length ds `min`
687           length es
688 -- | /O(1)/ Unzip 5 vectors
689 unzip5 :: (Unbox a,
690            Unbox b,
691            Unbox c,
692            Unbox d,
693            Unbox e) => MVector s (a, b, c, d, e) -> (MVector s a,
694                                                      MVector s b,
695                                                      MVector s c,
696                                                      MVector s d,
697                                                      MVector s e)
698 {-# INLINE unzip5 #-}
699 unzip5 (MV_5 n_ as bs cs ds es) = (as, bs, cs, ds, es)
700 #endif
701 #ifdef DEFINE_IMMUTABLE
702 -- | /O(1)/ Zip 5 vectors
703 zip5 :: (Unbox a,
704          Unbox b,
705          Unbox c,
706          Unbox d,
707          Unbox e) => Vector a ->
708                      Vector b ->
709                      Vector c ->
710                      Vector d ->
711                      Vector e -> Vector (a, b, c, d, e)
712 {-# INLINE_STREAM zip5 #-}
713 zip5 as bs cs ds es = V_5 len (unsafeSlice 0 len as)
714                               (unsafeSlice 0 len bs)
715                               (unsafeSlice 0 len cs)
716                               (unsafeSlice 0 len ds)
717                               (unsafeSlice 0 len es)
718   where
719     len = length as `min`
720           length bs `min`
721           length cs `min`
722           length ds `min`
723           length es
724 {-# RULES "stream/zip5 [Vector.Unboxed]" forall as bs cs ds es .
725   G.stream (zip5 as
726                  bs
727                  cs
728                  ds
729                  es) = Stream.zipWith5 (, , , ,) (G.stream as)
730                                                  (G.stream bs)
731                                                  (G.stream cs)
732                                                  (G.stream ds)
733                                                  (G.stream es)
734   #-}
735 -- | /O(1)/ Unzip 5 vectors
736 unzip5 :: (Unbox a,
737            Unbox b,
738            Unbox c,
739            Unbox d,
740            Unbox e) => Vector (a, b, c, d, e) -> (Vector a,
741                                                   Vector b,
742                                                   Vector c,
743                                                   Vector d,
744                                                   Vector e)
745 {-# INLINE unzip5 #-}
746 unzip5 (V_5 n_ as bs cs ds es) = (as, bs, cs, ds, es)
747 #endif
748 #ifdef DEFINE_INSTANCES
749 data instance MVector s (a, b, c, d, e, f)
750     = MV_6 {-# UNPACK #-} !Int !(MVector s a)
751                                !(MVector s b)
752                                !(MVector s c)
753                                !(MVector s d)
754                                !(MVector s e)
755                                !(MVector s f)
756 data instance Vector (a, b, c, d, e, f)
757     = V_6 {-# UNPACK #-} !Int !(Vector a)
758                               !(Vector b)
759                               !(Vector c)
760                               !(Vector d)
761                               !(Vector e)
762                               !(Vector f)
763 instance (Unbox a,
764           Unbox b,
765           Unbox c,
766           Unbox d,
767           Unbox e,
768           Unbox f) => Unbox (a, b, c, d, e, f)
769 instance (Unbox a,
770           Unbox b,
771           Unbox c,
772           Unbox d,
773           Unbox e,
774           Unbox f) => M.MVector MVector (a, b, c, d, e, f) where
775   {-# INLINE basicLength  #-}
776   basicLength (MV_6 n_ as bs cs ds es fs) = n_
777   {-# INLINE basicUnsafeSlice  #-}
778   basicUnsafeSlice i_ m_ (MV_6 n_ as bs cs ds es fs)
779       = MV_6 m_ (M.basicUnsafeSlice i_ m_ as)
780                 (M.basicUnsafeSlice i_ m_ bs)
781                 (M.basicUnsafeSlice i_ m_ cs)
782                 (M.basicUnsafeSlice i_ m_ ds)
783                 (M.basicUnsafeSlice i_ m_ es)
784                 (M.basicUnsafeSlice i_ m_ fs)
785   {-# INLINE basicOverlaps  #-}
786   basicOverlaps (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
787                                                              bs2
788                                                              cs2
789                                                              ds2
790                                                              es2
791                                                              fs2)
792       = M.basicOverlaps as1 as2
793         || M.basicOverlaps bs1 bs2
794         || M.basicOverlaps cs1 cs2
795         || M.basicOverlaps ds1 ds2
796         || M.basicOverlaps es1 es2
797         || M.basicOverlaps fs1 fs2
798   {-# INLINE basicUnsafeNew  #-}
799   basicUnsafeNew n_
800       = do
801           as <- M.basicUnsafeNew n_
802           bs <- M.basicUnsafeNew n_
803           cs <- M.basicUnsafeNew n_
804           ds <- M.basicUnsafeNew n_
805           es <- M.basicUnsafeNew n_
806           fs <- M.basicUnsafeNew n_
807           return $ MV_6 n_ as bs cs ds es fs
808   {-# INLINE basicUnsafeReplicate  #-}
809   basicUnsafeReplicate n_ (a, b, c, d, e, f)
810       = do
811           as <- M.basicUnsafeReplicate n_ a
812           bs <- M.basicUnsafeReplicate n_ b
813           cs <- M.basicUnsafeReplicate n_ c
814           ds <- M.basicUnsafeReplicate n_ d
815           es <- M.basicUnsafeReplicate n_ e
816           fs <- M.basicUnsafeReplicate n_ f
817           return $ MV_6 n_ as bs cs ds es fs
818   {-# INLINE basicUnsafeRead  #-}
819   basicUnsafeRead (MV_6 n_ as bs cs ds es fs) i_
820       = do
821           a <- M.basicUnsafeRead as i_
822           b <- M.basicUnsafeRead bs i_
823           c <- M.basicUnsafeRead cs i_
824           d <- M.basicUnsafeRead ds i_
825           e <- M.basicUnsafeRead es i_
826           f <- M.basicUnsafeRead fs i_
827           return (a, b, c, d, e, f)
828   {-# INLINE basicUnsafeWrite  #-}
829   basicUnsafeWrite (MV_6 n_ as bs cs ds es fs) i_ (a, b, c, d, e, f)
830       = do
831           M.basicUnsafeWrite as i_ a
832           M.basicUnsafeWrite bs i_ b
833           M.basicUnsafeWrite cs i_ c
834           M.basicUnsafeWrite ds i_ d
835           M.basicUnsafeWrite es i_ e
836           M.basicUnsafeWrite fs i_ f
837   {-# INLINE basicClear  #-}
838   basicClear (MV_6 n_ as bs cs ds es fs)
839       = do
840           M.basicClear as
841           M.basicClear bs
842           M.basicClear cs
843           M.basicClear ds
844           M.basicClear es
845           M.basicClear fs
846   {-# INLINE basicSet  #-}
847   basicSet (MV_6 n_ as bs cs ds es fs) (a, b, c, d, e, f)
848       = do
849           M.basicSet as a
850           M.basicSet bs b
851           M.basicSet cs c
852           M.basicSet ds d
853           M.basicSet es e
854           M.basicSet fs f
855   {-# INLINE basicUnsafeCopy  #-}
856   basicUnsafeCopy (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
857                                                                bs2
858                                                                cs2
859                                                                ds2
860                                                                es2
861                                                                fs2)
862       = do
863           M.basicUnsafeCopy as1 as2
864           M.basicUnsafeCopy bs1 bs2
865           M.basicUnsafeCopy cs1 cs2
866           M.basicUnsafeCopy ds1 ds2
867           M.basicUnsafeCopy es1 es2
868           M.basicUnsafeCopy fs1 fs2
869   {-# INLINE basicUnsafeGrow  #-}
870   basicUnsafeGrow (MV_6 n_ as bs cs ds es fs) m_
871       = do
872           as' <- M.basicUnsafeGrow as m_
873           bs' <- M.basicUnsafeGrow bs m_
874           cs' <- M.basicUnsafeGrow cs m_
875           ds' <- M.basicUnsafeGrow ds m_
876           es' <- M.basicUnsafeGrow es m_
877           fs' <- M.basicUnsafeGrow fs m_
878           return $ MV_6 (m_+n_) as' bs' cs' ds' es' fs'
879 instance (Unbox a,
880           Unbox b,
881           Unbox c,
882           Unbox d,
883           Unbox e,
884           Unbox f) => G.Vector Vector (a, b, c, d, e, f) where
885   {-# INLINE basicUnsafeFreeze  #-}
886   basicUnsafeFreeze (MV_6 n_ as bs cs ds es fs)
887       = do
888           as' <- G.basicUnsafeFreeze as
889           bs' <- G.basicUnsafeFreeze bs
890           cs' <- G.basicUnsafeFreeze cs
891           ds' <- G.basicUnsafeFreeze ds
892           es' <- G.basicUnsafeFreeze es
893           fs' <- G.basicUnsafeFreeze fs
894           return $ V_6 n_ as' bs' cs' ds' es' fs'
895   {-# INLINE basicUnsafeThaw  #-}
896   basicUnsafeThaw (V_6 n_ as bs cs ds es fs)
897       = do
898           as' <- G.basicUnsafeThaw as
899           bs' <- G.basicUnsafeThaw bs
900           cs' <- G.basicUnsafeThaw cs
901           ds' <- G.basicUnsafeThaw ds
902           es' <- G.basicUnsafeThaw es
903           fs' <- G.basicUnsafeThaw fs
904           return $ MV_6 n_ as' bs' cs' ds' es' fs'
905   {-# INLINE basicLength  #-}
906   basicLength (V_6 n_ as bs cs ds es fs) = n_
907   {-# INLINE basicUnsafeSlice  #-}
908   basicUnsafeSlice i_ m_ (V_6 n_ as bs cs ds es fs)
909       = V_6 m_ (G.basicUnsafeSlice i_ m_ as)
910                (G.basicUnsafeSlice i_ m_ bs)
911                (G.basicUnsafeSlice i_ m_ cs)
912                (G.basicUnsafeSlice i_ m_ ds)
913                (G.basicUnsafeSlice i_ m_ es)
914                (G.basicUnsafeSlice i_ m_ fs)
915   {-# INLINE basicUnsafeIndexM  #-}
916   basicUnsafeIndexM (V_6 n_ as bs cs ds es fs) i_
917       = do
918           a <- G.basicUnsafeIndexM as i_
919           b <- G.basicUnsafeIndexM bs i_
920           c <- G.basicUnsafeIndexM cs i_
921           d <- G.basicUnsafeIndexM ds i_
922           e <- G.basicUnsafeIndexM es i_
923           f <- G.basicUnsafeIndexM fs i_
924           return (a, b, c, d, e, f)
925   {-# INLINE basicUnsafeCopy  #-}
926   basicUnsafeCopy (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (V_6 n_2 as2
927                                                               bs2
928                                                               cs2
929                                                               ds2
930                                                               es2
931                                                               fs2)
932       = do
933           G.basicUnsafeCopy as1 as2
934           G.basicUnsafeCopy bs1 bs2
935           G.basicUnsafeCopy cs1 cs2
936           G.basicUnsafeCopy ds1 ds2
937           G.basicUnsafeCopy es1 es2
938           G.basicUnsafeCopy fs1 fs2
939   {-# INLINE elemseq  #-}
940   elemseq _ (a, b, c, d, e, f)
941       = G.elemseq (undefined :: Vector a) a
942         . G.elemseq (undefined :: Vector b) b
943         . G.elemseq (undefined :: Vector c) c
944         . G.elemseq (undefined :: Vector d) d
945         . G.elemseq (undefined :: Vector e) e
946         . G.elemseq (undefined :: Vector f) f
947 #endif
948 #ifdef DEFINE_MUTABLE
949 -- | /O(1)/ Zip 6 vectors
950 zip6 :: (Unbox a,
951          Unbox b,
952          Unbox c,
953          Unbox d,
954          Unbox e,
955          Unbox f) => MVector s a ->
956                      MVector s b ->
957                      MVector s c ->
958                      MVector s d ->
959                      MVector s e ->
960                      MVector s f -> MVector s (a, b, c, d, e, f)
961 {-# INLINE_STREAM zip6 #-}
962 zip6 as bs cs ds es fs = MV_6 len (unsafeSlice 0 len as)
963                                   (unsafeSlice 0 len bs)
964                                   (unsafeSlice 0 len cs)
965                                   (unsafeSlice 0 len ds)
966                                   (unsafeSlice 0 len es)
967                                   (unsafeSlice 0 len fs)
968   where
969     len = length as `min`
970           length bs `min`
971           length cs `min`
972           length ds `min`
973           length es `min`
974           length fs
975 -- | /O(1)/ Unzip 6 vectors
976 unzip6 :: (Unbox a,
977            Unbox b,
978            Unbox c,
979            Unbox d,
980            Unbox e,
981            Unbox f) => MVector s (a, b, c, d, e, f) -> (MVector s a,
982                                                         MVector s b,
983                                                         MVector s c,
984                                                         MVector s d,
985                                                         MVector s e,
986                                                         MVector s f)
987 {-# INLINE unzip6 #-}
988 unzip6 (MV_6 n_ as bs cs ds es fs) = (as, bs, cs, ds, es, fs)
989 #endif
990 #ifdef DEFINE_IMMUTABLE
991 -- | /O(1)/ Zip 6 vectors
992 zip6 :: (Unbox a,
993          Unbox b,
994          Unbox c,
995          Unbox d,
996          Unbox e,
997          Unbox f) => Vector a ->
998                      Vector b ->
999                      Vector c ->
1000                      Vector d ->
1001                      Vector e ->
1002                      Vector f -> Vector (a, b, c, d, e, f)
1003 {-# INLINE_STREAM zip6 #-}
1004 zip6 as bs cs ds es fs = V_6 len (unsafeSlice 0 len as)
1005                                  (unsafeSlice 0 len bs)
1006                                  (unsafeSlice 0 len cs)
1007                                  (unsafeSlice 0 len ds)
1008                                  (unsafeSlice 0 len es)
1009                                  (unsafeSlice 0 len fs)
1010   where
1011     len = length as `min`
1012           length bs `min`
1013           length cs `min`
1014           length ds `min`
1015           length es `min`
1016           length fs
1017 {-# RULES "stream/zip6 [Vector.Unboxed]" forall as bs cs ds es fs .
1018   G.stream (zip6 as
1019                  bs
1020                  cs
1021                  ds
1022                  es
1023                  fs) = Stream.zipWith6 (, , , , ,) (G.stream as)
1024                                                    (G.stream bs)
1025                                                    (G.stream cs)
1026                                                    (G.stream ds)
1027                                                    (G.stream es)
1028                                                    (G.stream fs)
1029   #-}
1030 -- | /O(1)/ Unzip 6 vectors
1031 unzip6 :: (Unbox a,
1032            Unbox b,
1033            Unbox c,
1034            Unbox d,
1035            Unbox e,
1036            Unbox f) => Vector (a, b, c, d, e, f) -> (Vector a,
1037                                                      Vector b,
1038                                                      Vector c,
1039                                                      Vector d,
1040                                                      Vector e,
1041                                                      Vector f)
1042 {-# INLINE unzip6 #-}
1043 unzip6 (V_6 n_ as bs cs ds es fs) = (as, bs, cs, ds, es, fs)
1044 #endif