{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveLift #-}

#ifndef MIN_VERSION_hashable
#define MIN_VERSION_hashable(x,y,z) 1
#endif

#ifndef MIN_VERSION_vector
#define MIN_VERSION_vector(x,y,z) 1
#endif

#ifndef MIN_VERSION_transformers
#define MIN_VERSION_transformers(x,y,z) 1
#endif

#ifndef MIN_VERSION_base
#define MIN_VERSION_base(x,y,z) 1
#endif

-----------------------------------------------------------------------------
-- |
-- Copyright   :  (C) 2012-2015 Edward Kmett
-- License     :  BSD-style (see the file LICENSE)
--
-- Maintainer  :  Edward Kmett <ekmett@gmail.com>
-- Stability   :  experimental
-- Portability :  non-portable
--
-- 2-D Vectors
----------------------------------------------------------------------------
module Linear.V2
  ( V2(..)
  , R1(..)
  , R2(..)
  , _yx
  , ex, ey
  , perp
  , angle
  , unangle
  , crossZ
  ) where

import Control.Applicative
import Control.DeepSeq (NFData(rnf))
import Control.Monad (liftM)
import Control.Monad.Fix
import Control.Monad.Zip
import Control.Lens as Lens hiding ((<.>))
import Data.Binary as Binary
import Data.Bytes.Serial
import Data.Data
import Data.Distributive
import Data.Foldable
import qualified Data.Foldable.WithIndex as WithIndex
import Data.Functor.Bind
import Data.Functor.Classes
import Data.Functor.Rep
import qualified Data.Functor.WithIndex as WithIndex
import Data.Hashable
import Data.Hashable.Lifted
import Data.Semigroup
import Data.Semigroup.Foldable
import Data.Serialize as Cereal
import qualified Data.Traversable.WithIndex as WithIndex
import qualified Data.Vector as V
import Foreign.Ptr (castPtr)
import Foreign.Storable (Storable(..))
import GHC.Arr (Ix(..))
import GHC.Generics (Generic, Generic1)
#if defined(MIN_VERSION_template_haskell)
import Language.Haskell.TH.Syntax (Lift)
#endif
import qualified Data.Vector.Generic.Mutable as M
import qualified Data.Vector.Generic as G
import qualified Data.Vector.Unboxed.Base as U
import Linear.Metric
import Linear.Epsilon
import Linear.V
import Linear.Vector
import Linear.V1 (R1(..),ex)
import Prelude hiding (sum)
import System.Random (Random(..))

-- $setup
-- >>> import Control.Applicative
-- >>> import Control.Lens
-- >>> import qualified Data.Foldable as F
-- >>> let sum xs = F.sum xs

-- | A 2-dimensional vector
--
-- >>> pure 1 :: V2 Int
-- V2 1 1
--
-- >>> V2 1 2 + V2 3 4
-- V2 4 6
--
-- >>> V2 1 2 * V2 3 4
-- V2 3 8
--
-- >>> sum (V2 1 2)
-- 3

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
$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
/= :: 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
$ccompare :: forall a. Ord a => V2 a -> V2 a -> Ordering
compare :: V2 a -> V2 a -> Ordering
$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
>= :: V2 a -> V2 a -> Bool
$cmax :: forall a. Ord a => V2 a -> V2 a -> V2 a
max :: V2 a -> V2 a -> V2 a
$cmin :: forall a. Ord a => V2 a -> V2 a -> V2 a
min :: V2 a -> V2 a -> 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
$cshowsPrec :: forall a. Show a => Int -> V2 a -> ShowS
showsPrec :: Int -> V2 a -> ShowS
$cshow :: forall a. Show a => V2 a -> String
show :: V2 a -> String
$cshowList :: forall a. Show a => [V2 a] -> ShowS
showList :: [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
$creadsPrec :: forall a. Read a => Int -> ReadS (V2 a)
readsPrec :: Int -> ReadS (V2 a)
$creadList :: forall a. Read a => ReadS [V2 a]
readList :: ReadS [V2 a]
$creadPrec :: forall a. Read a => ReadPrec (V2 a)
readPrec :: ReadPrec (V2 a)
$creadListPrec :: forall a. Read a => ReadPrec [V2 a]
readListPrec :: ReadPrec [V2 a]
Read,Typeable (V2 a)
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 -> Constr
V2 a -> DataType
(forall b. Data b => b -> b) -> V2 a -> V2 a
forall a. Data a => Typeable (V2 a)
forall a. Data a => V2 a -> Constr
forall a. Data a => V2 a -> DataType
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))
$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)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> V2 a -> 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)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (V2 a)
$ctoConstr :: forall a. Data a => V2 a -> Constr
toConstr :: V2 a -> Constr
$cdataTypeOf :: forall a. Data a => V2 a -> DataType
dataTypeOf :: V2 a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (V2 a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> 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))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V2 a))
$cgmapT :: forall a. Data a => (forall b. Data b => b -> b) -> V2 a -> V2 a
gmapT :: (forall b. Data b => b -> b) -> V2 a -> V2 a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V2 a -> r
gmapQl :: forall r r'.
(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
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V2 a -> r
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> V2 a -> [u]
gmapQ :: forall u. (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
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> V2 a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> V2 a -> m (V2 a)
gmapM :: forall (m :: * -> *).
Monad m =>
(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)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> V2 a -> m (V2 a)
Data
  ,(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
$cfrom :: forall a x. V2 a -> Rep (V2 a) x
from :: forall x. V2 a -> Rep (V2 a) x
$cto :: forall a x. Rep (V2 a) x -> V2 a
to :: forall x. Rep (V2 a) x -> V2 a
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
$cfrom1 :: forall a. V2 a -> Rep1 V2 a
from1 :: forall a. V2 a -> Rep1 V2 a
$cto1 :: forall a. Rep1 V2 a -> V2 a
to1 :: forall a. Rep1 V2 a -> V2 a
Generic1
#if defined(MIN_VERSION_template_haskell)
  ,(forall (m :: * -> *). Quote m => V2 a -> m Exp)
-> (forall (m :: * -> *). Quote m => V2 a -> Code m (V2 a))
-> Lift (V2 a)
forall a (m :: * -> *). (Lift a, Quote m) => V2 a -> m Exp
forall a (m :: * -> *). (Lift a, Quote m) => V2 a -> Code m (V2 a)
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => V2 a -> m Exp
forall (m :: * -> *). Quote m => V2 a -> Code m (V2 a)
$clift :: forall a (m :: * -> *). (Lift a, Quote m) => V2 a -> m Exp
lift :: forall (m :: * -> *). Quote m => V2 a -> m Exp
$cliftTyped :: forall a (m :: * -> *). (Lift a, Quote m) => V2 a -> Code m (V2 a)
liftTyped :: forall (m :: * -> *). Quote m => V2 a -> Code m (V2 a)
Lift
#endif
  )

instance Finite V2 where
  type Size V2 = 2
  toV :: forall a. V2 a -> V (Size V2) a
toV (V2 a
a a
b) = Vector a -> V 2 a
forall {k} (n :: k) a. Vector a -> V n a
V (Int -> [a] -> Vector a
forall a. Int -> [a] -> Vector a
V.fromListN Int
2 [a
a,a
b])
  fromV :: forall a. V (Size V2) a -> V2 a
fromV (V Vector a
v) = a -> a -> V2 a
forall a. a -> a -> V2 a
V2 (Vector a
v Vector a -> Int -> a
forall a. Vector a -> Int -> a
V.! Int
0) (Vector a
v Vector a -> Int -> a
forall a. Vector a -> Int -> a
V.! Int
1)

instance Random a => Random (V2 a) where
  random :: forall g. RandomGen g => g -> (V2 a, g)
random g
g = case g -> (a, g)
forall g. RandomGen g => g -> (a, g)
forall a g. (Random a, RandomGen g) => g -> (a, g)
random g
g of
   (a
a, g
g') -> case g -> (a, g)
forall g. RandomGen g => g -> (a, g)
forall a g. (Random a, RandomGen g) => g -> (a, g)
random g
g' of
     (a
b, g
g'') -> (a -> a -> V2 a
forall a. a -> a -> V2 a
V2 a
a a
b, g
g'')
  {-# inline random #-}
  randomR :: forall g. RandomGen g => (V2 a, V2 a) -> g -> (V2 a, g)
randomR (V2 a
a a
b, V2 a
c a
d) g
g = case (a, a) -> g -> (a, g)
forall g. RandomGen g => (a, a) -> g -> (a, g)
forall a g. (Random a, RandomGen g) => (a, a) -> g -> (a, g)
randomR (a
a, a
c) g
g of
    (a
x, g
g') -> case (a, a) -> g -> (a, g)
forall g. RandomGen g => (a, a) -> g -> (a, g)
forall a g. (Random a, RandomGen g) => (a, a) -> g -> (a, g)
randomR (a
b, a
d) g
g' of
      (a
y, g
g'') -> (a -> a -> V2 a
forall a. a -> a -> V2 a
V2 a
x a
y, g
g'')
  {-# inline randomR #-}

instance Functor V2 where
  fmap :: forall a b. (a -> b) -> V2 a -> V2 b
fmap a -> b
f (V2 a
a 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 <$ :: forall a b. a -> V2 b -> V2 a
<$ V2 b
_ = a -> a -> V2 a
forall a. a -> a -> V2 a
V2 a
a a
a
  {-# INLINE (<$) #-}

instance Foldable V2 where
  foldMap :: forall m a. Monoid m => (a -> m) -> V2 a -> m
foldMap a -> m
f (V2 a
a 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 #-}
#if MIN_VERSION_base(4,13,0)
  foldMap' :: forall m a. Monoid m => (a -> m) -> V2 a -> m
foldMap' a -> m
f (V2 a
a 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' #-}
#endif
  null :: forall a. V2 a -> Bool
null V2 a
_ = Bool
False
  length :: forall a. V2 a -> Int
length V2 a
_ = Int
2

instance Traversable V2 where
  traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> V2 a -> f (V2 b)
traverse a -> f b
f (V2 a
a 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 a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
b
  {-# INLINE traverse #-}

instance Foldable1 V2 where
  foldMap1 :: forall m a. Semigroup m => (a -> m) -> V2 a -> m
foldMap1 a -> m
f (V2 a
a a
b) = a -> m
f a
a m -> m -> m
forall a. Semigroup a => a -> a -> a
<> a -> m
f a
b
  {-# INLINE foldMap1 #-}

instance Traversable1 V2 where
  traverse1 :: forall (f :: * -> *) a b. Apply f => (a -> f b) -> V2 a -> f (V2 b)
traverse1 a -> f b
f (V2 a
a 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 a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
<.> a -> f b
f a
b
  {-# INLINE traverse1 #-}

instance Apply V2 where
  V2 a -> b
a a -> b
b <.> :: forall a b. V2 (a -> b) -> V2 a -> V2 b
<.> V2 a
d 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 Applicative V2 where
  pure :: forall a. a -> V2 a
pure a
a = a -> a -> V2 a
forall a. a -> a -> V2 a
V2 a
a a
a
  {-# INLINE pure #-}
  V2 a -> b
a a -> b
b <*> :: forall a b. V2 (a -> b) -> V2 a -> V2 b
<*> V2 a
d 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 Hashable a => Hashable (V2 a) where
  hashWithSalt :: Int -> V2 a -> Int
hashWithSalt Int
s (V2 a
a a
b) = Int
s Int -> a -> Int
forall a. Hashable a => Int -> a -> Int
`hashWithSalt` a
a Int -> a -> Int
forall a. Hashable a => Int -> a -> Int
`hashWithSalt` a
b
  {-# INLINE hashWithSalt #-}

instance Hashable1 V2 where
  liftHashWithSalt :: forall a. (Int -> a -> Int) -> Int -> V2 a -> Int
liftHashWithSalt Int -> a -> Int
h Int
s (V2 a
a a
b) = Int
s Int -> a -> Int
`h` a
a Int -> a -> Int
`h` a
b
  {-# INLINE liftHashWithSalt #-}

instance Additive V2 where
  zero :: forall a. Num a => V2 a
zero = a -> V2 a
forall a. a -> V2 a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
0
  {-# INLINE zero #-}
  liftU2 :: forall a. (a -> a -> a) -> V2 a -> V2 a -> V2 a
liftU2 = (a -> a -> a) -> V2 a -> V2 a -> V2 a
forall a b c. (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
  {-# INLINE liftU2 #-}
  liftI2 :: forall a b c. (a -> b -> c) -> V2 a -> V2 b -> V2 c
liftI2 = (a -> b -> c) -> V2 a -> V2 b -> V2 c
forall a b c. (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
  {-# INLINE liftI2 #-}

instance Bind V2 where
  V2 a
a a
b >>- :: forall a b. V2 a -> (a -> V2 b) -> V2 b
>>- a -> V2 b
f = b -> b -> V2 b
forall a. a -> a -> V2 a
V2 b
a' b
b' where
    V2 b
a' b
_ = a -> V2 b
f a
a
    V2 b
_ b
b' = a -> V2 b
f a
b
  {-# INLINE (>>-) #-}

instance Monad V2 where
#if !(MIN_VERSION_base(4,11,0))
  return a = V2 a a
  {-# INLINE return #-}
#endif
  V2 a
a a
b >>= :: forall a b. V2 a -> (a -> V2 b) -> V2 b
>>= a -> V2 b
f = b -> b -> V2 b
forall a. a -> a -> V2 a
V2 b
a' b
b' where
    V2 b
a' b
_ = 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 a b c. (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 a -> a -> a
forall a. Num a => a -> a -> a
(+)
  {-# INLINE (+) #-}
  (-) = (a -> a -> a) -> V2 a -> V2 a -> V2 a
forall a b c. (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 (-)
  {-# INLINE (-) #-}
  * :: V2 a -> V2 a -> V2 a
(*) = (a -> a -> a) -> V2 a -> V2 a -> V2 a
forall a b c. (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 a -> a -> a
forall a. Num a => a -> a -> a
(*)
  {-# INLINE (*) #-}
  negate :: V2 a -> V2 a
negate = (a -> a) -> V2 a -> V2 a
forall a b. (a -> b) -> V2 a -> V2 b
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 a b. (a -> b) -> V2 a -> V2 b
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 a b. (a -> b) -> V2 a -> V2 b
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 a. 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 a b. (a -> b) -> V2 a -> V2 b
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 a b c. (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 a -> a -> a
forall a. Fractional a => a -> a -> a
(/)
  {-# INLINE (/) #-}
  fromRational :: Rational -> V2 a
fromRational = a -> V2 a
forall a. 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 a. 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 a b. (a -> b) -> V2 a -> V2 b
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 a b. (a -> b) -> V2 a -> V2 b
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 a b. (a -> b) -> V2 a -> V2 b
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 a b c. (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 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 a b c. (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 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 a b. (a -> b) -> V2 a -> V2 b
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 a b. (a -> b) -> V2 a -> V2 b
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 a b. (a -> b) -> V2 a -> V2 b
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 a b. (a -> b) -> V2 a -> V2 b
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 a b. (a -> b) -> V2 a -> V2 b
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 a b. (a -> b) -> V2 a -> V2 b
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 a b. (a -> b) -> V2 a -> V2 b
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 a b. (a -> b) -> V2 a -> V2 b
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 a b. (a -> b) -> V2 a -> V2 b
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 a b. (a -> b) -> V2 a -> V2 b
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 a b. (a -> b) -> V2 a -> V2 b
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 a b. (a -> b) -> V2 a -> V2 b
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 Metric V2 where
  dot :: forall a. Num a => V2 a -> V2 a -> a
dot (V2 a
a a
b) (V2 a
c a
d) = a
a a -> a -> a
forall a. Num a => a -> a -> a
* a
c a -> a -> a
forall a. Num a => a -> a -> a
+ a
b a -> a -> a
forall a. Num a => a -> a -> a
* a
d
  {-# INLINE dot #-}

-- | A space that distinguishes 2 orthogonal basis vectors '_x' and '_y', but may have more.
class R1 t => R2 t where
  -- |
  -- >>> V2 1 2 ^._y
  -- 2
  --
  -- >>> V2 1 2 & _y .~ 3
  -- V2 1 3
  --
  _y :: Lens' (t a) a
  _y = (V2 a -> f (V2 a)) -> t a -> f (t a)
forall a. Lens' (t a) (V2 a)
forall (t :: * -> *) a. R2 t => Lens' (t a) (V2 a)
_xy((V2 a -> f (V2 a)) -> t a -> f (t a))
-> ((a -> f a) -> V2 a -> f (V2 a)) -> (a -> f a) -> t a -> f (t a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(a -> f a) -> V2 a -> f (V2 a)
forall a. Lens' (V2 a) a
forall (t :: * -> *) a. R2 t => Lens' (t a) a
_y
  {-# INLINE _y #-}

  _xy :: Lens' (t a) (V2 a)

-- |
-- >>> V2 1 2 ^. _yx
-- V2 2 1
_yx :: R2 t => Lens' (t a) (V2 a)
_yx :: forall (t :: * -> *) a. R2 t => Lens' (t a) (V2 a)
_yx V2 a -> f (V2 a)
f = (V2 a -> f (V2 a)) -> t a -> f (t a)
forall a. Lens' (t a) (V2 a)
forall (t :: * -> *) a. R2 t => Lens' (t a) (V2 a)
_xy ((V2 a -> f (V2 a)) -> t a -> f (t a))
-> (V2 a -> f (V2 a)) -> t a -> f (t a)
forall a b. (a -> b) -> a -> b
$ \(V2 a
a a
b) -> V2 a -> f (V2 a)
f (a -> a -> V2 a
forall a. a -> a -> V2 a
V2 a
b a
a) f (V2 a) -> (V2 a -> V2 a) -> f (V2 a)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(V2 a
b' a
a') -> a -> a -> V2 a
forall a. a -> a -> V2 a
V2 a
a' a
b'
{-# INLINE _yx #-}

ey :: R2 t => E t
ey :: forall (t :: * -> *). R2 t => E t
ey = (forall x. Lens' (t x) x) -> E t
forall (t :: * -> *). (forall x. Lens' (t x) x) -> E t
E (x -> f x) -> t x -> f (t x)
forall x. Lens' (t x) x
forall (t :: * -> *) a. R2 t => Lens' (t a) a
_y

instance R1 V2 where
  _x :: forall a. Lens' (V2 a) a
_x a -> f a
f (V2 a
a a
b) = (a -> a -> V2 a
forall a. a -> a -> V2 a
`V2` a
b) (a -> V2 a) -> f a -> f (V2 a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f a
f a
a
  {-# INLINE _x #-}

instance R2 V2 where
  _y :: forall a. Lens' (V2 a) a
_y a -> f a
f (V2 a
a a
b) = a -> a -> V2 a
forall a. a -> a -> V2 a
V2 a
a (a -> V2 a) -> f a -> f (V2 a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f a
f a
b
  {-# INLINE _y #-}
  _xy :: forall a. Lens' (V2 a) (V2 a)
_xy = (V2 a -> f (V2 a)) -> V2 a -> f (V2 a)
forall a. a -> a
id
  {-# INLINE _xy #-}

instance Distributive V2 where
  distribute :: forall (f :: * -> *) a. Functor f => f (V2 a) -> V2 (f a)
distribute f (V2 a)
f = f a -> f a -> V2 (f a)
forall a. a -> a -> V2 a
V2 ((V2 a -> a) -> f (V2 a) -> f a
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(V2 a
x a
_) -> a
x) f (V2 a)
f) ((V2 a -> a) -> f (V2 a) -> f a
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(V2 a
_ a
y) -> a
y) f (V2 a)
f)
  {-# INLINE distribute #-}

-- | the counter-clockwise perpendicular vector
--
-- >>> perp $ V2 10 20
-- V2 (-20) 10
perp :: Num a => V2 a -> V2 a
perp :: forall a. Num a => V2 a -> V2 a
perp (V2 a
a a
b) = a -> a -> V2 a
forall a. a -> a -> V2 a
V2 (a -> a
forall a. Num a => a -> a
negate a
b) a
a
{-# INLINE perp #-}

instance Epsilon a => Epsilon (V2 a) where
  nearZero :: V2 a -> Bool
nearZero = a -> Bool
forall a. Epsilon a => a -> Bool
nearZero (a -> Bool) -> (V2 a -> a) -> V2 a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. V2 a -> a
forall a. Num a => V2 a -> a
forall (f :: * -> *) a. (Metric f, Num a) => f a -> a
quadrance
  {-# INLINE nearZero #-}

instance Storable a => Storable (V2 a) where
  sizeOf :: V2 a -> Int
sizeOf V2 a
_ = Int
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 V2 a
_ = 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 (V2 a)
ptr (V2 a
x a
y) = Ptr a -> a -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr a
ptr' a
x IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
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' Int
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 (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 a b. IO (a -> b) -> IO a -> IO b
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' Int
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 a
l1 a
l2,V2 a
u1 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 a
l1 a
l2,V2 a
u1 a
u2) (V2 a
i1 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 a
l1 a
l2,V2 a
u1 a
u2) (V2 a
i1 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 #-}

instance Representable V2 where
  type Rep V2 = E V2
  tabulate :: forall a. (Rep V2 -> a) -> V2 a
tabulate Rep V2 -> a
f = a -> a -> V2 a
forall a. a -> a -> V2 a
V2 (Rep V2 -> a
f Rep V2
E V2
forall (t :: * -> *). R1 t => E t
ex) (Rep V2 -> a
f Rep V2
E V2
forall (t :: * -> *). R2 t => E t
ey)
  {-# INLINE tabulate #-}
  index :: forall a. V2 a -> Rep V2 -> a
index V2 a
xs (E forall a. Lens' (V2 a) a
l) = Getting a (V2 a) a -> V2 a -> a
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting a (V2 a) a
forall a. Lens' (V2 a) a
l V2 a
xs
  {-# INLINE index #-}

instance WithIndex.FunctorWithIndex (E V2) V2 where
  imap :: forall a b. (E V2 -> a -> b) -> V2 a -> V2 b
imap E V2 -> a -> b
f (V2 a
a a
b) = b -> b -> V2 b
forall a. a -> a -> V2 a
V2 (E V2 -> a -> b
f E V2
forall (t :: * -> *). R1 t => E t
ex a
a) (E V2 -> a -> b
f E V2
forall (t :: * -> *). R2 t => E t
ey a
b)
  {-# INLINE imap #-}

instance WithIndex.FoldableWithIndex (E V2) V2 where
  ifoldMap :: forall m a. Monoid m => (E V2 -> a -> m) -> V2 a -> m
ifoldMap E V2 -> a -> m
f (V2 a
a a
b) = E V2 -> a -> m
f E V2
forall (t :: * -> *). R1 t => E t
ex a
a m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` E V2 -> a -> m
f E V2
forall (t :: * -> *). R2 t => E t
ey a
b
  {-# INLINE ifoldMap #-}

instance WithIndex.TraversableWithIndex (E V2) V2 where
  itraverse :: forall (f :: * -> *) a b.
Applicative f =>
(E V2 -> a -> f b) -> V2 a -> f (V2 b)
itraverse E V2 -> a -> f b
f (V2 a
a 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
<$> E V2 -> a -> f b
f E V2
forall (t :: * -> *). R1 t => E t
ex a
a f (b -> V2 b) -> f b -> f (V2 b)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> E V2 -> a -> f b
f E V2
forall (t :: * -> *). R2 t => E t
ey a
b
  {-# INLINE itraverse #-}

#if !MIN_VERSION_lens(5,0,0)
instance Lens.FunctorWithIndex     (E V2) V2 where imap      = WithIndex.imap
instance Lens.FoldableWithIndex    (E V2) V2 where ifoldMap  = WithIndex.ifoldMap
instance Lens.TraversableWithIndex (E V2) V2 where itraverse = WithIndex.itraverse
#endif

type instance Index (V2 a) = E V2
type instance IxValue (V2 a) = a

instance Ixed (V2 a) where
  ix :: Index (V2 a) -> Traversal' (V2 a) (IxValue (V2 a))
ix Index (V2 a)
i = E V2 -> forall a. Lens' (V2 a) a
forall (t :: * -> *). E t -> forall x. Lens' (t x) x
el Index (V2 a)
E V2
i
  {-# INLINE ix #-}

instance Each (V2 a) (V2 b) a b where
  each :: Traversal (V2 a) (V2 b) a b
each = (a -> f b) -> V2 a -> f (V2 b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> V2 a -> f (V2 b)
traverse
  {-# INLINE each #-}

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 :: forall s. MVector s (V2 a) -> Int
basicLength (MV_V2 Int
n MVector s a
_) = Int
n
  basicUnsafeSlice :: forall s. Int -> Int -> MVector s (V2 a) -> MVector s (V2 a)
basicUnsafeSlice Int
m Int
n (MV_V2 Int
_ MVector s a
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 s. 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 (Int
2Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
m) (Int
2Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
n) MVector s a
v)
  basicOverlaps :: forall s. MVector s (V2 a) -> MVector s (V2 a) -> Bool
basicOverlaps (MV_V2 Int
_ MVector s a
v) (MV_V2 Int
_ MVector s a
u) = MVector s a -> MVector s a -> Bool
forall s. 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 :: forall s. Int -> ST s (MVector s (V2 a))
basicUnsafeNew Int
n = (MVector s a -> MVector s (V2 a))
-> ST s (MVector s a) -> ST s (MVector s (V2 a))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (Int -> MVector s a -> MVector s (V2 a)
forall s a. Int -> MVector s a -> MVector s (V2 a)
MV_V2 Int
n) (Int -> ST s (MVector s a)
forall s. Int -> ST s (MVector s a)
forall (v :: * -> * -> *) a s. MVector v a => Int -> ST s (v s a)
M.basicUnsafeNew (Int
2Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
n))
  basicUnsafeRead :: forall s. MVector s (V2 a) -> Int -> ST s (V2 a)
basicUnsafeRead (MV_V2 Int
_ MVector s a
v) Int
i =
    do let o :: Int
o = Int
2Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
i
       a
x <- MVector s a -> Int -> ST s a
forall s. MVector s a -> Int -> ST s a
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> ST s a
M.basicUnsafeRead MVector s a
v Int
o
       a
y <- MVector s a -> Int -> ST s a
forall s. MVector s a -> Int -> ST s a
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> ST s a
M.basicUnsafeRead MVector s a
v (Int
oInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)
       V2 a -> ST s (V2 a)
forall a. a -> ST s 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 :: forall s. MVector s (V2 a) -> Int -> V2 a -> ST s ()
basicUnsafeWrite (MV_V2 Int
_ MVector s a
v) Int
i (V2 a
x a
y) =
    do let o :: Int
o = Int
2Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
i
       MVector s a -> Int -> a -> ST s ()
forall s. MVector s a -> Int -> a -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> a -> ST s ()
M.basicUnsafeWrite MVector s a
v Int
o     a
x
       MVector s a -> Int -> a -> ST s ()
forall s. MVector s a -> Int -> a -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> a -> ST s ()
M.basicUnsafeWrite MVector s a
v (Int
oInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) a
y
  basicInitialize :: forall s. MVector s (V2 a) -> ST s ()
basicInitialize (MV_V2 Int
_ MVector s a
v) = MVector s a -> ST s ()
forall s. MVector s a -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s ()
M.basicInitialize MVector s a
v
  {-# INLINE basicInitialize #-}

instance U.Unbox a => G.Vector U.Vector (V2 a) where
  {-# INLINE basicUnsafeFreeze #-}
  {-# INLINE basicUnsafeThaw   #-}
  {-# INLINE basicLength       #-}
  {-# INLINE basicUnsafeSlice  #-}
  {-# INLINE basicUnsafeIndexM #-}
  basicUnsafeFreeze :: forall s. Mutable Vector s (V2 a) -> ST s (Vector (V2 a))
basicUnsafeFreeze (MV_V2 Int
n MVector s a
v) = (Vector a -> Vector (V2 a))
-> ST s (Vector a) -> ST s (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 s a -> ST s (Vector a)
forall s. Mutable Vector s a -> ST s (Vector a)
forall (v :: * -> *) a s. Vector v a => Mutable v s a -> ST s (v a)
G.basicUnsafeFreeze Mutable Vector s a
MVector s a
v)
  basicUnsafeThaw :: forall s. Vector (V2 a) -> ST s (Mutable Vector s (V2 a))
basicUnsafeThaw   ( V_V2 Int
n Vector a
v) = (MVector s a -> MVector s (V2 a))
-> ST s (MVector s a) -> ST s (MVector s (V2 a))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (Int -> MVector s a -> MVector s (V2 a)
forall s a. Int -> MVector s a -> MVector s (V2 a)
MV_V2 Int
n) (Vector a -> ST s (Mutable Vector s a)
forall s. Vector a -> ST s (Mutable Vector s a)
forall (v :: * -> *) a s. Vector v a => v a -> ST s (Mutable v s a)
G.basicUnsafeThaw   Vector a
v)
  basicLength :: Vector (V2 a) -> Int
basicLength       ( V_V2 Int
n Vector a
_) = Int
n
  basicUnsafeSlice :: Int -> Int -> Vector (V2 a) -> Vector (V2 a)
basicUnsafeSlice Int
m Int
n (V_V2 Int
_ Vector a
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 (Int
2Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
m) (Int
2Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
n) Vector a
v)
  basicUnsafeIndexM :: Vector (V2 a) -> Int -> Box (V2 a)
basicUnsafeIndexM (V_V2 Int
_ Vector a
v) Int
i =
    do let o :: Int
o = Int
2Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
i
       a
x <- Vector a -> Int -> Box a
forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
G.basicUnsafeIndexM Vector a
v Int
o
       a
y <- Vector a -> Int -> Box a
forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
G.basicUnsafeIndexM Vector a
v (Int
oInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)
       V2 a -> Box (V2 a)
forall a. a -> Box 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 :: forall a b c. (a -> b -> c) -> V2 a -> V2 b -> V2 c
mzipWith = (a -> b -> c) -> V2 a -> V2 b -> V2 c
forall a b c. (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 :: forall a. (a -> V2 a) -> V2 a
mfix 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)

angle :: Floating a => a -> V2 a
angle :: forall a. Floating a => a -> V2 a
angle a
a = a -> a -> V2 a
forall a. a -> a -> V2 a
V2 (a -> a
forall a. Floating a => a -> a
cos a
a) (a -> a
forall a. Floating a => a -> a
sin a
a)

unangle :: (Floating a, Ord a) => V2 a -> a
unangle :: forall a. (Floating a, Ord a) => V2 a -> a
unangle a :: V2 a
a@(V2 a
ax a
ay) =
  let alpha :: a
alpha = a -> a
forall a. Floating a => a -> a
asin (a -> a) -> a -> a
forall a b. (a -> b) -> a -> b
$ a
ay a -> a -> a
forall a. Fractional a => a -> a -> a
/ V2 a -> a
forall a. Floating a => V2 a -> a
forall (f :: * -> *) a. (Metric f, Floating a) => f a -> a
norm V2 a
a
  in if a
ax a -> a -> Bool
forall a. Ord a => a -> a -> Bool
< a
0
       then a
forall a. Floating a => a
pi a -> a -> a
forall a. Num a => a -> a -> a
- a
alpha
       else a
alpha

-- | The Z-component of the cross product of two vectors in the XY-plane.
--
-- >>> crossZ (V2 1 0) (V2 0 1)
-- 1
crossZ :: Num a => V2 a -> V2 a -> a
crossZ :: forall a. Num a => V2 a -> V2 a -> a
crossZ (V2 a
x1 a
y1) (V2 a
x2 a
y2) = a
x1a -> a -> a
forall a. Num a => a -> a -> a
*a
y2 a -> a -> a
forall a. Num a => a -> a -> a
- a
y1a -> a -> a
forall a. Num a => a -> a -> a
*a
x2
{-# INLINE crossZ #-}

instance Bounded a => Bounded (V2 a) where
  minBound :: V2 a
minBound = a -> V2 a
forall a. 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 a. a -> V2 a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Bounded a => a
maxBound
  {-# INLINE maxBound #-}

instance NFData a => NFData (V2 a) where
  rnf :: V2 a -> ()
rnf (V2 a
a a
b) = a -> ()
forall a. NFData a => a -> ()
rnf a
a () -> () -> ()
forall a b. a -> b -> b
`seq` a -> ()
forall a. NFData a => a -> ()
rnf a
b

instance Serial1 V2 where
  serializeWith :: forall (m :: * -> *) a. MonadPut m => (a -> m ()) -> V2 a -> m ()
serializeWith = (a -> m ()) -> V2 a -> m ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_
  deserializeWith :: forall (m :: * -> *) a. MonadGet m => m a -> m (V2 a)
deserializeWith m a
k = a -> a -> V2 a
forall a. a -> a -> V2 a
V2 (a -> a -> V2 a) -> m a -> m (a -> V2 a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m a
k m (a -> V2 a) -> m a -> m (V2 a)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m a
k

instance Serial a => Serial (V2 a) where
  serialize :: forall (m :: * -> *). MonadPut m => V2 a -> m ()
serialize = (a -> m ()) -> V2 a -> m ()
forall (f :: * -> *) (m :: * -> *) a.
(Serial1 f, MonadPut m) =>
(a -> m ()) -> f a -> m ()
forall (m :: * -> *) a. MonadPut m => (a -> m ()) -> V2 a -> m ()
serializeWith a -> m ()
forall a (m :: * -> *). (Serial a, MonadPut m) => a -> m ()
forall (m :: * -> *). MonadPut m => a -> m ()
serialize
  deserialize :: forall (m :: * -> *). MonadGet m => m (V2 a)
deserialize = m a -> m (V2 a)
forall (f :: * -> *) (m :: * -> *) a.
(Serial1 f, MonadGet m) =>
m a -> m (f a)
forall (m :: * -> *) a. MonadGet m => m a -> m (V2 a)
deserializeWith m a
forall a (m :: * -> *). (Serial a, MonadGet m) => m a
forall (m :: * -> *). MonadGet m => m a
deserialize

instance Binary a => Binary (V2 a) where
  put :: V2 a -> Put
put = (a -> Put) -> V2 a -> Put
forall (f :: * -> *) (m :: * -> *) a.
(Serial1 f, MonadPut m) =>
(a -> m ()) -> f a -> m ()
forall (m :: * -> *) a. MonadPut m => (a -> m ()) -> V2 a -> m ()
serializeWith a -> Put
forall t. Binary t => t -> Put
Binary.put
  get :: Get (V2 a)
get = Get a -> Get (V2 a)
forall (f :: * -> *) (m :: * -> *) a.
(Serial1 f, MonadGet m) =>
m a -> m (f a)
forall (m :: * -> *) a. MonadGet m => m a -> m (V2 a)
deserializeWith Get a
forall t. Binary t => Get t
Binary.get

instance Serialize a => Serialize (V2 a) where
  put :: Putter (V2 a)
put = (a -> PutM ()) -> Putter (V2 a)
forall (f :: * -> *) (m :: * -> *) a.
(Serial1 f, MonadPut m) =>
(a -> m ()) -> f a -> m ()
forall (m :: * -> *) a. MonadPut m => (a -> m ()) -> V2 a -> m ()
serializeWith a -> PutM ()
forall t. Serialize t => Putter t
Cereal.put
  get :: Get (V2 a)
get = Get a -> Get (V2 a)
forall (f :: * -> *) (m :: * -> *) a.
(Serial1 f, MonadGet m) =>
m a -> m (f a)
forall (m :: * -> *) a. MonadGet m => m a -> m (V2 a)
deserializeWith Get a
forall t. Serialize t => Get t
Cereal.get

instance Eq1 V2 where
  liftEq :: forall a b. (a -> b -> Bool) -> V2 a -> V2 b -> Bool
liftEq a -> b -> Bool
f (V2 a
a a
b) (V2 b
c b
d) = a -> b -> Bool
f a
a b
c Bool -> Bool -> Bool
&& a -> b -> Bool
f a
b b
d
instance Ord1 V2 where
  liftCompare :: forall a b. (a -> b -> Ordering) -> V2 a -> V2 b -> Ordering
liftCompare a -> b -> Ordering
f (V2 a
a a
b) (V2 b
c b
d) = a -> b -> Ordering
f a
a b
c Ordering -> Ordering -> Ordering
forall a. Monoid a => a -> a -> a
`mappend` a -> b -> Ordering
f a
b b
d
instance Read1 V2 where
  liftReadsPrec :: forall a. (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (V2 a)
liftReadsPrec Int -> ReadS a
f ReadS [a]
_ = (String -> ReadS (V2 a)) -> Int -> ReadS (V2 a)
forall a. (String -> ReadS a) -> Int -> ReadS a
readsData ((String -> ReadS (V2 a)) -> Int -> ReadS (V2 a))
-> (String -> ReadS (V2 a)) -> Int -> ReadS (V2 a)
forall a b. (a -> b) -> a -> b
$ (Int -> ReadS a)
-> (Int -> ReadS a)
-> String
-> (a -> a -> V2 a)
-> String
-> ReadS (V2 a)
forall a b t.
(Int -> ReadS a)
-> (Int -> ReadS b) -> String -> (a -> b -> t) -> String -> ReadS t
readsBinaryWith Int -> ReadS a
f Int -> ReadS a
f String
"V2" a -> a -> V2 a
forall a. a -> a -> V2 a
V2
instance Show1 V2 where
  liftShowsPrec :: forall a.
(Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> V2 a -> ShowS
liftShowsPrec Int -> a -> ShowS
f [a] -> ShowS
_ Int
d (V2 a
a a
b) = (Int -> a -> ShowS)
-> (Int -> a -> ShowS) -> String -> Int -> a -> a -> ShowS
forall a b.
(Int -> a -> ShowS)
-> (Int -> b -> ShowS) -> String -> Int -> a -> b -> ShowS
showsBinaryWith Int -> a -> ShowS
f Int -> a -> ShowS
f String
"V2" Int
d a
a a
b

instance Field1 (V2 a) (V2 a) a a where
  _1 :: Lens (V2 a) (V2 a) a a
_1 a -> f a
f (V2 a
x a
y) = a -> f a
f a
x f a -> (a -> V2 a) -> f (V2 a)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a
x' -> a -> a -> V2 a
forall a. a -> a -> V2 a
V2 a
x' a
y

instance Field2 (V2 a) (V2 a) a a where
  _2 :: Lens (V2 a) (V2 a) a a
_2 a -> f a
f (V2 a
x a
y) = a -> f a
f a
y f a -> (a -> V2 a) -> f (V2 a)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a
y' -> a -> a -> V2 a
forall a. a -> a -> V2 a
V2 a
x a
y'

instance Semigroup a => Semigroup (V2 a) where
 <> :: V2 a -> V2 a -> V2 a
(<>) = (a -> a -> a) -> V2 a -> V2 a -> V2 a
forall a b c. (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 a -> a -> a
forall a. Semigroup a => a -> a -> a
(<>)

instance Monoid a => Monoid (V2 a) where
  mempty :: V2 a
mempty = a -> V2 a
forall a. a -> V2 a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Monoid a => a
mempty
#if !(MIN_VERSION_base(4,11,0))
  mappend = liftA2 mappend
#endif