{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE TypeFamilies #-}
#ifndef MIN_VERSION_vector
#define MIN_VERSION_vector(x,y,z) 1
#endif
module SDL.Internal.Vect
( Point (..)
, V2 (..)
, V3 (..)
, V4 (..)
) where
import Control.Applicative
import Control.Monad (liftM)
import Control.Monad.Fix
import Control.Monad.Zip
import Data.Data
import Data.Foldable
import Data.Monoid
import Data.Traversable
import qualified Data.Vector.Generic as G
import qualified Data.Vector.Generic.Mutable as M
import qualified Data.Vector.Unboxed.Base as U
import Foreign.Ptr (castPtr)
import Foreign.Storable (Storable (..))
import GHC.Arr (Ix (..))
import GHC.Generics (Generic, Generic1)
import Prelude
{-# ANN module "HLint: ignore Reduce duplication" #-}
{-# ANN module "HLint: ignore Use fmap" #-}
newtype Point f a = P (f a)
deriving ( Point f a -> Point f a -> Bool
(Point f a -> Point f a -> Bool)
-> (Point f a -> Point f a -> Bool) -> Eq (Point f a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (f :: * -> *) a. Eq (f a) => Point f a -> Point f a -> Bool
/= :: Point f a -> Point f a -> Bool
$c/= :: forall (f :: * -> *) a. Eq (f a) => Point f a -> Point f a -> Bool
== :: Point f a -> Point f a -> Bool
$c== :: forall (f :: * -> *) a. Eq (f a) => Point f a -> Point f a -> Bool
Eq, Eq (Point f a)
Eq (Point f a) =>
(Point f a -> Point f a -> Ordering)
-> (Point f a -> Point f a -> Bool)
-> (Point f a -> Point f a -> Bool)
-> (Point f a -> Point f a -> Bool)
-> (Point f a -> Point f a -> Bool)
-> (Point f a -> Point f a -> Point f a)
-> (Point f a -> Point f a -> Point f a)
-> Ord (Point f a)
Point f a -> Point f a -> Bool
Point f a -> Point f a -> Ordering
Point f a -> Point f a -> Point f a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall (f :: * -> *) a. Ord (f a) => Eq (Point f a)
forall (f :: * -> *) a. Ord (f a) => Point f a -> Point f a -> Bool
forall (f :: * -> *) a.
Ord (f a) =>
Point f a -> Point f a -> Ordering
forall (f :: * -> *) a.
Ord (f a) =>
Point f a -> Point f a -> Point f a
min :: Point f a -> Point f a -> Point f a
$cmin :: forall (f :: * -> *) a.
Ord (f a) =>
Point f a -> Point f a -> Point f a
max :: Point f a -> Point f a -> Point f a
$cmax :: forall (f :: * -> *) a.
Ord (f a) =>
Point f a -> Point f a -> Point f a
>= :: Point f a -> Point f a -> Bool
$c>= :: forall (f :: * -> *) a. Ord (f a) => Point f a -> Point f a -> Bool
> :: Point f a -> Point f a -> Bool
$c> :: forall (f :: * -> *) a. Ord (f a) => Point f a -> Point f a -> Bool
<= :: Point f a -> Point f a -> Bool
$c<= :: forall (f :: * -> *) a. Ord (f a) => Point f a -> Point f a -> Bool
< :: Point f a -> Point f a -> Bool
$c< :: forall (f :: * -> *) a. Ord (f a) => Point f a -> Point f a -> Bool
compare :: Point f a -> Point f a -> Ordering
$ccompare :: forall (f :: * -> *) a.
Ord (f a) =>
Point f a -> Point f a -> Ordering
$cp1Ord :: forall (f :: * -> *) a. Ord (f a) => Eq (Point f a)
Ord, Int -> Point f a -> ShowS
[Point f a] -> ShowS
Point f a -> String
(Int -> Point f a -> ShowS)
-> (Point f a -> String)
-> ([Point f a] -> ShowS)
-> Show (Point f a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (f :: * -> *) a. Show (f a) => Int -> Point f a -> ShowS
forall (f :: * -> *) a. Show (f a) => [Point f a] -> ShowS
forall (f :: * -> *) a. Show (f a) => Point f a -> String
showList :: [Point f a] -> ShowS
$cshowList :: forall (f :: * -> *) a. Show (f a) => [Point f a] -> ShowS
show :: Point f a -> String
$cshow :: forall (f :: * -> *) a. Show (f a) => Point f a -> String
showsPrec :: Int -> Point f a -> ShowS
$cshowsPrec :: forall (f :: * -> *) a. Show (f a) => Int -> Point f a -> ShowS
Show, ReadPrec [Point f a]
ReadPrec (Point f a)
Int -> ReadS (Point f a)
ReadS [Point f a]
(Int -> ReadS (Point f a))
-> ReadS [Point f a]
-> ReadPrec (Point f a)
-> ReadPrec [Point f a]
-> Read (Point f a)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall (f :: * -> *) a. Read (f a) => ReadPrec [Point f a]
forall (f :: * -> *) a. Read (f a) => ReadPrec (Point f a)
forall (f :: * -> *) a. Read (f a) => Int -> ReadS (Point f a)
forall (f :: * -> *) a. Read (f a) => ReadS [Point f a]
readListPrec :: ReadPrec [Point f a]
$creadListPrec :: forall (f :: * -> *) a. Read (f a) => ReadPrec [Point f a]
readPrec :: ReadPrec (Point f a)
$creadPrec :: forall (f :: * -> *) a. Read (f a) => ReadPrec (Point f a)
readList :: ReadS [Point f a]
$creadList :: forall (f :: * -> *) a. Read (f a) => ReadS [Point f a]
readsPrec :: Int -> ReadS (Point f a)
$creadsPrec :: forall (f :: * -> *) a. Read (f a) => Int -> ReadS (Point f a)
Read, Applicative (Point f)
a -> Point f a
Applicative (Point f) =>
(forall a b. Point f a -> (a -> Point f b) -> Point f b)
-> (forall a b. Point f a -> Point f b -> Point f b)
-> (forall a. a -> Point f a)
-> Monad (Point f)
Point f a -> (a -> Point f b) -> Point f b
Point f a -> Point f b -> Point f b
forall a. a -> Point f a
forall a b. Point f a -> Point f b -> Point f b
forall a b. Point f a -> (a -> Point f b) -> Point f b
forall (f :: * -> *). Monad f => Applicative (Point f)
forall (f :: * -> *) a. Monad f => a -> Point f a
forall (f :: * -> *) a b.
Monad f =>
Point f a -> Point f b -> Point f b
forall (f :: * -> *) a b.
Monad f =>
Point f a -> (a -> Point f b) -> Point f b
forall (m :: * -> *).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> Point f a
$creturn :: forall (f :: * -> *) a. Monad f => a -> Point f a
>> :: Point f a -> Point f b -> Point f b
$c>> :: forall (f :: * -> *) a b.
Monad f =>
Point f a -> Point f b -> Point f b
>>= :: Point f a -> (a -> Point f b) -> Point f b
$c>>= :: forall (f :: * -> *) a b.
Monad f =>
Point f a -> (a -> Point f b) -> Point f b
$cp1Monad :: forall (f :: * -> *). Monad f => Applicative (Point f)
Monad, a -> Point f b -> Point f a
(a -> b) -> Point f a -> Point f b
(forall a b. (a -> b) -> Point f a -> Point f b)
-> (forall a b. a -> Point f b -> Point f a) -> Functor (Point f)
forall a b. a -> Point f b -> Point f a
forall a b. (a -> b) -> Point f a -> Point f b
forall (f :: * -> *) a b. Functor f => a -> Point f b -> Point f a
forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> Point f a -> Point f b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Point f b -> Point f a
$c<$ :: forall (f :: * -> *) a b. Functor f => a -> Point f b -> Point f a
fmap :: (a -> b) -> Point f a -> Point f b
$cfmap :: forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> Point f a -> Point f b
Functor, Functor (Point f)
a -> Point f a
Functor (Point f) =>
(forall a. a -> Point f a)
-> (forall a b. Point f (a -> b) -> Point f a -> Point f b)
-> (forall a b c.
(a -> b -> c) -> Point f a -> Point f b -> Point f c)
-> (forall a b. Point f a -> Point f b -> Point f b)
-> (forall a b. Point f a -> Point f b -> Point f a)
-> Applicative (Point f)
Point f a -> Point f b -> Point f b
Point f a -> Point f b -> Point f a
Point f (a -> b) -> Point f a -> Point f b
(a -> b -> c) -> Point f a -> Point f b -> Point f c
forall a. a -> Point f a
forall a b. Point f a -> Point f b -> Point f a
forall a b. Point f a -> Point f b -> Point f b
forall a b. Point f (a -> b) -> Point f a -> Point f b
forall a b c. (a -> b -> c) -> Point f a -> Point f b -> Point f c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
forall (f :: * -> *). Applicative f => Functor (Point f)
forall (f :: * -> *) a. Applicative f => a -> Point f a
forall (f :: * -> *) a b.
Applicative f =>
Point f a -> Point f b -> Point f a
forall (f :: * -> *) a b.
Applicative f =>
Point f a -> Point f b -> Point f b
forall (f :: * -> *) a b.
Applicative f =>
Point f (a -> b) -> Point f a -> Point f b
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> Point f a -> Point f b -> Point f c
<* :: Point f a -> Point f b -> Point f a
$c<* :: forall (f :: * -> *) a b.
Applicative f =>
Point f a -> Point f b -> Point f a
*> :: Point f a -> Point f b -> Point f b
$c*> :: forall (f :: * -> *) a b.
Applicative f =>
Point f a -> Point f b -> Point f b
liftA2 :: (a -> b -> c) -> Point f a -> Point f b -> Point f c
$cliftA2 :: forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> Point f a -> Point f b -> Point f c
<*> :: Point f (a -> b) -> Point f a -> Point f b
$c<*> :: forall (f :: * -> *) a b.
Applicative f =>
Point f (a -> b) -> Point f a -> Point f b
pure :: a -> Point f a
$cpure :: forall (f :: * -> *) a. Applicative f => a -> Point f a
$cp1Applicative :: forall (f :: * -> *). Applicative f => Functor (Point f)
Applicative, a -> Point f a -> Bool
Point f m -> m
Point f a -> [a]
Point f a -> Bool
Point f a -> Int
Point f a -> a
Point f a -> a
Point f a -> a
Point f a -> a
(a -> m) -> Point f a -> m
(a -> m) -> Point f a -> m
(a -> b -> b) -> b -> Point f a -> b
(a -> b -> b) -> b -> Point f a -> b
(b -> a -> b) -> b -> Point f a -> b
(b -> a -> b) -> b -> Point f a -> b
(a -> a -> a) -> Point f a -> a
(a -> a -> a) -> Point f a -> a
(forall m. Monoid m => Point f m -> m)
-> (forall m a. Monoid m => (a -> m) -> Point f a -> m)
-> (forall m a. Monoid m => (a -> m) -> Point f a -> m)
-> (forall a b. (a -> b -> b) -> b -> Point f a -> b)
-> (forall a b. (a -> b -> b) -> b -> Point f a -> b)
-> (forall b a. (b -> a -> b) -> b -> Point f a -> b)
-> (forall b a. (b -> a -> b) -> b -> Point f a -> b)
-> (forall a. (a -> a -> a) -> Point f a -> a)
-> (forall a. (a -> a -> a) -> Point f a -> a)
-> (forall a. Point f a -> [a])
-> (forall a. Point f a -> Bool)
-> (forall a. Point f a -> Int)
-> (forall a. Eq a => a -> Point f a -> Bool)
-> (forall a. Ord a => Point f a -> a)
-> (forall a. Ord a => Point f a -> a)
-> (forall a. Num a => Point f a -> a)
-> (forall a. Num a => Point f a -> a)
-> Foldable (Point f)
forall a. Eq a => a -> Point f a -> Bool
forall a. Num a => Point f a -> a
forall a. Ord a => Point f a -> a
forall m. Monoid m => Point f m -> m
forall a. Point f a -> Bool
forall a. Point f a -> Int
forall a. Point f a -> [a]
forall a. (a -> a -> a) -> Point f a -> a
forall m a. Monoid m => (a -> m) -> Point f a -> m
forall b a. (b -> a -> b) -> b -> Point f a -> b
forall a b. (a -> b -> b) -> b -> Point f a -> b
forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> Point f a -> Bool
forall (f :: * -> *) a. (Foldable f, Num a) => Point f a -> a
forall (f :: * -> *) a. (Foldable f, Ord a) => Point f a -> a
forall (f :: * -> *) m. (Foldable f, Monoid m) => Point f m -> m
forall (f :: * -> *) a. Foldable f => Point f a -> Bool
forall (f :: * -> *) a. Foldable f => Point f a -> Int
forall (f :: * -> *) a. Foldable f => Point f a -> [a]
forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> Point f a -> a
forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> Point f a -> m
forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> Point f a -> b
forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> Point f a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Point f a -> a
$cproduct :: forall (f :: * -> *) a. (Foldable f, Num a) => Point f a -> a
sum :: Point f a -> a
$csum :: forall (f :: * -> *) a. (Foldable f, Num a) => Point f a -> a
minimum :: Point f a -> a
$cminimum :: forall (f :: * -> *) a. (Foldable f, Ord a) => Point f a -> a
maximum :: Point f a -> a
$cmaximum :: forall (f :: * -> *) a. (Foldable f, Ord a) => Point f a -> a
elem :: a -> Point f a -> Bool
$celem :: forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> Point f a -> Bool
length :: Point f a -> Int
$clength :: forall (f :: * -> *) a. Foldable f => Point f a -> Int
null :: Point f a -> Bool
$cnull :: forall (f :: * -> *) a. Foldable f => Point f a -> Bool
toList :: Point f a -> [a]
$ctoList :: forall (f :: * -> *) a. Foldable f => Point f a -> [a]
foldl1 :: (a -> a -> a) -> Point f a -> a
$cfoldl1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> Point f a -> a
foldr1 :: (a -> a -> a) -> Point f a -> a
$cfoldr1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> Point f a -> a
foldl' :: (b -> a -> b) -> b -> Point f a -> b
$cfoldl' :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> Point f a -> b
foldl :: (b -> a -> b) -> b -> Point f a -> b
$cfoldl :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> Point f a -> b
foldr' :: (a -> b -> b) -> b -> Point f a -> b
$cfoldr' :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> Point f a -> b
foldr :: (a -> b -> b) -> b -> Point f a -> b
$cfoldr :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> Point f a -> b
foldMap' :: (a -> m) -> Point f a -> m
$cfoldMap' :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> Point f a -> m
foldMap :: (a -> m) -> Point f a -> m
$cfoldMap :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> Point f a -> m
fold :: Point f m -> m
$cfold :: forall (f :: * -> *) m. (Foldable f, Monoid m) => Point f m -> m
Foldable
, Functor (Point f)
Foldable (Point f)
(Functor (Point f), Foldable (Point f)) =>
(forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Point f a -> f (Point f b))
-> (forall (f :: * -> *) a.
Applicative f =>
Point f (f a) -> f (Point f a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Point f a -> m (Point f b))
-> (forall (m :: * -> *) a.
Monad m =>
Point f (m a) -> m (Point f a))
-> Traversable (Point f)
(a -> f b) -> Point f a -> f (Point f b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (f :: * -> *). Traversable f => Functor (Point f)
forall (f :: * -> *). Traversable f => Foldable (Point f)
forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
Point f (m a) -> m (Point f a)
forall (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
Point f (f a) -> f (Point f a)
forall (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> Point f a -> m (Point f b)
forall (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> Point f a -> f (Point f b)
forall (m :: * -> *) a. Monad m => Point f (m a) -> m (Point f a)
forall (f :: * -> *) a.
Applicative f =>
Point f (f a) -> f (Point f a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Point f a -> m (Point f b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Point f a -> f (Point f b)
sequence :: Point f (m a) -> m (Point f a)
$csequence :: forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
Point f (m a) -> m (Point f a)
mapM :: (a -> m b) -> Point f a -> m (Point f b)
$cmapM :: forall (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> Point f a -> m (Point f b)
sequenceA :: Point f (f a) -> f (Point f a)
$csequenceA :: forall (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
Point f (f a) -> f (Point f a)
traverse :: (a -> f b) -> Point f a -> f (Point f b)
$ctraverse :: forall (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> Point f a -> f (Point f b)
$cp2Traversable :: forall (f :: * -> *). Traversable f => Foldable (Point f)
$cp1Traversable :: forall (f :: * -> *). Traversable f => Functor (Point f)
Traversable, Num (Point f a)
Num (Point f a) =>
(Point f a -> Point f a -> Point f a)
-> (Point f a -> Point f a)
-> (Rational -> Point f a)
-> Fractional (Point f a)
Rational -> Point f a
Point f a -> Point f a
Point f a -> Point f a -> Point f a
forall a.
Num a =>
(a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
forall (f :: * -> *) a. Fractional (f a) => Num (Point f a)
forall (f :: * -> *) a. Fractional (f a) => Rational -> Point f a
forall (f :: * -> *) a. Fractional (f a) => Point f a -> Point f a
forall (f :: * -> *) a.
Fractional (f a) =>
Point f a -> Point f a -> Point f a
fromRational :: Rational -> Point f a
$cfromRational :: forall (f :: * -> *) a. Fractional (f a) => Rational -> Point f a
recip :: Point f a -> Point f a
$crecip :: forall (f :: * -> *) a. Fractional (f a) => Point f a -> Point f a
/ :: Point f a -> Point f a -> Point f a
$c/ :: forall (f :: * -> *) a.
Fractional (f a) =>
Point f a -> Point f a -> Point f a
$cp1Fractional :: forall (f :: * -> *) a. Fractional (f a) => Num (Point f a)
Fractional , Integer -> Point f a
Point f a -> Point f a
Point f a -> Point f a -> Point f a
(Point f a -> Point f a -> Point f a)
-> (Point f a -> Point f a -> Point f a)
-> (Point f a -> Point f a -> Point f a)
-> (Point f a -> Point f a)
-> (Point f a -> Point f a)
-> (Point f a -> Point f a)
-> (Integer -> Point f a)
-> Num (Point f a)
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
forall (f :: * -> *) a. Num (f a) => Integer -> Point f a
forall (f :: * -> *) a. Num (f a) => Point f a -> Point f a
forall (f :: * -> *) a.
Num (f a) =>
Point f a -> Point f a -> Point f a
fromInteger :: Integer -> Point f a
$cfromInteger :: forall (f :: * -> *) a. Num (f a) => Integer -> Point f a
signum :: Point f a -> Point f a
$csignum :: forall (f :: * -> *) a. Num (f a) => Point f a -> Point f a
abs :: Point f a -> Point f a
$cabs :: forall (f :: * -> *) a. Num (f a) => Point f a -> Point f a
negate :: Point f a -> Point f a
$cnegate :: forall (f :: * -> *) a. Num (f a) => Point f a -> Point f a
* :: Point f a -> Point f a -> Point f a
$c* :: forall (f :: * -> *) a.
Num (f a) =>
Point f a -> Point f a -> Point f a
- :: Point f a -> Point f a -> Point f a
$c- :: forall (f :: * -> *) a.
Num (f a) =>
Point f a -> Point f a -> Point f a
+ :: Point f a -> Point f a -> Point f a
$c+ :: forall (f :: * -> *) a.
Num (f a) =>
Point f a -> Point f a -> Point f a
Num, Ord (Point f a)
Ord (Point f a) =>
((Point f a, Point f a) -> [Point f a])
-> ((Point f a, Point f a) -> Point f a -> Int)
-> ((Point f a, Point f a) -> Point f a -> Int)
-> ((Point f a, Point f a) -> Point f a -> Bool)
-> ((Point f a, Point f a) -> Int)
-> ((Point f a, Point f a) -> Int)
-> Ix (Point f a)
(Point f a, Point f a) -> Int
(Point f a, Point f a) -> [Point f a]
(Point f a, Point f a) -> Point f a -> Bool
(Point f a, Point f a) -> Point f a -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
forall (f :: * -> *) a. Ix (f a) => Ord (Point f a)
forall (f :: * -> *) a. Ix (f a) => (Point f a, Point f a) -> Int
forall (f :: * -> *) a.
Ix (f a) =>
(Point f a, Point f a) -> [Point f a]
forall (f :: * -> *) a.
Ix (f a) =>
(Point f a, Point f a) -> Point f a -> Bool
forall (f :: * -> *) a.
Ix (f a) =>
(Point f a, Point f a) -> Point f a -> Int
unsafeRangeSize :: (Point f a, Point f a) -> Int
$cunsafeRangeSize :: forall (f :: * -> *) a. Ix (f a) => (Point f a, Point f a) -> Int
rangeSize :: (Point f a, Point f a) -> Int
$crangeSize :: forall (f :: * -> *) a. Ix (f a) => (Point f a, Point f a) -> Int
inRange :: (Point f a, Point f a) -> Point f a -> Bool
$cinRange :: forall (f :: * -> *) a.
Ix (f a) =>
(Point f a, Point f a) -> Point f a -> Bool
unsafeIndex :: (Point f a, Point f a) -> Point f a -> Int
$cunsafeIndex :: forall (f :: * -> *) a.
Ix (f a) =>
(Point f a, Point f a) -> Point f a -> Int
index :: (Point f a, Point f a) -> Point f a -> Int
$cindex :: forall (f :: * -> *) a.
Ix (f a) =>
(Point f a, Point f a) -> Point f a -> Int
range :: (Point f a, Point f a) -> [Point f a]
$crange :: forall (f :: * -> *) a.
Ix (f a) =>
(Point f a, Point f a) -> [Point f a]
$cp1Ix :: forall (f :: * -> *) a. Ix (f a) => Ord (Point f a)
Ix, Ptr b -> Int -> IO (Point f a)
Ptr b -> Int -> Point f a -> IO ()
Ptr (Point f a) -> IO (Point f a)
Ptr (Point f a) -> Int -> IO (Point f a)
Ptr (Point f a) -> Int -> Point f a -> IO ()
Ptr (Point f a) -> Point f a -> IO ()
Point f a -> Int
(Point f a -> Int)
-> (Point f a -> Int)
-> (Ptr (Point f a) -> Int -> IO (Point f a))
-> (Ptr (Point f a) -> Int -> Point f a -> IO ())
-> (forall b. Ptr b -> Int -> IO (Point f a))
-> (forall b. Ptr b -> Int -> Point f a -> IO ())
-> (Ptr (Point f a) -> IO (Point f a))
-> (Ptr (Point f a) -> Point f a -> IO ())
-> Storable (Point f a)
forall b. Ptr b -> Int -> IO (Point f a)
forall b. Ptr b -> Int -> Point f a -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
forall (f :: * -> *) a.
Storable (f a) =>
Ptr (Point f a) -> IO (Point f a)
forall (f :: * -> *) a.
Storable (f a) =>
Ptr (Point f a) -> Int -> IO (Point f a)
forall (f :: * -> *) a.
Storable (f a) =>
Ptr (Point f a) -> Int -> Point f a -> IO ()
forall (f :: * -> *) a.
Storable (f a) =>
Ptr (Point f a) -> Point f a -> IO ()
forall (f :: * -> *) a. Storable (f a) => Point f a -> Int
forall (f :: * -> *) a b.
Storable (f a) =>
Ptr b -> Int -> IO (Point f a)
forall (f :: * -> *) a b.
Storable (f a) =>
Ptr b -> Int -> Point f a -> IO ()
poke :: Ptr (Point f a) -> Point f a -> IO ()
$cpoke :: forall (f :: * -> *) a.
Storable (f a) =>
Ptr (Point f a) -> Point f a -> IO ()
peek :: Ptr (Point f a) -> IO (Point f a)
$cpeek :: forall (f :: * -> *) a.
Storable (f a) =>
Ptr (Point f a) -> IO (Point f a)
pokeByteOff :: Ptr b -> Int -> Point f a -> IO ()
$cpokeByteOff :: forall (f :: * -> *) a b.
Storable (f a) =>
Ptr b -> Int -> Point f a -> IO ()
peekByteOff :: Ptr b -> Int -> IO (Point f a)
$cpeekByteOff :: forall (f :: * -> *) a b.
Storable (f a) =>
Ptr b -> Int -> IO (Point f a)
pokeElemOff :: Ptr (Point f a) -> Int -> Point f a -> IO ()
$cpokeElemOff :: forall (f :: * -> *) a.
Storable (f a) =>
Ptr (Point f a) -> Int -> Point f a -> IO ()
peekElemOff :: Ptr (Point f a) -> Int -> IO (Point f a)
$cpeekElemOff :: forall (f :: * -> *) a.
Storable (f a) =>
Ptr (Point f a) -> Int -> IO (Point f a)
alignment :: Point f a -> Int
$calignment :: forall (f :: * -> *) a. Storable (f a) => Point f a -> Int
sizeOf :: Point f a -> Int
$csizeOf :: forall (f :: * -> *) a. Storable (f a) => Point f a -> Int
Storable, (forall x. Point f a -> Rep (Point f a) x)
-> (forall x. Rep (Point f a) x -> Point f a)
-> Generic (Point f a)
forall x. Rep (Point f a) x -> Point f a
forall x. Point f a -> Rep (Point f a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (f :: * -> *) a x. Rep (Point f a) x -> Point f a
forall (f :: * -> *) a x. Point f a -> Rep (Point f a) x
$cto :: forall (f :: * -> *) a x. Rep (Point f a) x -> Point f a
$cfrom :: forall (f :: * -> *) a x. Point f a -> Rep (Point f a) x
Generic, (forall a. Point f a -> Rep1 (Point f) a)
-> (forall a. Rep1 (Point f) a -> Point f a) -> Generic1 (Point f)
forall a. Rep1 (Point f) a -> Point f a
forall a. Point f a -> Rep1 (Point f) a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
forall (f :: * -> *) a. Rep1 (Point f) a -> Point f a
forall (f :: * -> *) a. Point f a -> Rep1 (Point f) a
$cto1 :: forall (f :: * -> *) a. Rep1 (Point f) a -> Point f a
$cfrom1 :: forall (f :: * -> *) a. Point f a -> Rep1 (Point f) a
Generic1
, Typeable, Typeable (Point f a)
DataType
Constr
Typeable (Point f a) =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Point f a -> c (Point f a))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Point f a))
-> (Point f a -> Constr)
-> (Point f a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Point f a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Point f a)))
-> ((forall b. Data b => b -> b) -> Point f a -> Point f a)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Point f a -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Point f a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Point f a -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> Point f a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Point f a -> m (Point f a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Point f a -> m (Point f a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Point f a -> m (Point f a))
-> Data (Point f a)
Point f a -> DataType
Point f a -> Constr
(forall b. Data b => b -> b) -> Point f a -> Point f a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Point f a -> c (Point f a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Point f a)
forall a.
Typeable a =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Point f a -> u
forall u. (forall d. Data d => d -> u) -> Point f a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Point f a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Point f a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Point f a -> m (Point f a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Point f a -> m (Point f a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Point f a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Point f a -> c (Point f a)
forall (f :: * -> *) a.
(Typeable f, Typeable a, Data (f a)) =>
Typeable (Point f a)
forall (f :: * -> *) a.
(Typeable f, Typeable a, Data (f a)) =>
Point f a -> DataType
forall (f :: * -> *) a.
(Typeable f, Typeable a, Data (f a)) =>
Point f a -> Constr
forall (f :: * -> *) a.
(Typeable f, Typeable a, Data (f a)) =>
(forall b. Data b => b -> b) -> Point f a -> Point f a
forall (f :: * -> *) a u.
(Typeable f, Typeable a, Data (f a)) =>
Int -> (forall d. Data d => d -> u) -> Point f a -> u
forall (f :: * -> *) a u.
(Typeable f, Typeable a, Data (f a)) =>
(forall d. Data d => d -> u) -> Point f a -> [u]
forall (f :: * -> *) a r r'.
(Typeable f, Typeable a, Data (f a)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Point f a -> r
forall (f :: * -> *) a r r'.
(Typeable f, Typeable a, Data (f a)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Point f a -> r
forall (f :: * -> *) a (m :: * -> *).
(Typeable f, Typeable a, Data (f a), Monad m) =>
(forall d. Data d => d -> m d) -> Point f a -> m (Point f a)
forall (f :: * -> *) a (m :: * -> *).
(Typeable f, Typeable a, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d) -> Point f a -> m (Point f a)
forall (f :: * -> *) a (c :: * -> *).
(Typeable f, Typeable a, Data (f a)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Point f a)
forall (f :: * -> *) a (c :: * -> *).
(Typeable f, Typeable a, Data (f a)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Point f a -> c (Point f a)
forall (f :: * -> *) a (t :: * -> *) (c :: * -> *).
(Typeable f, Typeable a, Data (f a), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Point f a))
forall (f :: * -> *) a (t :: * -> * -> *) (c :: * -> *).
(Typeable f, Typeable a, Data (f a), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Point f a))
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Point f a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Point f a))
$cP :: Constr
$tPoint :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Point f a -> m (Point f a)
$cgmapMo :: forall (f :: * -> *) a (m :: * -> *).
(Typeable f, Typeable a, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d) -> Point f a -> m (Point f a)
gmapMp :: (forall d. Data d => d -> m d) -> Point f a -> m (Point f a)
$cgmapMp :: forall (f :: * -> *) a (m :: * -> *).
(Typeable f, Typeable a, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d) -> Point f a -> m (Point f a)
gmapM :: (forall d. Data d => d -> m d) -> Point f a -> m (Point f a)
$cgmapM :: forall (f :: * -> *) a (m :: * -> *).
(Typeable f, Typeable a, Data (f a), Monad m) =>
(forall d. Data d => d -> m d) -> Point f a -> m (Point f a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Point f a -> u
$cgmapQi :: forall (f :: * -> *) a u.
(Typeable f, Typeable a, Data (f a)) =>
Int -> (forall d. Data d => d -> u) -> Point f a -> u
gmapQ :: (forall d. Data d => d -> u) -> Point f a -> [u]
$cgmapQ :: forall (f :: * -> *) a u.
(Typeable f, Typeable a, Data (f a)) =>
(forall d. Data d => d -> u) -> Point f a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Point f a -> r
$cgmapQr :: forall (f :: * -> *) a r r'.
(Typeable f, Typeable a, Data (f a)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Point f a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Point f a -> r
$cgmapQl :: forall (f :: * -> *) a r r'.
(Typeable f, Typeable a, Data (f a)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Point f a -> r
gmapT :: (forall b. Data b => b -> b) -> Point f a -> Point f a
$cgmapT :: forall (f :: * -> *) a.
(Typeable f, Typeable a, Data (f a)) =>
(forall b. Data b => b -> b) -> Point f a -> Point f a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Point f a))
$cdataCast2 :: forall (f :: * -> *) a (t :: * -> * -> *) (c :: * -> *).
(Typeable f, Typeable a, Data (f a), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Point f a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Point f a))
$cdataCast1 :: forall (f :: * -> *) a (t :: * -> *) (c :: * -> *).
(Typeable f, Typeable a, Data (f a), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Point f a))
dataTypeOf :: Point f a -> DataType
$cdataTypeOf :: forall (f :: * -> *) a.
(Typeable f, Typeable a, Data (f a)) =>
Point f a -> DataType
toConstr :: Point f a -> Constr
$ctoConstr :: forall (f :: * -> *) a.
(Typeable f, Typeable a, Data (f a)) =>
Point f a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Point f a)
$cgunfold :: forall (f :: * -> *) a (c :: * -> *).
(Typeable f, Typeable a, Data (f a)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Point f a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Point f a -> c (Point f a)
$cgfoldl :: forall (f :: * -> *) a (c :: * -> *).
(Typeable f, Typeable a, Data (f a)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Point f a -> c (Point f a)
$cp1Data :: forall (f :: * -> *) a.
(Typeable f, Typeable a, Data (f a)) =>
Typeable (Point f a)
Data
)
data instance U.Vector (Point f a) = V_P !(U.Vector (f a))
data instance U.MVector s (Point f a) = MV_P !(U.MVector s (f a))
instance U.Unbox (f a) => U.Unbox (Point f a)
instance U.Unbox (f a) => M.MVector U.MVector (Point f a) where
{-# INLINE basicLength #-}
{-# INLINE basicUnsafeSlice #-}
{-# INLINE basicOverlaps #-}
{-# INLINE basicUnsafeNew #-}
{-# INLINE basicUnsafeRead #-}
{-# INLINE basicUnsafeWrite #-}
basicLength :: MVector s (Point f a) -> Int
basicLength (MV_P v) = MVector s (f a) -> Int
forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int
M.basicLength MVector s (f a)
v
basicUnsafeSlice :: Int -> Int -> MVector s (Point f a) -> MVector s (Point f a)
basicUnsafeSlice m :: Int
m n :: Int
n (MV_P v) = MVector s (f a) -> MVector s (Point f a)
forall s (f :: * -> *) a. MVector s (f a) -> MVector s (Point f a)
MV_P (Int -> Int -> MVector s (f a) -> MVector s (f a)
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
M.basicUnsafeSlice Int
m Int
n MVector s (f a)
v)
basicOverlaps :: MVector s (Point f a) -> MVector s (Point f a) -> Bool
basicOverlaps (MV_P v) (MV_P u) = MVector s (f a) -> MVector s (f a) -> Bool
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> Bool
M.basicOverlaps MVector s (f a)
v MVector s (f a)
u
basicUnsafeNew :: Int -> m (MVector (PrimState m) (Point f a))
basicUnsafeNew n :: Int
n = MVector (PrimState m) (f a) -> MVector (PrimState m) (Point f a)
forall s (f :: * -> *) a. MVector s (f a) -> MVector s (Point f a)
MV_P (MVector (PrimState m) (f a) -> MVector (PrimState m) (Point f a))
-> m (MVector (PrimState m) (f a))
-> m (MVector (PrimState m) (Point f a))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Int -> m (MVector (PrimState m) (f a))
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
Int -> m (v (PrimState m) a)
M.basicUnsafeNew Int
n
basicUnsafeRead :: MVector (PrimState m) (Point f a) -> Int -> m (Point f a)
basicUnsafeRead (MV_P v) i :: Int
i = f a -> Point f a
forall (f :: * -> *) a. f a -> Point f a
P (f a -> Point f a) -> m (f a) -> m (Point f a)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` MVector (PrimState m) (f a) -> Int -> m (f a)
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> m a
M.basicUnsafeRead MVector (PrimState m) (f a)
v Int
i
basicUnsafeWrite :: MVector (PrimState m) (Point f a) -> Int -> Point f a -> m ()
basicUnsafeWrite (MV_P v) i :: Int
i (P x :: f a
x) = MVector (PrimState m) (f a) -> Int -> f a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> a -> m ()
M.basicUnsafeWrite MVector (PrimState m) (f a)
v Int
i f a
x
#if MIN_VERSION_vector(0,11,0)
basicInitialize :: MVector (PrimState m) (Point f a) -> m ()
basicInitialize (MV_P v) = MVector (PrimState m) (f a) -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> m ()
M.basicInitialize MVector (PrimState m) (f a)
v
{-# INLINE basicInitialize #-}
#endif
instance U.Unbox (f a) => G.Vector U.Vector (Point f a) where
{-# INLINE basicUnsafeFreeze #-}
{-# INLINE basicUnsafeThaw #-}
{-# INLINE basicLength #-}
{-# INLINE basicUnsafeSlice #-}
{-# INLINE basicUnsafeIndexM #-}
basicUnsafeFreeze :: Mutable Vector (PrimState m) (Point f a) -> m (Vector (Point f a))
basicUnsafeFreeze (MV_P v) = Vector (f a) -> Vector (Point f a)
forall (f :: * -> *) a. Vector (f a) -> Vector (Point f a)
V_P (Vector (f a) -> Vector (Point f a))
-> m (Vector (f a)) -> m (Vector (Point f a))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Mutable Vector (PrimState m) (f a) -> m (Vector (f a))
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
Mutable v (PrimState m) a -> m (v a)
G.basicUnsafeFreeze MVector (PrimState m) (f a)
Mutable Vector (PrimState m) (f a)
v
basicUnsafeThaw :: Vector (Point f a) -> m (Mutable Vector (PrimState m) (Point f a))
basicUnsafeThaw ( V_P v) = MVector (PrimState m) (f a) -> MVector (PrimState m) (Point f a)
forall s (f :: * -> *) a. MVector s (f a) -> MVector s (Point f a)
MV_P (MVector (PrimState m) (f a) -> MVector (PrimState m) (Point f a))
-> m (MVector (PrimState m) (f a))
-> m (MVector (PrimState m) (Point f a))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Vector (f a) -> m (Mutable Vector (PrimState m) (f a))
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
v a -> m (Mutable v (PrimState m) a)
G.basicUnsafeThaw Vector (f a)
v
basicLength :: Vector (Point f a) -> Int
basicLength ( V_P v) = Vector (f a) -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
G.basicLength Vector (f a)
v
basicUnsafeSlice :: Int -> Int -> Vector (Point f a) -> Vector (Point f a)
basicUnsafeSlice m :: Int
m n :: Int
n (V_P v) = Vector (f a) -> Vector (Point f a)
forall (f :: * -> *) a. Vector (f a) -> Vector (Point f a)
V_P (Int -> Int -> Vector (f a) -> Vector (f a)
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
G.basicUnsafeSlice Int
m Int
n Vector (f a)
v)
basicUnsafeIndexM :: Vector (Point f a) -> Int -> m (Point f a)
basicUnsafeIndexM (V_P v) i :: Int
i = f a -> Point f a
forall (f :: * -> *) a. f a -> Point f a
P (f a -> Point f a) -> m (f a) -> m (Point f a)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Vector (f a) -> Int -> m (f a)
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
G.basicUnsafeIndexM Vector (f a)
v Int
i
data V2 a = V2 !a !a
deriving (V2 a -> V2 a -> Bool
(V2 a -> V2 a -> Bool) -> (V2 a -> V2 a -> Bool) -> Eq (V2 a)
forall a. Eq a => V2 a -> V2 a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: V2 a -> V2 a -> Bool
$c/= :: forall a. Eq a => V2 a -> V2 a -> Bool
== :: V2 a -> V2 a -> Bool
$c== :: forall a. Eq a => V2 a -> V2 a -> Bool
Eq, Eq (V2 a)
Eq (V2 a) =>
(V2 a -> V2 a -> Ordering)
-> (V2 a -> V2 a -> Bool)
-> (V2 a -> V2 a -> Bool)
-> (V2 a -> V2 a -> Bool)
-> (V2 a -> V2 a -> Bool)
-> (V2 a -> V2 a -> V2 a)
-> (V2 a -> V2 a -> V2 a)
-> Ord (V2 a)
V2 a -> V2 a -> Bool
V2 a -> V2 a -> Ordering
V2 a -> V2 a -> V2 a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (V2 a)
forall a. Ord a => V2 a -> V2 a -> Bool
forall a. Ord a => V2 a -> V2 a -> Ordering
forall a. Ord a => V2 a -> V2 a -> V2 a
min :: V2 a -> V2 a -> V2 a
$cmin :: forall a. Ord a => V2 a -> V2 a -> V2 a
max :: V2 a -> V2 a -> V2 a
$cmax :: forall a. Ord a => V2 a -> V2 a -> V2 a
>= :: V2 a -> V2 a -> Bool
$c>= :: forall a. Ord a => V2 a -> V2 a -> Bool
> :: V2 a -> V2 a -> Bool
$c> :: forall a. Ord a => V2 a -> V2 a -> Bool
<= :: V2 a -> V2 a -> Bool
$c<= :: forall a. Ord a => V2 a -> V2 a -> Bool
< :: V2 a -> V2 a -> Bool
$c< :: forall a. Ord a => V2 a -> V2 a -> Bool
compare :: V2 a -> V2 a -> Ordering
$ccompare :: forall a. Ord a => V2 a -> V2 a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (V2 a)
Ord, Int -> V2 a -> ShowS
[V2 a] -> ShowS
V2 a -> String
(Int -> V2 a -> ShowS)
-> (V2 a -> String) -> ([V2 a] -> ShowS) -> Show (V2 a)
forall a. Show a => Int -> V2 a -> ShowS
forall a. Show a => [V2 a] -> ShowS
forall a. Show a => V2 a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [V2 a] -> ShowS
$cshowList :: forall a. Show a => [V2 a] -> ShowS
show :: V2 a -> String
$cshow :: forall a. Show a => V2 a -> String
showsPrec :: Int -> V2 a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> V2 a -> ShowS
Show, ReadPrec [V2 a]
ReadPrec (V2 a)
Int -> ReadS (V2 a)
ReadS [V2 a]
(Int -> ReadS (V2 a))
-> ReadS [V2 a]
-> ReadPrec (V2 a)
-> ReadPrec [V2 a]
-> Read (V2 a)
forall a. Read a => ReadPrec [V2 a]
forall a. Read a => ReadPrec (V2 a)
forall a. Read a => Int -> ReadS (V2 a)
forall a. Read a => ReadS [V2 a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [V2 a]
$creadListPrec :: forall a. Read a => ReadPrec [V2 a]
readPrec :: ReadPrec (V2 a)
$creadPrec :: forall a. Read a => ReadPrec (V2 a)
readList :: ReadS [V2 a]
$creadList :: forall a. Read a => ReadS [V2 a]
readsPrec :: Int -> ReadS (V2 a)
$creadsPrec :: forall a. Read a => Int -> ReadS (V2 a)
Read, Typeable (V2 a)
DataType
Constr
Typeable (V2 a) =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> V2 a -> c (V2 a))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (V2 a))
-> (V2 a -> Constr)
-> (V2 a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (V2 a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V2 a)))
-> ((forall b. Data b => b -> b) -> V2 a -> V2 a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V2 a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V2 a -> r)
-> (forall u. (forall d. Data d => d -> u) -> V2 a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> V2 a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> V2 a -> m (V2 a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> V2 a -> m (V2 a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> V2 a -> m (V2 a))
-> Data (V2 a)
V2 a -> DataType
V2 a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (V2 a))
(forall b. Data b => b -> b) -> V2 a -> V2 a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> V2 a -> c (V2 a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (V2 a)
forall a. Data a => Typeable (V2 a)
forall a. Data a => V2 a -> DataType
forall a. Data a => V2 a -> Constr
forall a. Data a => (forall b. Data b => b -> b) -> V2 a -> V2 a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> V2 a -> u
forall a u. Data a => (forall d. Data d => d -> u) -> V2 a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V2 a -> r
forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V2 a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> V2 a -> m (V2 a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> V2 a -> m (V2 a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (V2 a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> V2 a -> c (V2 a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (V2 a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V2 a))
forall a.
Typeable a =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> V2 a -> u
forall u. (forall d. Data d => d -> u) -> V2 a -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V2 a -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V2 a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> V2 a -> m (V2 a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> V2 a -> m (V2 a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (V2 a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> V2 a -> c (V2 a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (V2 a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V2 a))
$cV2 :: Constr
$tV2 :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> V2 a -> m (V2 a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> V2 a -> m (V2 a)
gmapMp :: (forall d. Data d => d -> m d) -> V2 a -> m (V2 a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> V2 a -> m (V2 a)
gmapM :: (forall d. Data d => d -> m d) -> V2 a -> m (V2 a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> V2 a -> m (V2 a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> V2 a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> V2 a -> u
gmapQ :: (forall d. Data d => d -> u) -> V2 a -> [u]
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> V2 a -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V2 a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V2 a -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V2 a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V2 a -> r
gmapT :: (forall b. Data b => b -> b) -> V2 a -> V2 a
$cgmapT :: forall a. Data a => (forall b. Data b => b -> b) -> V2 a -> V2 a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V2 a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V2 a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (V2 a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (V2 a))
dataTypeOf :: V2 a -> DataType
$cdataTypeOf :: forall a. Data a => V2 a -> DataType
toConstr :: V2 a -> Constr
$ctoConstr :: forall a. Data a => V2 a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (V2 a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (V2 a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> V2 a -> c (V2 a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> V2 a -> c (V2 a)
$cp1Data :: forall a. Data a => Typeable (V2 a)
Data, Typeable, (forall x. V2 a -> Rep (V2 a) x)
-> (forall x. Rep (V2 a) x -> V2 a) -> Generic (V2 a)
forall x. Rep (V2 a) x -> V2 a
forall x. V2 a -> Rep (V2 a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (V2 a) x -> V2 a
forall a x. V2 a -> Rep (V2 a) x
$cto :: forall a x. Rep (V2 a) x -> V2 a
$cfrom :: forall a x. V2 a -> Rep (V2 a) x
Generic, (forall a. V2 a -> Rep1 V2 a)
-> (forall a. Rep1 V2 a -> V2 a) -> Generic1 V2
forall a. Rep1 V2 a -> V2 a
forall a. V2 a -> Rep1 V2 a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cto1 :: forall a. Rep1 V2 a -> V2 a
$cfrom1 :: forall a. V2 a -> Rep1 V2 a
Generic1)
instance Functor V2 where
fmap :: (a -> b) -> V2 a -> V2 b
fmap f :: a -> b
f (V2 a :: a
a b :: a
b) = b -> b -> V2 b
forall a. a -> a -> V2 a
V2 (a -> b
f a
a) (a -> b
f a
b)
{-# INLINE fmap #-}
a :: a
a <$ :: a -> V2 b -> V2 a
<$ _ = a -> a -> V2 a
forall a. a -> a -> V2 a
V2 a
a a
a
{-# INLINE (<$) #-}
instance Foldable V2 where
foldMap :: (a -> m) -> V2 a -> m
foldMap f :: a -> m
f (V2 a :: a
a b :: a
b) = a -> m
f a
a m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a -> m
f a
b
{-# INLINE foldMap #-}
instance Traversable V2 where
traverse :: (a -> f b) -> V2 a -> f (V2 b)
traverse f :: a -> f b
f (V2 a :: a
a b :: a
b) = b -> b -> V2 b
forall a. a -> a -> V2 a
V2 (b -> b -> V2 b) -> f b -> f (b -> V2 b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a f (b -> V2 b) -> f b -> f (V2 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
b
{-# INLINE traverse #-}
instance Applicative V2 where
pure :: a -> V2 a
pure a :: a
a = a -> a -> V2 a
forall a. a -> a -> V2 a
V2 a
a a
a
{-# INLINE pure #-}
V2 a :: a -> b
a b :: a -> b
b <*> :: V2 (a -> b) -> V2 a -> V2 b
<*> V2 d :: a
d e :: a
e = b -> b -> V2 b
forall a. a -> a -> V2 a
V2 (a -> b
a a
d) (a -> b
b a
e)
{-# INLINE (<*>) #-}
instance Monad V2 where
return :: a -> V2 a
return a :: a
a = a -> a -> V2 a
forall a. a -> a -> V2 a
V2 a
a a
a
{-# INLINE return #-}
V2 a :: a
a b :: a
b >>= :: V2 a -> (a -> V2 b) -> V2 b
>>= f :: a -> V2 b
f = b -> b -> V2 b
forall a. a -> a -> V2 a
V2 b
a' b
b' where
V2 a' :: b
a' _ = a -> V2 b
f a
a
V2 _ b' :: b
b' = a -> V2 b
f a
b
{-# INLINE (>>=) #-}
instance Num a => Num (V2 a) where
+ :: V2 a -> V2 a -> V2 a
(+) = (a -> a -> a) -> V2 a -> V2 a -> V2 a
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Num a => a -> a -> a
(+)
{-# INLINE (+) #-}
(-) = (a -> a -> a) -> V2 a -> V2 a -> V2 a
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (-)
{-# INLINE (-) #-}
* :: V2 a -> V2 a -> V2 a
(*) = (a -> a -> a) -> V2 a -> V2 a -> V2 a
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Num a => a -> a -> a
(*)
{-# INLINE (*) #-}
negate :: V2 a -> V2 a
negate = (a -> a) -> V2 a -> V2 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Num a => a -> a
negate
{-# INLINE negate #-}
abs :: V2 a -> V2 a
abs = (a -> a) -> V2 a -> V2 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Num a => a -> a
abs
{-# INLINE abs #-}
signum :: V2 a -> V2 a
signum = (a -> a) -> V2 a -> V2 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Num a => a -> a
signum
{-# INLINE signum #-}
fromInteger :: Integer -> V2 a
fromInteger = a -> V2 a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> V2 a) -> (Integer -> a) -> Integer -> V2 a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> a
forall a. Num a => Integer -> a
fromInteger
{-# INLINE fromInteger #-}
instance Fractional a => Fractional (V2 a) where
recip :: V2 a -> V2 a
recip = (a -> a) -> V2 a -> V2 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Fractional a => a -> a
recip
{-# INLINE recip #-}
/ :: V2 a -> V2 a -> V2 a
(/) = (a -> a -> a) -> V2 a -> V2 a -> V2 a
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Fractional a => a -> a -> a
(/)
{-# INLINE (/) #-}
fromRational :: Rational -> V2 a
fromRational = a -> V2 a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> V2 a) -> (Rational -> a) -> Rational -> V2 a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> a
forall a. Fractional a => Rational -> a
fromRational
{-# INLINE fromRational #-}
instance Floating a => Floating (V2 a) where
pi :: V2 a
pi = a -> V2 a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Floating a => a
pi
{-# INLINE pi #-}
exp :: V2 a -> V2 a
exp = (a -> a) -> V2 a -> V2 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
exp
{-# INLINE exp #-}
sqrt :: V2 a -> V2 a
sqrt = (a -> a) -> V2 a -> V2 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
sqrt
{-# INLINE sqrt #-}
log :: V2 a -> V2 a
log = (a -> a) -> V2 a -> V2 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
log
{-# INLINE log #-}
** :: V2 a -> V2 a -> V2 a
(**) = (a -> a -> a) -> V2 a -> V2 a -> V2 a
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Floating a => a -> a -> a
(**)
{-# INLINE (**) #-}
logBase :: V2 a -> V2 a -> V2 a
logBase = (a -> a -> a) -> V2 a -> V2 a -> V2 a
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Floating a => a -> a -> a
logBase
{-# INLINE logBase #-}
sin :: V2 a -> V2 a
sin = (a -> a) -> V2 a -> V2 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
sin
{-# INLINE sin #-}
tan :: V2 a -> V2 a
tan = (a -> a) -> V2 a -> V2 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
tan
{-# INLINE tan #-}
cos :: V2 a -> V2 a
cos = (a -> a) -> V2 a -> V2 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
cos
{-# INLINE cos #-}
asin :: V2 a -> V2 a
asin = (a -> a) -> V2 a -> V2 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
asin
{-# INLINE asin #-}
atan :: V2 a -> V2 a
atan = (a -> a) -> V2 a -> V2 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
atan
{-# INLINE atan #-}
acos :: V2 a -> V2 a
acos = (a -> a) -> V2 a -> V2 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
acos
{-# INLINE acos #-}
sinh :: V2 a -> V2 a
sinh = (a -> a) -> V2 a -> V2 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
sinh
{-# INLINE sinh #-}
tanh :: V2 a -> V2 a
tanh = (a -> a) -> V2 a -> V2 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
tanh
{-# INLINE tanh #-}
cosh :: V2 a -> V2 a
cosh = (a -> a) -> V2 a -> V2 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
cosh
{-# INLINE cosh #-}
asinh :: V2 a -> V2 a
asinh = (a -> a) -> V2 a -> V2 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
asinh
{-# INLINE asinh #-}
atanh :: V2 a -> V2 a
atanh = (a -> a) -> V2 a -> V2 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
atanh
{-# INLINE atanh #-}
acosh :: V2 a -> V2 a
acosh = (a -> a) -> V2 a -> V2 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
acosh
{-# INLINE acosh #-}
instance Storable a => Storable (V2 a) where
sizeOf :: V2 a -> Int
sizeOf _ = 2 Int -> Int -> Int
forall a. Num a => a -> a -> a
* a -> Int
forall a. Storable a => a -> Int
sizeOf (a
forall a. HasCallStack => a
undefined::a)
{-# INLINE sizeOf #-}
alignment :: V2 a -> Int
alignment _ = a -> Int
forall a. Storable a => a -> Int
alignment (a
forall a. HasCallStack => a
undefined::a)
{-# INLINE alignment #-}
poke :: Ptr (V2 a) -> V2 a -> IO ()
poke ptr :: Ptr (V2 a)
ptr (V2 x :: a
x y :: a
y) = Ptr a -> a -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr a
ptr' a
x IO () -> IO () -> IO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr a -> Int -> a -> IO ()
forall a. Storable a => Ptr a -> Int -> a -> IO ()
pokeElemOff Ptr a
ptr' 1 a
y
where ptr' :: Ptr a
ptr' = Ptr (V2 a) -> Ptr a
forall a b. Ptr a -> Ptr b
castPtr Ptr (V2 a)
ptr
{-# INLINE poke #-}
peek :: Ptr (V2 a) -> IO (V2 a)
peek ptr :: Ptr (V2 a)
ptr = a -> a -> V2 a
forall a. a -> a -> V2 a
V2 (a -> a -> V2 a) -> IO a -> IO (a -> V2 a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr a -> IO a
forall a. Storable a => Ptr a -> IO a
peek Ptr a
ptr' IO (a -> V2 a) -> IO a -> IO (V2 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr a -> Int -> IO a
forall a. Storable a => Ptr a -> Int -> IO a
peekElemOff Ptr a
ptr' 1
where ptr' :: Ptr a
ptr' = Ptr (V2 a) -> Ptr a
forall a b. Ptr a -> Ptr b
castPtr Ptr (V2 a)
ptr
{-# INLINE peek #-}
instance Ix a => Ix (V2 a) where
{-# SPECIALISE instance Ix (V2 Int) #-}
range :: (V2 a, V2 a) -> [V2 a]
range (V2 l1 :: a
l1 l2 :: a
l2,V2 u1 :: a
u1 u2 :: a
u2) =
[ a -> a -> V2 a
forall a. a -> a -> V2 a
V2 a
i1 a
i2 | a
i1 <- (a, a) -> [a]
forall a. Ix a => (a, a) -> [a]
range (a
l1,a
u1), a
i2 <- (a, a) -> [a]
forall a. Ix a => (a, a) -> [a]
range (a
l2,a
u2) ]
{-# INLINE range #-}
unsafeIndex :: (V2 a, V2 a) -> V2 a -> Int
unsafeIndex (V2 l1 :: a
l1 l2 :: a
l2,V2 u1 :: a
u1 u2 :: a
u2) (V2 i1 :: a
i1 i2 :: a
i2) =
(a, a) -> a -> Int
forall a. Ix a => (a, a) -> a -> Int
unsafeIndex (a
l1,a
u1) a
i1 Int -> Int -> Int
forall a. Num a => a -> a -> a
* (a, a) -> Int
forall a. Ix a => (a, a) -> Int
unsafeRangeSize (a
l2,a
u2) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ (a, a) -> a -> Int
forall a. Ix a => (a, a) -> a -> Int
unsafeIndex (a
l2,a
u2) a
i2
{-# INLINE unsafeIndex #-}
inRange :: (V2 a, V2 a) -> V2 a -> Bool
inRange (V2 l1 :: a
l1 l2 :: a
l2,V2 u1 :: a
u1 u2 :: a
u2) (V2 i1 :: a
i1 i2 :: a
i2) =
(a, a) -> a -> Bool
forall a. Ix a => (a, a) -> a -> Bool
inRange (a
l1,a
u1) a
i1 Bool -> Bool -> Bool
&& (a, a) -> a -> Bool
forall a. Ix a => (a, a) -> a -> Bool
inRange (a
l2,a
u2) a
i2
{-# INLINE inRange #-}
data instance U.Vector (V2 a) = V_V2 {-# UNPACK #-} !Int !(U.Vector a)
data instance U.MVector s (V2 a) = MV_V2 {-# UNPACK #-} !Int !(U.MVector s a)
instance U.Unbox a => U.Unbox (V2 a)
instance U.Unbox a => M.MVector U.MVector (V2 a) where
{-# INLINE basicLength #-}
{-# INLINE basicUnsafeSlice #-}
{-# INLINE basicOverlaps #-}
{-# INLINE basicUnsafeNew #-}
{-# INLINE basicUnsafeRead #-}
{-# INLINE basicUnsafeWrite #-}
basicLength :: MVector s (V2 a) -> Int
basicLength (MV_V2 n _) = Int
n
basicUnsafeSlice :: Int -> Int -> MVector s (V2 a) -> MVector s (V2 a)
basicUnsafeSlice m :: Int
m n :: Int
n (MV_V2 _ v) = Int -> MVector s a -> MVector s (V2 a)
forall s a. Int -> MVector s a -> MVector s (V2 a)
MV_V2 Int
n (Int -> Int -> MVector s a -> MVector s a
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
M.basicUnsafeSlice (2Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
m) (2Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
n) MVector s a
v)
basicOverlaps :: MVector s (V2 a) -> MVector s (V2 a) -> Bool
basicOverlaps (MV_V2 _ v) (MV_V2 _ u) = MVector s a -> MVector s a -> Bool
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> Bool
M.basicOverlaps MVector s a
v MVector s a
u
basicUnsafeNew :: Int -> m (MVector (PrimState m) (V2 a))
basicUnsafeNew n :: Int
n = (MVector (PrimState m) a -> MVector (PrimState m) (V2 a))
-> m (MVector (PrimState m) a) -> m (MVector (PrimState m) (V2 a))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (Int -> MVector (PrimState m) a -> MVector (PrimState m) (V2 a)
forall s a. Int -> MVector s a -> MVector s (V2 a)
MV_V2 Int
n) (Int -> m (MVector (PrimState m) a)
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
Int -> m (v (PrimState m) a)
M.basicUnsafeNew (2Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
n))
basicUnsafeRead :: MVector (PrimState m) (V2 a) -> Int -> m (V2 a)
basicUnsafeRead (MV_V2 _ v) i :: Int
i =
do let o :: Int
o = 2Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
i
a
x <- MVector (PrimState m) a -> Int -> m a
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> m a
M.basicUnsafeRead MVector (PrimState m) a
v Int
o
a
y <- MVector (PrimState m) a -> Int -> m a
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> m a
M.basicUnsafeRead MVector (PrimState m) a
v (Int
oInt -> Int -> Int
forall a. Num a => a -> a -> a
+1)
V2 a -> m (V2 a)
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> a -> V2 a
forall a. a -> a -> V2 a
V2 a
x a
y)
basicUnsafeWrite :: MVector (PrimState m) (V2 a) -> Int -> V2 a -> m ()
basicUnsafeWrite (MV_V2 _ v) i :: Int
i (V2 x :: a
x y :: a
y) =
do let o :: Int
o = 2Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
i
MVector (PrimState m) a -> Int -> a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> a -> m ()
M.basicUnsafeWrite MVector (PrimState m) a
v Int
o a
x
MVector (PrimState m) a -> Int -> a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> a -> m ()
M.basicUnsafeWrite MVector (PrimState m) a
v (Int
oInt -> Int -> Int
forall a. Num a => a -> a -> a
+1) a
y
#if MIN_VERSION_vector(0,11,0)
basicInitialize :: MVector (PrimState m) (V2 a) -> m ()
basicInitialize (MV_V2 _ v) = MVector (PrimState m) a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> m ()
M.basicInitialize MVector (PrimState m) a
v
{-# INLINE basicInitialize #-}
#endif
instance U.Unbox a => G.Vector U.Vector (V2 a) where
{-# INLINE basicUnsafeFreeze #-}
{-# INLINE basicUnsafeThaw #-}
{-# INLINE basicLength #-}
{-# INLINE basicUnsafeSlice #-}
{-# INLINE basicUnsafeIndexM #-}
basicUnsafeFreeze :: Mutable Vector (PrimState m) (V2 a) -> m (Vector (V2 a))
basicUnsafeFreeze (MV_V2 n v) = (Vector a -> Vector (V2 a)) -> m (Vector a) -> m (Vector (V2 a))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM ( Int -> Vector a -> Vector (V2 a)
forall a. Int -> Vector a -> Vector (V2 a)
V_V2 Int
n) (Mutable Vector (PrimState m) a -> m (Vector a)
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
Mutable v (PrimState m) a -> m (v a)
G.basicUnsafeFreeze MVector (PrimState m) a
Mutable Vector (PrimState m) a
v)
basicUnsafeThaw :: Vector (V2 a) -> m (Mutable Vector (PrimState m) (V2 a))
basicUnsafeThaw ( V_V2 n v) = (MVector (PrimState m) a -> MVector (PrimState m) (V2 a))
-> m (MVector (PrimState m) a) -> m (MVector (PrimState m) (V2 a))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (Int -> MVector (PrimState m) a -> MVector (PrimState m) (V2 a)
forall s a. Int -> MVector s a -> MVector s (V2 a)
MV_V2 Int
n) (Vector a -> m (Mutable Vector (PrimState m) a)
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
v a -> m (Mutable v (PrimState m) a)
G.basicUnsafeThaw Vector a
v)
basicLength :: Vector (V2 a) -> Int
basicLength ( V_V2 n _) = Int
n
basicUnsafeSlice :: Int -> Int -> Vector (V2 a) -> Vector (V2 a)
basicUnsafeSlice m :: Int
m n :: Int
n (V_V2 _ v) = Int -> Vector a -> Vector (V2 a)
forall a. Int -> Vector a -> Vector (V2 a)
V_V2 Int
n (Int -> Int -> Vector a -> Vector a
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
G.basicUnsafeSlice (2Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
m) (2Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
n) Vector a
v)
basicUnsafeIndexM :: Vector (V2 a) -> Int -> m (V2 a)
basicUnsafeIndexM (V_V2 _ v) i :: Int
i =
do let o :: Int
o = 2Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
i
a
x <- Vector a -> Int -> m a
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
G.basicUnsafeIndexM Vector a
v Int
o
a
y <- Vector a -> Int -> m a
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
G.basicUnsafeIndexM Vector a
v (Int
oInt -> Int -> Int
forall a. Num a => a -> a -> a
+1)
V2 a -> m (V2 a)
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> a -> V2 a
forall a. a -> a -> V2 a
V2 a
x a
y)
instance MonadZip V2 where
mzipWith :: (a -> b -> c) -> V2 a -> V2 b -> V2 c
mzipWith = (a -> b -> c) -> V2 a -> V2 b -> V2 c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2
instance MonadFix V2 where
mfix :: (a -> V2 a) -> V2 a
mfix f :: a -> V2 a
f = a -> a -> V2 a
forall a. a -> a -> V2 a
V2 (let V2 a :: a
a _ = a -> V2 a
f a
a in a
a)
(let V2 _ a :: a
a = a -> V2 a
f a
a in a
a)
instance Bounded a => Bounded (V2 a) where
minBound :: V2 a
minBound = a -> V2 a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Bounded a => a
minBound
{-# INLINE minBound #-}
maxBound :: V2 a
maxBound = a -> V2 a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Bounded a => a
maxBound
{-# INLINE maxBound #-}
data V3 a = V3 !a !a !a
deriving (V3 a -> V3 a -> Bool
(V3 a -> V3 a -> Bool) -> (V3 a -> V3 a -> Bool) -> Eq (V3 a)
forall a. Eq a => V3 a -> V3 a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: V3 a -> V3 a -> Bool
$c/= :: forall a. Eq a => V3 a -> V3 a -> Bool
== :: V3 a -> V3 a -> Bool
$c== :: forall a. Eq a => V3 a -> V3 a -> Bool
Eq, Eq (V3 a)
Eq (V3 a) =>
(V3 a -> V3 a -> Ordering)
-> (V3 a -> V3 a -> Bool)
-> (V3 a -> V3 a -> Bool)
-> (V3 a -> V3 a -> Bool)
-> (V3 a -> V3 a -> Bool)
-> (V3 a -> V3 a -> V3 a)
-> (V3 a -> V3 a -> V3 a)
-> Ord (V3 a)
V3 a -> V3 a -> Bool
V3 a -> V3 a -> Ordering
V3 a -> V3 a -> V3 a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (V3 a)
forall a. Ord a => V3 a -> V3 a -> Bool
forall a. Ord a => V3 a -> V3 a -> Ordering
forall a. Ord a => V3 a -> V3 a -> V3 a
min :: V3 a -> V3 a -> V3 a
$cmin :: forall a. Ord a => V3 a -> V3 a -> V3 a
max :: V3 a -> V3 a -> V3 a
$cmax :: forall a. Ord a => V3 a -> V3 a -> V3 a
>= :: V3 a -> V3 a -> Bool
$c>= :: forall a. Ord a => V3 a -> V3 a -> Bool
> :: V3 a -> V3 a -> Bool
$c> :: forall a. Ord a => V3 a -> V3 a -> Bool
<= :: V3 a -> V3 a -> Bool
$c<= :: forall a. Ord a => V3 a -> V3 a -> Bool
< :: V3 a -> V3 a -> Bool
$c< :: forall a. Ord a => V3 a -> V3 a -> Bool
compare :: V3 a -> V3 a -> Ordering
$ccompare :: forall a. Ord a => V3 a -> V3 a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (V3 a)
Ord, Int -> V3 a -> ShowS
[V3 a] -> ShowS
V3 a -> String
(Int -> V3 a -> ShowS)
-> (V3 a -> String) -> ([V3 a] -> ShowS) -> Show (V3 a)
forall a. Show a => Int -> V3 a -> ShowS
forall a. Show a => [V3 a] -> ShowS
forall a. Show a => V3 a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [V3 a] -> ShowS
$cshowList :: forall a. Show a => [V3 a] -> ShowS
show :: V3 a -> String
$cshow :: forall a. Show a => V3 a -> String
showsPrec :: Int -> V3 a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> V3 a -> ShowS
Show, ReadPrec [V3 a]
ReadPrec (V3 a)
Int -> ReadS (V3 a)
ReadS [V3 a]
(Int -> ReadS (V3 a))
-> ReadS [V3 a]
-> ReadPrec (V3 a)
-> ReadPrec [V3 a]
-> Read (V3 a)
forall a. Read a => ReadPrec [V3 a]
forall a. Read a => ReadPrec (V3 a)
forall a. Read a => Int -> ReadS (V3 a)
forall a. Read a => ReadS [V3 a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [V3 a]
$creadListPrec :: forall a. Read a => ReadPrec [V3 a]
readPrec :: ReadPrec (V3 a)
$creadPrec :: forall a. Read a => ReadPrec (V3 a)
readList :: ReadS [V3 a]
$creadList :: forall a. Read a => ReadS [V3 a]
readsPrec :: Int -> ReadS (V3 a)
$creadsPrec :: forall a. Read a => Int -> ReadS (V3 a)
Read, Typeable (V3 a)
DataType
Constr
Typeable (V3 a) =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> V3 a -> c (V3 a))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (V3 a))
-> (V3 a -> Constr)
-> (V3 a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (V3 a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V3 a)))
-> ((forall b. Data b => b -> b) -> V3 a -> V3 a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V3 a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V3 a -> r)
-> (forall u. (forall d. Data d => d -> u) -> V3 a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> V3 a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> V3 a -> m (V3 a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> V3 a -> m (V3 a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> V3 a -> m (V3 a))
-> Data (V3 a)
V3 a -> DataType
V3 a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (V3 a))
(forall b. Data b => b -> b) -> V3 a -> V3 a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> V3 a -> c (V3 a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (V3 a)
forall a. Data a => Typeable (V3 a)
forall a. Data a => V3 a -> DataType
forall a. Data a => V3 a -> Constr
forall a. Data a => (forall b. Data b => b -> b) -> V3 a -> V3 a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> V3 a -> u
forall a u. Data a => (forall d. Data d => d -> u) -> V3 a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V3 a -> r
forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V3 a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> V3 a -> m (V3 a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> V3 a -> m (V3 a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (V3 a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> V3 a -> c (V3 a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (V3 a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V3 a))
forall a.
Typeable a =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> V3 a -> u
forall u. (forall d. Data d => d -> u) -> V3 a -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V3 a -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V3 a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> V3 a -> m (V3 a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> V3 a -> m (V3 a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (V3 a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> V3 a -> c (V3 a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (V3 a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V3 a))
$cV3 :: Constr
$tV3 :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> V3 a -> m (V3 a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> V3 a -> m (V3 a)
gmapMp :: (forall d. Data d => d -> m d) -> V3 a -> m (V3 a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> V3 a -> m (V3 a)
gmapM :: (forall d. Data d => d -> m d) -> V3 a -> m (V3 a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> V3 a -> m (V3 a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> V3 a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> V3 a -> u
gmapQ :: (forall d. Data d => d -> u) -> V3 a -> [u]
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> V3 a -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V3 a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V3 a -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V3 a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V3 a -> r
gmapT :: (forall b. Data b => b -> b) -> V3 a -> V3 a
$cgmapT :: forall a. Data a => (forall b. Data b => b -> b) -> V3 a -> V3 a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V3 a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V3 a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (V3 a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (V3 a))
dataTypeOf :: V3 a -> DataType
$cdataTypeOf :: forall a. Data a => V3 a -> DataType
toConstr :: V3 a -> Constr
$ctoConstr :: forall a. Data a => V3 a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (V3 a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (V3 a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> V3 a -> c (V3 a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> V3 a -> c (V3 a)
$cp1Data :: forall a. Data a => Typeable (V3 a)
Data, Typeable, (forall x. V3 a -> Rep (V3 a) x)
-> (forall x. Rep (V3 a) x -> V3 a) -> Generic (V3 a)
forall x. Rep (V3 a) x -> V3 a
forall x. V3 a -> Rep (V3 a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (V3 a) x -> V3 a
forall a x. V3 a -> Rep (V3 a) x
$cto :: forall a x. Rep (V3 a) x -> V3 a
$cfrom :: forall a x. V3 a -> Rep (V3 a) x
Generic, (forall a. V3 a -> Rep1 V3 a)
-> (forall a. Rep1 V3 a -> V3 a) -> Generic1 V3
forall a. Rep1 V3 a -> V3 a
forall a. V3 a -> Rep1 V3 a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cto1 :: forall a. Rep1 V3 a -> V3 a
$cfrom1 :: forall a. V3 a -> Rep1 V3 a
Generic1)
instance Functor V3 where
fmap :: (a -> b) -> V3 a -> V3 b
fmap f :: a -> b
f (V3 a :: a
a b :: a
b c :: a
c) = b -> b -> b -> V3 b
forall a. a -> a -> a -> V3 a
V3 (a -> b
f a
a) (a -> b
f a
b) (a -> b
f a
c)
{-# INLINE fmap #-}
a :: a
a <$ :: a -> V3 b -> V3 a
<$ _ = a -> a -> a -> V3 a
forall a. a -> a -> a -> V3 a
V3 a
a a
a a
a
{-# INLINE (<$) #-}
instance Foldable V3 where
foldMap :: (a -> m) -> V3 a -> m
foldMap f :: a -> m
f (V3 a :: a
a b :: a
b c :: a
c) = a -> m
f a
a m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a -> m
f a
b m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a -> m
f a
c
{-# INLINE foldMap #-}
instance Traversable V3 where
traverse :: (a -> f b) -> V3 a -> f (V3 b)
traverse f :: a -> f b
f (V3 a :: a
a b :: a
b c :: a
c) = b -> b -> b -> V3 b
forall a. a -> a -> a -> V3 a
V3 (b -> b -> b -> V3 b) -> f b -> f (b -> b -> V3 b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a f (b -> b -> V3 b) -> f b -> f (b -> V3 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
b f (b -> V3 b) -> f b -> f (V3 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
c
{-# INLINE traverse #-}
instance Applicative V3 where
pure :: a -> V3 a
pure a :: a
a = a -> a -> a -> V3 a
forall a. a -> a -> a -> V3 a
V3 a
a a
a a
a
{-# INLINE pure #-}
V3 a :: a -> b
a b :: a -> b
b c :: a -> b
c <*> :: V3 (a -> b) -> V3 a -> V3 b
<*> V3 d :: a
d e :: a
e f :: a
f = b -> b -> b -> V3 b
forall a. a -> a -> a -> V3 a
V3 (a -> b
a a
d) (a -> b
b a
e) (a -> b
c a
f)
{-# INLINE (<*>) #-}
instance Monad V3 where
return :: a -> V3 a
return a :: a
a = a -> a -> a -> V3 a
forall a. a -> a -> a -> V3 a
V3 a
a a
a a
a
{-# INLINE return #-}
V3 a :: a
a b :: a
b c :: a
c >>= :: V3 a -> (a -> V3 b) -> V3 b
>>= f :: a -> V3 b
f = b -> b -> b -> V3 b
forall a. a -> a -> a -> V3 a
V3 b
a' b
b' b
c' where
V3 a' :: b
a' _ _ = a -> V3 b
f a
a
V3 _ b' :: b
b' _ = a -> V3 b
f a
b
V3 _ _ c' :: b
c' = a -> V3 b
f a
c
{-# INLINE (>>=) #-}
instance Num a => Num (V3 a) where
+ :: V3 a -> V3 a -> V3 a
(+) = (a -> a -> a) -> V3 a -> V3 a -> V3 a
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Num a => a -> a -> a
(+)
{-# INLINE (+) #-}
(-) = (a -> a -> a) -> V3 a -> V3 a -> V3 a
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (-)
{-# INLINE (-) #-}
* :: V3 a -> V3 a -> V3 a
(*) = (a -> a -> a) -> V3 a -> V3 a -> V3 a
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Num a => a -> a -> a
(*)
{-# INLINE (*) #-}
negate :: V3 a -> V3 a
negate = (a -> a) -> V3 a -> V3 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Num a => a -> a
negate
{-# INLINE negate #-}
abs :: V3 a -> V3 a
abs = (a -> a) -> V3 a -> V3 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Num a => a -> a
abs
{-# INLINE abs #-}
signum :: V3 a -> V3 a
signum = (a -> a) -> V3 a -> V3 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Num a => a -> a
signum
{-# INLINE signum #-}
fromInteger :: Integer -> V3 a
fromInteger = a -> V3 a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> V3 a) -> (Integer -> a) -> Integer -> V3 a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> a
forall a. Num a => Integer -> a
fromInteger
{-# INLINE fromInteger #-}
instance Fractional a => Fractional (V3 a) where
recip :: V3 a -> V3 a
recip = (a -> a) -> V3 a -> V3 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Fractional a => a -> a
recip
{-# INLINE recip #-}
/ :: V3 a -> V3 a -> V3 a
(/) = (a -> a -> a) -> V3 a -> V3 a -> V3 a
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Fractional a => a -> a -> a
(/)
{-# INLINE (/) #-}
fromRational :: Rational -> V3 a
fromRational = a -> V3 a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> V3 a) -> (Rational -> a) -> Rational -> V3 a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> a
forall a. Fractional a => Rational -> a
fromRational
{-# INLINE fromRational #-}
instance Floating a => Floating (V3 a) where
pi :: V3 a
pi = a -> V3 a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Floating a => a
pi
{-# INLINE pi #-}
exp :: V3 a -> V3 a
exp = (a -> a) -> V3 a -> V3 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
exp
{-# INLINE exp #-}
sqrt :: V3 a -> V3 a
sqrt = (a -> a) -> V3 a -> V3 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
sqrt
{-# INLINE sqrt #-}
log :: V3 a -> V3 a
log = (a -> a) -> V3 a -> V3 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
log
{-# INLINE log #-}
** :: V3 a -> V3 a -> V3 a
(**) = (a -> a -> a) -> V3 a -> V3 a -> V3 a
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Floating a => a -> a -> a
(**)
{-# INLINE (**) #-}
logBase :: V3 a -> V3 a -> V3 a
logBase = (a -> a -> a) -> V3 a -> V3 a -> V3 a
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Floating a => a -> a -> a
logBase
{-# INLINE logBase #-}
sin :: V3 a -> V3 a
sin = (a -> a) -> V3 a -> V3 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
sin
{-# INLINE sin #-}
tan :: V3 a -> V3 a
tan = (a -> a) -> V3 a -> V3 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
tan
{-# INLINE tan #-}
cos :: V3 a -> V3 a
cos = (a -> a) -> V3 a -> V3 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
cos
{-# INLINE cos #-}
asin :: V3 a -> V3 a
asin = (a -> a) -> V3 a -> V3 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
asin
{-# INLINE asin #-}
atan :: V3 a -> V3 a
atan = (a -> a) -> V3 a -> V3 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
atan
{-# INLINE atan #-}
acos :: V3 a -> V3 a
acos = (a -> a) -> V3 a -> V3 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
acos
{-# INLINE acos #-}
sinh :: V3 a -> V3 a
sinh = (a -> a) -> V3 a -> V3 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
sinh
{-# INLINE sinh #-}
tanh :: V3 a -> V3 a
tanh = (a -> a) -> V3 a -> V3 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
tanh
{-# INLINE tanh #-}
cosh :: V3 a -> V3 a
cosh = (a -> a) -> V3 a -> V3 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
cosh
{-# INLINE cosh #-}
asinh :: V3 a -> V3 a
asinh = (a -> a) -> V3 a -> V3 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
asinh
{-# INLINE asinh #-}
atanh :: V3 a -> V3 a
atanh = (a -> a) -> V3 a -> V3 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
atanh
{-# INLINE atanh #-}
acosh :: V3 a -> V3 a
acosh = (a -> a) -> V3 a -> V3 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
acosh
{-# INLINE acosh #-}
instance Storable a => Storable (V3 a) where
sizeOf :: V3 a -> Int
sizeOf _ = 3 Int -> Int -> Int
forall a. Num a => a -> a -> a
* a -> Int
forall a. Storable a => a -> Int
sizeOf (a
forall a. HasCallStack => a
undefined::a)
{-# INLINE sizeOf #-}
alignment :: V3 a -> Int
alignment _ = a -> Int
forall a. Storable a => a -> Int
alignment (a
forall a. HasCallStack => a
undefined::a)
{-# INLINE alignment #-}
poke :: Ptr (V3 a) -> V3 a -> IO ()
poke ptr :: Ptr (V3 a)
ptr (V3 x :: a
x y :: a
y z :: a
z) = do Ptr a -> a -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr a
ptr' a
x
Ptr a -> Int -> a -> IO ()
forall a. Storable a => Ptr a -> Int -> a -> IO ()
pokeElemOff Ptr a
ptr' 1 a
y
Ptr a -> Int -> a -> IO ()
forall a. Storable a => Ptr a -> Int -> a -> IO ()
pokeElemOff Ptr a
ptr' 2 a
z
where ptr' :: Ptr a
ptr' = Ptr (V3 a) -> Ptr a
forall a b. Ptr a -> Ptr b
castPtr Ptr (V3 a)
ptr
{-# INLINE poke #-}
peek :: Ptr (V3 a) -> IO (V3 a)
peek ptr :: Ptr (V3 a)
ptr = a -> a -> a -> V3 a
forall a. a -> a -> a -> V3 a
V3 (a -> a -> a -> V3 a) -> IO a -> IO (a -> a -> V3 a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr a -> IO a
forall a. Storable a => Ptr a -> IO a
peek Ptr a
ptr' IO (a -> a -> V3 a) -> IO a -> IO (a -> V3 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr a -> Int -> IO a
forall a. Storable a => Ptr a -> Int -> IO a
peekElemOff Ptr a
ptr' 1 IO (a -> V3 a) -> IO a -> IO (V3 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr a -> Int -> IO a
forall a. Storable a => Ptr a -> Int -> IO a
peekElemOff Ptr a
ptr' 2
where ptr' :: Ptr a
ptr' = Ptr (V3 a) -> Ptr a
forall a b. Ptr a -> Ptr b
castPtr Ptr (V3 a)
ptr
{-# INLINE peek #-}
instance Ix a => Ix (V3 a) where
{-# SPECIALISE instance Ix (V3 Int) #-}
range :: (V3 a, V3 a) -> [V3 a]
range (V3 l1 :: a
l1 l2 :: a
l2 l3 :: a
l3,V3 u1 :: a
u1 u2 :: a
u2 u3 :: a
u3) =
[a -> a -> a -> V3 a
forall a. a -> a -> a -> V3 a
V3 a
i1 a
i2 a
i3 | a
i1 <- (a, a) -> [a]
forall a. Ix a => (a, a) -> [a]
range (a
l1,a
u1)
, a
i2 <- (a, a) -> [a]
forall a. Ix a => (a, a) -> [a]
range (a
l2,a
u2)
, a
i3 <- (a, a) -> [a]
forall a. Ix a => (a, a) -> [a]
range (a
l3,a
u3)
]
{-# INLINE range #-}
unsafeIndex :: (V3 a, V3 a) -> V3 a -> Int
unsafeIndex (V3 l1 :: a
l1 l2 :: a
l2 l3 :: a
l3,V3 u1 :: a
u1 u2 :: a
u2 u3 :: a
u3) (V3 i1 :: a
i1 i2 :: a
i2 i3 :: a
i3) =
(a, a) -> a -> Int
forall a. Ix a => (a, a) -> a -> Int
unsafeIndex (a
l3,a
u3) a
i3 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ (a, a) -> Int
forall a. Ix a => (a, a) -> Int
unsafeRangeSize (a
l3,a
u3) Int -> Int -> Int
forall a. Num a => a -> a -> a
* (
(a, a) -> a -> Int
forall a. Ix a => (a, a) -> a -> Int
unsafeIndex (a
l2,a
u2) a
i2 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ (a, a) -> Int
forall a. Ix a => (a, a) -> Int
unsafeRangeSize (a
l2,a
u2) Int -> Int -> Int
forall a. Num a => a -> a -> a
*
(a, a) -> a -> Int
forall a. Ix a => (a, a) -> a -> Int
unsafeIndex (a
l1,a
u1) a
i1)
{-# INLINE unsafeIndex #-}
inRange :: (V3 a, V3 a) -> V3 a -> Bool
inRange (V3 l1 :: a
l1 l2 :: a
l2 l3 :: a
l3,V3 u1 :: a
u1 u2 :: a
u2 u3 :: a
u3) (V3 i1 :: a
i1 i2 :: a
i2 i3 :: a
i3) =
(a, a) -> a -> Bool
forall a. Ix a => (a, a) -> a -> Bool
inRange (a
l1,a
u1) a
i1 Bool -> Bool -> Bool
&& (a, a) -> a -> Bool
forall a. Ix a => (a, a) -> a -> Bool
inRange (a
l2,a
u2) a
i2 Bool -> Bool -> Bool
&&
(a, a) -> a -> Bool
forall a. Ix a => (a, a) -> a -> Bool
inRange (a
l3,a
u3) a
i3
{-# INLINE inRange #-}
data instance U.Vector (V3 a) = V_V3 {-# UNPACK #-} !Int !(U.Vector a)
data instance U.MVector s (V3 a) = MV_V3 {-# UNPACK #-} !Int !(U.MVector s a)
instance U.Unbox a => U.Unbox (V3 a)
instance U.Unbox a => M.MVector U.MVector (V3 a) where
{-# INLINE basicLength #-}
{-# INLINE basicUnsafeSlice #-}
{-# INLINE basicOverlaps #-}
{-# INLINE basicUnsafeNew #-}
{-# INLINE basicUnsafeRead #-}
{-# INLINE basicUnsafeWrite #-}
basicLength :: MVector s (V3 a) -> Int
basicLength (MV_V3 n _) = Int
n
basicUnsafeSlice :: Int -> Int -> MVector s (V3 a) -> MVector s (V3 a)
basicUnsafeSlice m :: Int
m n :: Int
n (MV_V3 _ v) = Int -> MVector s a -> MVector s (V3 a)
forall s a. Int -> MVector s a -> MVector s (V3 a)
MV_V3 Int
n (Int -> Int -> MVector s a -> MVector s a
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
M.basicUnsafeSlice (3Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
m) (3Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
n) MVector s a
v)
basicOverlaps :: MVector s (V3 a) -> MVector s (V3 a) -> Bool
basicOverlaps (MV_V3 _ v) (MV_V3 _ u) = MVector s a -> MVector s a -> Bool
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> Bool
M.basicOverlaps MVector s a
v MVector s a
u
basicUnsafeNew :: Int -> m (MVector (PrimState m) (V3 a))
basicUnsafeNew n :: Int
n = (MVector (PrimState m) a -> MVector (PrimState m) (V3 a))
-> m (MVector (PrimState m) a) -> m (MVector (PrimState m) (V3 a))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (Int -> MVector (PrimState m) a -> MVector (PrimState m) (V3 a)
forall s a. Int -> MVector s a -> MVector s (V3 a)
MV_V3 Int
n) (Int -> m (MVector (PrimState m) a)
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
Int -> m (v (PrimState m) a)
M.basicUnsafeNew (3Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
n))
basicUnsafeRead :: MVector (PrimState m) (V3 a) -> Int -> m (V3 a)
basicUnsafeRead (MV_V3 _ v) i :: Int
i =
do let o :: Int
o = 3Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
i
a
x <- MVector (PrimState m) a -> Int -> m a
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> m a
M.basicUnsafeRead MVector (PrimState m) a
v Int
o
a
y <- MVector (PrimState m) a -> Int -> m a
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> m a
M.basicUnsafeRead MVector (PrimState m) a
v (Int
oInt -> Int -> Int
forall a. Num a => a -> a -> a
+1)
a
z <- MVector (PrimState m) a -> Int -> m a
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> m a
M.basicUnsafeRead MVector (PrimState m) a
v (Int
oInt -> Int -> Int
forall a. Num a => a -> a -> a
+2)
V3 a -> m (V3 a)
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> a -> a -> V3 a
forall a. a -> a -> a -> V3 a
V3 a
x a
y a
z)
basicUnsafeWrite :: MVector (PrimState m) (V3 a) -> Int -> V3 a -> m ()
basicUnsafeWrite (MV_V3 _ v) i :: Int
i (V3 x :: a
x y :: a
y z :: a
z) =
do let o :: Int
o = 3Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
i
MVector (PrimState m) a -> Int -> a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> a -> m ()
M.basicUnsafeWrite MVector (PrimState m) a
v Int
o a
x
MVector (PrimState m) a -> Int -> a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> a -> m ()
M.basicUnsafeWrite MVector (PrimState m) a
v (Int
oInt -> Int -> Int
forall a. Num a => a -> a -> a
+1) a
y
MVector (PrimState m) a -> Int -> a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> a -> m ()
M.basicUnsafeWrite MVector (PrimState m) a
v (Int
oInt -> Int -> Int
forall a. Num a => a -> a -> a
+2) a
z
#if MIN_VERSION_vector(0,11,0)
basicInitialize :: MVector (PrimState m) (V3 a) -> m ()
basicInitialize (MV_V3 _ v) = MVector (PrimState m) a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> m ()
M.basicInitialize MVector (PrimState m) a
v
{-# INLINE basicInitialize #-}
#endif
instance U.Unbox a => G.Vector U.Vector (V3 a) where
{-# INLINE basicUnsafeFreeze #-}
{-# INLINE basicUnsafeThaw #-}
{-# INLINE basicLength #-}
{-# INLINE basicUnsafeSlice #-}
{-# INLINE basicUnsafeIndexM #-}
basicUnsafeFreeze :: Mutable Vector (PrimState m) (V3 a) -> m (Vector (V3 a))
basicUnsafeFreeze (MV_V3 n v) = (Vector a -> Vector (V3 a)) -> m (Vector a) -> m (Vector (V3 a))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM ( Int -> Vector a -> Vector (V3 a)
forall a. Int -> Vector a -> Vector (V3 a)
V_V3 Int
n) (Mutable Vector (PrimState m) a -> m (Vector a)
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
Mutable v (PrimState m) a -> m (v a)
G.basicUnsafeFreeze MVector (PrimState m) a
Mutable Vector (PrimState m) a
v)
basicUnsafeThaw :: Vector (V3 a) -> m (Mutable Vector (PrimState m) (V3 a))
basicUnsafeThaw ( V_V3 n v) = (MVector (PrimState m) a -> MVector (PrimState m) (V3 a))
-> m (MVector (PrimState m) a) -> m (MVector (PrimState m) (V3 a))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (Int -> MVector (PrimState m) a -> MVector (PrimState m) (V3 a)
forall s a. Int -> MVector s a -> MVector s (V3 a)
MV_V3 Int
n) (Vector a -> m (Mutable Vector (PrimState m) a)
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
v a -> m (Mutable v (PrimState m) a)
G.basicUnsafeThaw Vector a
v)
basicLength :: Vector (V3 a) -> Int
basicLength ( V_V3 n _) = Int
n
basicUnsafeSlice :: Int -> Int -> Vector (V3 a) -> Vector (V3 a)
basicUnsafeSlice m :: Int
m n :: Int
n (V_V3 _ v) = Int -> Vector a -> Vector (V3 a)
forall a. Int -> Vector a -> Vector (V3 a)
V_V3 Int
n (Int -> Int -> Vector a -> Vector a
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
G.basicUnsafeSlice (3Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
m) (3Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
n) Vector a
v)
basicUnsafeIndexM :: Vector (V3 a) -> Int -> m (V3 a)
basicUnsafeIndexM (V_V3 _ v) i :: Int
i =
do let o :: Int
o = 3Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
i
a
x <- Vector a -> Int -> m a
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
G.basicUnsafeIndexM Vector a
v Int
o
a
y <- Vector a -> Int -> m a
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
G.basicUnsafeIndexM Vector a
v (Int
oInt -> Int -> Int
forall a. Num a => a -> a -> a
+1)
a
z <- Vector a -> Int -> m a
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
G.basicUnsafeIndexM Vector a
v (Int
oInt -> Int -> Int
forall a. Num a => a -> a -> a
+2)
V3 a -> m (V3 a)
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> a -> a -> V3 a
forall a. a -> a -> a -> V3 a
V3 a
x a
y a
z)
instance MonadZip V3 where
mzipWith :: (a -> b -> c) -> V3 a -> V3 b -> V3 c
mzipWith = (a -> b -> c) -> V3 a -> V3 b -> V3 c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2
instance MonadFix V3 where
mfix :: (a -> V3 a) -> V3 a
mfix f :: a -> V3 a
f = a -> a -> a -> V3 a
forall a. a -> a -> a -> V3 a
V3 (let V3 a :: a
a _ _ = a -> V3 a
f a
a in a
a)
(let V3 _ a :: a
a _ = a -> V3 a
f a
a in a
a)
(let V3 _ _ a :: a
a = a -> V3 a
f a
a in a
a)
instance Bounded a => Bounded (V3 a) where
minBound :: V3 a
minBound = a -> V3 a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Bounded a => a
minBound
{-# INLINE minBound #-}
maxBound :: V3 a
maxBound = a -> V3 a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Bounded a => a
maxBound
{-# INLINE maxBound #-}
data V4 a = V4 !a !a !a !a
deriving (V4 a -> V4 a -> Bool
(V4 a -> V4 a -> Bool) -> (V4 a -> V4 a -> Bool) -> Eq (V4 a)
forall a. Eq a => V4 a -> V4 a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: V4 a -> V4 a -> Bool
$c/= :: forall a. Eq a => V4 a -> V4 a -> Bool
== :: V4 a -> V4 a -> Bool
$c== :: forall a. Eq a => V4 a -> V4 a -> Bool
Eq, Eq (V4 a)
Eq (V4 a) =>
(V4 a -> V4 a -> Ordering)
-> (V4 a -> V4 a -> Bool)
-> (V4 a -> V4 a -> Bool)
-> (V4 a -> V4 a -> Bool)
-> (V4 a -> V4 a -> Bool)
-> (V4 a -> V4 a -> V4 a)
-> (V4 a -> V4 a -> V4 a)
-> Ord (V4 a)
V4 a -> V4 a -> Bool
V4 a -> V4 a -> Ordering
V4 a -> V4 a -> V4 a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (V4 a)
forall a. Ord a => V4 a -> V4 a -> Bool
forall a. Ord a => V4 a -> V4 a -> Ordering
forall a. Ord a => V4 a -> V4 a -> V4 a
min :: V4 a -> V4 a -> V4 a
$cmin :: forall a. Ord a => V4 a -> V4 a -> V4 a
max :: V4 a -> V4 a -> V4 a
$cmax :: forall a. Ord a => V4 a -> V4 a -> V4 a
>= :: V4 a -> V4 a -> Bool
$c>= :: forall a. Ord a => V4 a -> V4 a -> Bool
> :: V4 a -> V4 a -> Bool
$c> :: forall a. Ord a => V4 a -> V4 a -> Bool
<= :: V4 a -> V4 a -> Bool
$c<= :: forall a. Ord a => V4 a -> V4 a -> Bool
< :: V4 a -> V4 a -> Bool
$c< :: forall a. Ord a => V4 a -> V4 a -> Bool
compare :: V4 a -> V4 a -> Ordering
$ccompare :: forall a. Ord a => V4 a -> V4 a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (V4 a)
Ord, Int -> V4 a -> ShowS
[V4 a] -> ShowS
V4 a -> String
(Int -> V4 a -> ShowS)
-> (V4 a -> String) -> ([V4 a] -> ShowS) -> Show (V4 a)
forall a. Show a => Int -> V4 a -> ShowS
forall a. Show a => [V4 a] -> ShowS
forall a. Show a => V4 a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [V4 a] -> ShowS
$cshowList :: forall a. Show a => [V4 a] -> ShowS
show :: V4 a -> String
$cshow :: forall a. Show a => V4 a -> String
showsPrec :: Int -> V4 a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> V4 a -> ShowS
Show, ReadPrec [V4 a]
ReadPrec (V4 a)
Int -> ReadS (V4 a)
ReadS [V4 a]
(Int -> ReadS (V4 a))
-> ReadS [V4 a]
-> ReadPrec (V4 a)
-> ReadPrec [V4 a]
-> Read (V4 a)
forall a. Read a => ReadPrec [V4 a]
forall a. Read a => ReadPrec (V4 a)
forall a. Read a => Int -> ReadS (V4 a)
forall a. Read a => ReadS [V4 a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [V4 a]
$creadListPrec :: forall a. Read a => ReadPrec [V4 a]
readPrec :: ReadPrec (V4 a)
$creadPrec :: forall a. Read a => ReadPrec (V4 a)
readList :: ReadS [V4 a]
$creadList :: forall a. Read a => ReadS [V4 a]
readsPrec :: Int -> ReadS (V4 a)
$creadsPrec :: forall a. Read a => Int -> ReadS (V4 a)
Read, Typeable (V4 a)
DataType
Constr
Typeable (V4 a) =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> V4 a -> c (V4 a))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (V4 a))
-> (V4 a -> Constr)
-> (V4 a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (V4 a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V4 a)))
-> ((forall b. Data b => b -> b) -> V4 a -> V4 a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V4 a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V4 a -> r)
-> (forall u. (forall d. Data d => d -> u) -> V4 a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> V4 a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> V4 a -> m (V4 a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> V4 a -> m (V4 a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> V4 a -> m (V4 a))
-> Data (V4 a)
V4 a -> DataType
V4 a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (V4 a))
(forall b. Data b => b -> b) -> V4 a -> V4 a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> V4 a -> c (V4 a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (V4 a)
forall a. Data a => Typeable (V4 a)
forall a. Data a => V4 a -> DataType
forall a. Data a => V4 a -> Constr
forall a. Data a => (forall b. Data b => b -> b) -> V4 a -> V4 a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> V4 a -> u
forall a u. Data a => (forall d. Data d => d -> u) -> V4 a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V4 a -> r
forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V4 a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> V4 a -> m (V4 a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> V4 a -> m (V4 a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (V4 a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> V4 a -> c (V4 a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (V4 a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V4 a))
forall a.
Typeable a =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> V4 a -> u
forall u. (forall d. Data d => d -> u) -> V4 a -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V4 a -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V4 a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> V4 a -> m (V4 a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> V4 a -> m (V4 a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (V4 a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> V4 a -> c (V4 a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (V4 a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V4 a))
$cV4 :: Constr
$tV4 :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> V4 a -> m (V4 a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> V4 a -> m (V4 a)
gmapMp :: (forall d. Data d => d -> m d) -> V4 a -> m (V4 a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> V4 a -> m (V4 a)
gmapM :: (forall d. Data d => d -> m d) -> V4 a -> m (V4 a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> V4 a -> m (V4 a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> V4 a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> V4 a -> u
gmapQ :: (forall d. Data d => d -> u) -> V4 a -> [u]
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> V4 a -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V4 a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V4 a -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V4 a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V4 a -> r
gmapT :: (forall b. Data b => b -> b) -> V4 a -> V4 a
$cgmapT :: forall a. Data a => (forall b. Data b => b -> b) -> V4 a -> V4 a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V4 a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V4 a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (V4 a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (V4 a))
dataTypeOf :: V4 a -> DataType
$cdataTypeOf :: forall a. Data a => V4 a -> DataType
toConstr :: V4 a -> Constr
$ctoConstr :: forall a. Data a => V4 a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (V4 a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (V4 a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> V4 a -> c (V4 a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> V4 a -> c (V4 a)
$cp1Data :: forall a. Data a => Typeable (V4 a)
Data, Typeable, (forall x. V4 a -> Rep (V4 a) x)
-> (forall x. Rep (V4 a) x -> V4 a) -> Generic (V4 a)
forall x. Rep (V4 a) x -> V4 a
forall x. V4 a -> Rep (V4 a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (V4 a) x -> V4 a
forall a x. V4 a -> Rep (V4 a) x
$cto :: forall a x. Rep (V4 a) x -> V4 a
$cfrom :: forall a x. V4 a -> Rep (V4 a) x
Generic, (forall a. V4 a -> Rep1 V4 a)
-> (forall a. Rep1 V4 a -> V4 a) -> Generic1 V4
forall a. Rep1 V4 a -> V4 a
forall a. V4 a -> Rep1 V4 a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cto1 :: forall a. Rep1 V4 a -> V4 a
$cfrom1 :: forall a. V4 a -> Rep1 V4 a
Generic1)
instance Functor V4 where
fmap :: (a -> b) -> V4 a -> V4 b
fmap f :: a -> b
f (V4 a :: a
a b :: a
b c :: a
c d :: a
d) = b -> b -> b -> b -> V4 b
forall a. a -> a -> a -> a -> V4 a
V4 (a -> b
f a
a) (a -> b
f a
b) (a -> b
f a
c) (a -> b
f a
d)
{-# INLINE fmap #-}
a :: a
a <$ :: a -> V4 b -> V4 a
<$ _ = a -> a -> a -> a -> V4 a
forall a. a -> a -> a -> a -> V4 a
V4 a
a a
a a
a a
a
{-# INLINE (<$) #-}
instance Foldable V4 where
foldMap :: (a -> m) -> V4 a -> m
foldMap f :: a -> m
f (V4 a :: a
a b :: a
b c :: a
c d :: a
d) = a -> m
f a
a m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a -> m
f a
b m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a -> m
f a
c m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a -> m
f a
d
{-# INLINE foldMap #-}
instance Traversable V4 where
traverse :: (a -> f b) -> V4 a -> f (V4 b)
traverse f :: a -> f b
f (V4 a :: a
a b :: a
b c :: a
c d :: a
d) = b -> b -> b -> b -> V4 b
forall a. a -> a -> a -> a -> V4 a
V4 (b -> b -> b -> b -> V4 b) -> f b -> f (b -> b -> b -> V4 b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a f (b -> b -> b -> V4 b) -> f b -> f (b -> b -> V4 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
b f (b -> b -> V4 b) -> f b -> f (b -> V4 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
c f (b -> V4 b) -> f b -> f (V4 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
d
{-# INLINE traverse #-}
instance Applicative V4 where
pure :: a -> V4 a
pure a :: a
a = a -> a -> a -> a -> V4 a
forall a. a -> a -> a -> a -> V4 a
V4 a
a a
a a
a a
a
{-# INLINE pure #-}
V4 a :: a -> b
a b :: a -> b
b c :: a -> b
c d :: a -> b
d <*> :: V4 (a -> b) -> V4 a -> V4 b
<*> V4 e :: a
e f :: a
f g :: a
g h :: a
h = b -> b -> b -> b -> V4 b
forall a. a -> a -> a -> a -> V4 a
V4 (a -> b
a a
e) (a -> b
b a
f) (a -> b
c a
g) (a -> b
d a
h)
{-# INLINE (<*>) #-}
instance Monad V4 where
return :: a -> V4 a
return a :: a
a = a -> a -> a -> a -> V4 a
forall a. a -> a -> a -> a -> V4 a
V4 a
a a
a a
a a
a
{-# INLINE return #-}
V4 a :: a
a b :: a
b c :: a
c d :: a
d >>= :: V4 a -> (a -> V4 b) -> V4 b
>>= f :: a -> V4 b
f = b -> b -> b -> b -> V4 b
forall a. a -> a -> a -> a -> V4 a
V4 b
a' b
b' b
c' b
d' where
V4 a' :: b
a' _ _ _ = a -> V4 b
f a
a
V4 _ b' :: b
b' _ _ = a -> V4 b
f a
b
V4 _ _ c' :: b
c' _ = a -> V4 b
f a
c
V4 _ _ _ d' :: b
d' = a -> V4 b
f a
d
{-# INLINE (>>=) #-}
instance Num a => Num (V4 a) where
+ :: V4 a -> V4 a -> V4 a
(+) = (a -> a -> a) -> V4 a -> V4 a -> V4 a
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Num a => a -> a -> a
(+)
{-# INLINE (+) #-}
* :: V4 a -> V4 a -> V4 a
(*) = (a -> a -> a) -> V4 a -> V4 a -> V4 a
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Num a => a -> a -> a
(*)
{-# INLINE (-) #-}
(-) = (a -> a -> a) -> V4 a -> V4 a -> V4 a
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (-)
{-# INLINE (*) #-}
negate :: V4 a -> V4 a
negate = (a -> a) -> V4 a -> V4 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Num a => a -> a
negate
{-# INLINE negate #-}
abs :: V4 a -> V4 a
abs = (a -> a) -> V4 a -> V4 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Num a => a -> a
abs
{-# INLINE abs #-}
signum :: V4 a -> V4 a
signum = (a -> a) -> V4 a -> V4 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Num a => a -> a
signum
{-# INLINE signum #-}
fromInteger :: Integer -> V4 a
fromInteger = a -> V4 a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> V4 a) -> (Integer -> a) -> Integer -> V4 a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> a
forall a. Num a => Integer -> a
fromInteger
{-# INLINE fromInteger #-}
instance Fractional a => Fractional (V4 a) where
recip :: V4 a -> V4 a
recip = (a -> a) -> V4 a -> V4 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Fractional a => a -> a
recip
{-# INLINE recip #-}
/ :: V4 a -> V4 a -> V4 a
(/) = (a -> a -> a) -> V4 a -> V4 a -> V4 a
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Fractional a => a -> a -> a
(/)
{-# INLINE (/) #-}
fromRational :: Rational -> V4 a
fromRational = a -> V4 a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> V4 a) -> (Rational -> a) -> Rational -> V4 a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> a
forall a. Fractional a => Rational -> a
fromRational
{-# INLINE fromRational #-}
instance Floating a => Floating (V4 a) where
pi :: V4 a
pi = a -> V4 a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Floating a => a
pi
{-# INLINE pi #-}
exp :: V4 a -> V4 a
exp = (a -> a) -> V4 a -> V4 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
exp
{-# INLINE exp #-}
sqrt :: V4 a -> V4 a
sqrt = (a -> a) -> V4 a -> V4 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
sqrt
{-# INLINE sqrt #-}
log :: V4 a -> V4 a
log = (a -> a) -> V4 a -> V4 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
log
{-# INLINE log #-}
** :: V4 a -> V4 a -> V4 a
(**) = (a -> a -> a) -> V4 a -> V4 a -> V4 a
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Floating a => a -> a -> a
(**)
{-# INLINE (**) #-}
logBase :: V4 a -> V4 a -> V4 a
logBase = (a -> a -> a) -> V4 a -> V4 a -> V4 a
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Floating a => a -> a -> a
logBase
{-# INLINE logBase #-}
sin :: V4 a -> V4 a
sin = (a -> a) -> V4 a -> V4 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
sin
{-# INLINE sin #-}
tan :: V4 a -> V4 a
tan = (a -> a) -> V4 a -> V4 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
tan
{-# INLINE tan #-}
cos :: V4 a -> V4 a
cos = (a -> a) -> V4 a -> V4 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
cos
{-# INLINE cos #-}
asin :: V4 a -> V4 a
asin = (a -> a) -> V4 a -> V4 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
asin
{-# INLINE asin #-}
atan :: V4 a -> V4 a
atan = (a -> a) -> V4 a -> V4 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
atan
{-# INLINE atan #-}
acos :: V4 a -> V4 a
acos = (a -> a) -> V4 a -> V4 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
acos
{-# INLINE acos #-}
sinh :: V4 a -> V4 a
sinh = (a -> a) -> V4 a -> V4 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
sinh
{-# INLINE sinh #-}
tanh :: V4 a -> V4 a
tanh = (a -> a) -> V4 a -> V4 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
tanh
{-# INLINE tanh #-}
cosh :: V4 a -> V4 a
cosh = (a -> a) -> V4 a -> V4 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
cosh
{-# INLINE cosh #-}
asinh :: V4 a -> V4 a
asinh = (a -> a) -> V4 a -> V4 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
asinh
{-# INLINE asinh #-}
atanh :: V4 a -> V4 a
atanh = (a -> a) -> V4 a -> V4 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
atanh
{-# INLINE atanh #-}
acosh :: V4 a -> V4 a
acosh = (a -> a) -> V4 a -> V4 a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
acosh
{-# INLINE acosh #-}
instance Storable a => Storable (V4 a) where
sizeOf :: V4 a -> Int
sizeOf _ = 4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* a -> Int
forall a. Storable a => a -> Int
sizeOf (a
forall a. HasCallStack => a
undefined::a)
{-# INLINE sizeOf #-}
alignment :: V4 a -> Int
alignment _ = a -> Int
forall a. Storable a => a -> Int
alignment (a
forall a. HasCallStack => a
undefined::a)
{-# INLINE alignment #-}
poke :: Ptr (V4 a) -> V4 a -> IO ()
poke ptr :: Ptr (V4 a)
ptr (V4 x :: a
x y :: a
y z :: a
z w :: a
w) = do Ptr a -> a -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr a
ptr' a
x
Ptr a -> Int -> a -> IO ()
forall a. Storable a => Ptr a -> Int -> a -> IO ()
pokeElemOff Ptr a
ptr' 1 a
y
Ptr a -> Int -> a -> IO ()
forall a. Storable a => Ptr a -> Int -> a -> IO ()
pokeElemOff Ptr a
ptr' 2 a
z
Ptr a -> Int -> a -> IO ()
forall a. Storable a => Ptr a -> Int -> a -> IO ()
pokeElemOff Ptr a
ptr' 3 a
w
where ptr' :: Ptr a
ptr' = Ptr (V4 a) -> Ptr a
forall a b. Ptr a -> Ptr b
castPtr Ptr (V4 a)
ptr
{-# INLINE poke #-}
peek :: Ptr (V4 a) -> IO (V4 a)
peek ptr :: Ptr (V4 a)
ptr = a -> a -> a -> a -> V4 a
forall a. a -> a -> a -> a -> V4 a
V4 (a -> a -> a -> a -> V4 a) -> IO a -> IO (a -> a -> a -> V4 a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr a -> IO a
forall a. Storable a => Ptr a -> IO a
peek Ptr a
ptr' IO (a -> a -> a -> V4 a) -> IO a -> IO (a -> a -> V4 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr a -> Int -> IO a
forall a. Storable a => Ptr a -> Int -> IO a
peekElemOff Ptr a
ptr' 1
IO (a -> a -> V4 a) -> IO a -> IO (a -> V4 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr a -> Int -> IO a
forall a. Storable a => Ptr a -> Int -> IO a
peekElemOff Ptr a
ptr' 2 IO (a -> V4 a) -> IO a -> IO (V4 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr a -> Int -> IO a
forall a. Storable a => Ptr a -> Int -> IO a
peekElemOff Ptr a
ptr' 3
where ptr' :: Ptr a
ptr' = Ptr (V4 a) -> Ptr a
forall a b. Ptr a -> Ptr b
castPtr Ptr (V4 a)
ptr
{-# INLINE peek #-}
instance Ix a => Ix (V4 a) where
{-# SPECIALISE instance Ix (V4 Int) #-}
range :: (V4 a, V4 a) -> [V4 a]
range (V4 l1 :: a
l1 l2 :: a
l2 l3 :: a
l3 l4 :: a
l4,V4 u1 :: a
u1 u2 :: a
u2 u3 :: a
u3 u4 :: a
u4) =
[a -> a -> a -> a -> V4 a
forall a. a -> a -> a -> a -> V4 a
V4 a
i1 a
i2 a
i3 a
i4 | a
i1 <- (a, a) -> [a]
forall a. Ix a => (a, a) -> [a]
range (a
l1,a
u1)
, a
i2 <- (a, a) -> [a]
forall a. Ix a => (a, a) -> [a]
range (a
l2,a
u2)
, a
i3 <- (a, a) -> [a]
forall a. Ix a => (a, a) -> [a]
range (a
l3,a
u3)
, a
i4 <- (a, a) -> [a]
forall a. Ix a => (a, a) -> [a]
range (a
l4,a
u4)
]
{-# INLINE range #-}
unsafeIndex :: (V4 a, V4 a) -> V4 a -> Int
unsafeIndex (V4 l1 :: a
l1 l2 :: a
l2 l3 :: a
l3 l4 :: a
l4,V4 u1 :: a
u1 u2 :: a
u2 u3 :: a
u3 u4 :: a
u4) (V4 i1 :: a
i1 i2 :: a
i2 i3 :: a
i3 i4 :: a
i4) =
(a, a) -> a -> Int
forall a. Ix a => (a, a) -> a -> Int
unsafeIndex (a
l4,a
u4) a
i4 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ (a, a) -> Int
forall a. Ix a => (a, a) -> Int
unsafeRangeSize (a
l4,a
u4) Int -> Int -> Int
forall a. Num a => a -> a -> a
* (
(a, a) -> a -> Int
forall a. Ix a => (a, a) -> a -> Int
unsafeIndex (a
l3,a
u3) a
i3 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ (a, a) -> Int
forall a. Ix a => (a, a) -> Int
unsafeRangeSize (a
l3,a
u3) Int -> Int -> Int
forall a. Num a => a -> a -> a
* (
(a, a) -> a -> Int
forall a. Ix a => (a, a) -> a -> Int
unsafeIndex (a
l2,a
u2) a
i2 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ (a, a) -> Int
forall a. Ix a => (a, a) -> Int
unsafeRangeSize (a
l2,a
u2) Int -> Int -> Int
forall a. Num a => a -> a -> a
*
(a, a) -> a -> Int
forall a. Ix a => (a, a) -> a -> Int
unsafeIndex (a
l1,a
u1) a
i1))
{-# INLINE unsafeIndex #-}
inRange :: (V4 a, V4 a) -> V4 a -> Bool
inRange (V4 l1 :: a
l1 l2 :: a
l2 l3 :: a
l3 l4 :: a
l4,V4 u1 :: a
u1 u2 :: a
u2 u3 :: a
u3 u4 :: a
u4) (V4 i1 :: a
i1 i2 :: a
i2 i3 :: a
i3 i4 :: a
i4) =
(a, a) -> a -> Bool
forall a. Ix a => (a, a) -> a -> Bool
inRange (a
l1,a
u1) a
i1 Bool -> Bool -> Bool
&& (a, a) -> a -> Bool
forall a. Ix a => (a, a) -> a -> Bool
inRange (a
l2,a
u2) a
i2 Bool -> Bool -> Bool
&&
(a, a) -> a -> Bool
forall a. Ix a => (a, a) -> a -> Bool
inRange (a
l3,a
u3) a
i3 Bool -> Bool -> Bool
&& (a, a) -> a -> Bool
forall a. Ix a => (a, a) -> a -> Bool
inRange (a
l4,a
u4) a
i4
{-# INLINE inRange #-}
data instance U.Vector (V4 a) = V_V4 {-# UNPACK #-} !Int !(U.Vector a)
data instance U.MVector s (V4 a) = MV_V4 {-# UNPACK #-} !Int !(U.MVector s a)
instance U.Unbox a => U.Unbox (V4 a)
instance U.Unbox a => M.MVector U.MVector (V4 a) where
basicLength :: MVector s (V4 a) -> Int
basicLength (MV_V4 n _) = Int
n
basicUnsafeSlice :: Int -> Int -> MVector s (V4 a) -> MVector s (V4 a)
basicUnsafeSlice m :: Int
m n :: Int
n (MV_V4 _ v) = Int -> MVector s a -> MVector s (V4 a)
forall s a. Int -> MVector s a -> MVector s (V4 a)
MV_V4 Int
n (Int -> Int -> MVector s a -> MVector s a
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
M.basicUnsafeSlice (4Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
m) (4Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
n) MVector s a
v)
basicOverlaps :: MVector s (V4 a) -> MVector s (V4 a) -> Bool
basicOverlaps (MV_V4 _ v) (MV_V4 _ u) = MVector s a -> MVector s a -> Bool
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> Bool
M.basicOverlaps MVector s a
v MVector s a
u
basicUnsafeNew :: Int -> m (MVector (PrimState m) (V4 a))
basicUnsafeNew n :: Int
n = (MVector (PrimState m) a -> MVector (PrimState m) (V4 a))
-> m (MVector (PrimState m) a) -> m (MVector (PrimState m) (V4 a))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (Int -> MVector (PrimState m) a -> MVector (PrimState m) (V4 a)
forall s a. Int -> MVector s a -> MVector s (V4 a)
MV_V4 Int
n) (Int -> m (MVector (PrimState m) a)
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
Int -> m (v (PrimState m) a)
M.basicUnsafeNew (4Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
n))
basicUnsafeRead :: MVector (PrimState m) (V4 a) -> Int -> m (V4 a)
basicUnsafeRead (MV_V4 _ v) i :: Int
i =
do let o :: Int
o = 4Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
i
a
x <- MVector (PrimState m) a -> Int -> m a
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> m a
M.basicUnsafeRead MVector (PrimState m) a
v Int
o
a
y <- MVector (PrimState m) a -> Int -> m a
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> m a
M.basicUnsafeRead MVector (PrimState m) a
v (Int
oInt -> Int -> Int
forall a. Num a => a -> a -> a
+1)
a
z <- MVector (PrimState m) a -> Int -> m a
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> m a
M.basicUnsafeRead MVector (PrimState m) a
v (Int
oInt -> Int -> Int
forall a. Num a => a -> a -> a
+2)
a
w <- MVector (PrimState m) a -> Int -> m a
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> m a
M.basicUnsafeRead MVector (PrimState m) a
v (Int
oInt -> Int -> Int
forall a. Num a => a -> a -> a
+3)
V4 a -> m (V4 a)
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> a -> a -> a -> V4 a
forall a. a -> a -> a -> a -> V4 a
V4 a
x a
y a
z a
w)
basicUnsafeWrite :: MVector (PrimState m) (V4 a) -> Int -> V4 a -> m ()
basicUnsafeWrite (MV_V4 _ v) i :: Int
i (V4 x :: a
x y :: a
y z :: a
z w :: a
w) =
do let o :: Int
o = 4Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
i
MVector (PrimState m) a -> Int -> a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> a -> m ()
M.basicUnsafeWrite MVector (PrimState m) a
v Int
o a
x
MVector (PrimState m) a -> Int -> a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> a -> m ()
M.basicUnsafeWrite MVector (PrimState m) a
v (Int
oInt -> Int -> Int
forall a. Num a => a -> a -> a
+1) a
y
MVector (PrimState m) a -> Int -> a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> a -> m ()
M.basicUnsafeWrite MVector (PrimState m) a
v (Int
oInt -> Int -> Int
forall a. Num a => a -> a -> a
+2) a
z
MVector (PrimState m) a -> Int -> a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> a -> m ()
M.basicUnsafeWrite MVector (PrimState m) a
v (Int
oInt -> Int -> Int
forall a. Num a => a -> a -> a
+3) a
w
#if MIN_VERSION_vector(0,11,0)
basicInitialize :: MVector (PrimState m) (V4 a) -> m ()
basicInitialize (MV_V4 _ v) = MVector (PrimState m) a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> m ()
M.basicInitialize MVector (PrimState m) a
v
#endif
instance U.Unbox a => G.Vector U.Vector (V4 a) where
basicUnsafeFreeze :: Mutable Vector (PrimState m) (V4 a) -> m (Vector (V4 a))
basicUnsafeFreeze (MV_V4 n v) = (Vector a -> Vector (V4 a)) -> m (Vector a) -> m (Vector (V4 a))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM ( Int -> Vector a -> Vector (V4 a)
forall a. Int -> Vector a -> Vector (V4 a)
V_V4 Int
n) (Mutable Vector (PrimState m) a -> m (Vector a)
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
Mutable v (PrimState m) a -> m (v a)
G.basicUnsafeFreeze MVector (PrimState m) a
Mutable Vector (PrimState m) a
v)
basicUnsafeThaw :: Vector (V4 a) -> m (Mutable Vector (PrimState m) (V4 a))
basicUnsafeThaw ( V_V4 n v) = (MVector (PrimState m) a -> MVector (PrimState m) (V4 a))
-> m (MVector (PrimState m) a) -> m (MVector (PrimState m) (V4 a))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (Int -> MVector (PrimState m) a -> MVector (PrimState m) (V4 a)
forall s a. Int -> MVector s a -> MVector s (V4 a)
MV_V4 Int
n) (Vector a -> m (Mutable Vector (PrimState m) a)
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
v a -> m (Mutable v (PrimState m) a)
G.basicUnsafeThaw Vector a
v)
basicLength :: Vector (V4 a) -> Int
basicLength ( V_V4 n _) = Int
n
basicUnsafeSlice :: Int -> Int -> Vector (V4 a) -> Vector (V4 a)
basicUnsafeSlice m :: Int
m n :: Int
n (V_V4 _ v) = Int -> Vector a -> Vector (V4 a)
forall a. Int -> Vector a -> Vector (V4 a)
V_V4 Int
n (Int -> Int -> Vector a -> Vector a
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
G.basicUnsafeSlice (4Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
m) (4Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
n) Vector a
v)
basicUnsafeIndexM :: Vector (V4 a) -> Int -> m (V4 a)
basicUnsafeIndexM (V_V4 _ v) i :: Int
i =
do let o :: Int
o = 4Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
i
a
x <- Vector a -> Int -> m a
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
G.basicUnsafeIndexM Vector a
v Int
o
a
y <- Vector a -> Int -> m a
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
G.basicUnsafeIndexM Vector a
v (Int
oInt -> Int -> Int
forall a. Num a => a -> a -> a
+1)
a
z <- Vector a -> Int -> m a
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
G.basicUnsafeIndexM Vector a
v (Int
oInt -> Int -> Int
forall a. Num a => a -> a -> a
+2)
a
w <- Vector a -> Int -> m a
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
G.basicUnsafeIndexM Vector a
v (Int
oInt -> Int -> Int
forall a. Num a => a -> a -> a
+3)
V4 a -> m (V4 a)
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> a -> a -> a -> V4 a
forall a. a -> a -> a -> a -> V4 a
V4 a
x a
y a
z a
w)
instance MonadZip V4 where
mzipWith :: (a -> b -> c) -> V4 a -> V4 b -> V4 c
mzipWith = (a -> b -> c) -> V4 a -> V4 b -> V4 c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2
instance MonadFix V4 where
mfix :: (a -> V4 a) -> V4 a
mfix f :: a -> V4 a
f = a -> a -> a -> a -> V4 a
forall a. a -> a -> a -> a -> V4 a
V4 (let V4 a :: a
a _ _ _ = a -> V4 a
f a
a in a
a)
(let V4 _ a :: a
a _ _ = a -> V4 a
f a
a in a
a)
(let V4 _ _ a :: a
a _ = a -> V4 a
f a
a in a
a)
(let V4 _ _ _ a :: a
a = a -> V4 a
f a
a in a
a)
instance Bounded a => Bounded (V4 a) where
minBound :: V4 a
minBound = a -> V4 a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Bounded a => a
minBound
{-# INLINE minBound #-}
maxBound :: V4 a
maxBound = a -> V4 a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Bounded a => a
maxBound
{-# INLINE maxBound #-}