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