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

    #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
    -----------------------------------------------------------------------------

    -- |

    -- Copyright   :  (C) 2012-2015 Edward Kmett

    -- License     :  BSD-style (see the file LICENSE)

    --

    -- Maintainer  :  Edward Kmett <ekmett@gmail.com>

    -- Stability   :  experimental

    -- Portability :  non-portable

    --

    -- Plücker coordinates for lines in 3d homogeneous space.

    ----------------------------------------------------------------------------

    module Linear.Plucker
      ( Plucker(..)
      , squaredError
      , isotropic
      , (><)
      , plucker
      , plucker3D
      -- * Operations on lines

      , parallel
      , intersects
      , LinePass(..)
      , passes
      , quadranceToOrigin
      , closestToOrigin
      , isLine
      , coincides
      , coincides'
      -- * Basis elements

      ,      p01, p02, p03
      , p10,      p12, p13
      , p20, p21,      p23
      , p30, p31, p32

      , e01, e02, e03, e12, e31, e23
      ) 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 (index, (<.>))
    import Data.Binary as Binary
    import Data.Bytes.Serial
    import Data.Distributive
    import Data.Foldable as 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.Semigroup
    import Data.Semigroup.Foldable
    import Data.Serialize as Cereal
    import qualified Data.Traversable.WithIndex as WithIndex
    import qualified Data.Vector as V
    import qualified Data.Vector.Generic.Mutable as M
    import qualified Data.Vector.Generic as G
    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)
    #if defined(MIN_VERSION_template_haskell)
    import Language.Haskell.TH.Syntax (Lift)
    #endif
    import Linear.Epsilon
    import Linear.Metric
    import Linear.V
    import Linear.V2
    import Linear.V3
    import Linear.V4
    import Linear.Vector
    import System.Random (Random(..))

    -- | Plücker coordinates for lines in a 3-dimensional space.

    data Plucker a = Plucker !a !a !a !a !a !a deriving (Plucker a -> Plucker a -> Bool
    (Plucker a -> Plucker a -> Bool)
    -> (Plucker a -> Plucker a -> Bool) -> Eq (Plucker a)
    forall a. Eq a => Plucker a -> Plucker a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => Plucker a -> Plucker a -> Bool
    == :: Plucker a -> Plucker a -> Bool
    $c/= :: forall a. Eq a => Plucker a -> Plucker a -> Bool
    /= :: Plucker a -> Plucker a -> Bool
    Eq,Eq (Plucker a)
    Eq (Plucker a)
    -> (Plucker a -> Plucker a -> Ordering)
    -> (Plucker a -> Plucker a -> Bool)
    -> (Plucker a -> Plucker a -> Bool)
    -> (Plucker a -> Plucker a -> Bool)
    -> (Plucker a -> Plucker a -> Bool)
    -> (Plucker a -> Plucker a -> Plucker a)
    -> (Plucker a -> Plucker a -> Plucker a)
    -> Ord (Plucker a)
    Plucker a -> Plucker a -> Bool
    Plucker a -> Plucker a -> Ordering
    Plucker a -> Plucker a -> Plucker 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 (Plucker a)
    forall a. Ord a => Plucker a -> Plucker a -> Bool
    forall a. Ord a => Plucker a -> Plucker a -> Ordering
    forall a. Ord a => Plucker a -> Plucker a -> Plucker a
    $ccompare :: forall a. Ord a => Plucker a -> Plucker a -> Ordering
    compare :: Plucker a -> Plucker a -> Ordering
    $c< :: forall a. Ord a => Plucker a -> Plucker a -> Bool
    < :: Plucker a -> Plucker a -> Bool
    $c<= :: forall a. Ord a => Plucker a -> Plucker a -> Bool
    <= :: Plucker a -> Plucker a -> Bool
    $c> :: forall a. Ord a => Plucker a -> Plucker a -> Bool
    > :: Plucker a -> Plucker a -> Bool
    $c>= :: forall a. Ord a => Plucker a -> Plucker a -> Bool
    >= :: Plucker a -> Plucker a -> Bool
    $cmax :: forall a. Ord a => Plucker a -> Plucker a -> Plucker a
    max :: Plucker a -> Plucker a -> Plucker a
    $cmin :: forall a. Ord a => Plucker a -> Plucker a -> Plucker a
    min :: Plucker a -> Plucker a -> Plucker a
    Ord,Int -> Plucker a -> ShowS
    [Plucker a] -> ShowS
    Plucker a -> String
    (Int -> Plucker a -> ShowS)
    -> (Plucker a -> String)
    -> ([Plucker a] -> ShowS)
    -> Show (Plucker a)
    forall a. Show a => Int -> Plucker a -> ShowS
    forall a. Show a => [Plucker a] -> ShowS
    forall a. Show a => Plucker a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> Plucker a -> ShowS
    showsPrec :: Int -> Plucker a -> ShowS
    $cshow :: forall a. Show a => Plucker a -> String
    show :: Plucker a -> String
    $cshowList :: forall a. Show a => [Plucker a] -> ShowS
    showList :: [Plucker a] -> ShowS
    Show,ReadPrec [Plucker a]
    ReadPrec (Plucker a)
    Int -> ReadS (Plucker a)
    ReadS [Plucker a]
    (Int -> ReadS (Plucker a))
    -> ReadS [Plucker a]
    -> ReadPrec (Plucker a)
    -> ReadPrec [Plucker a]
    -> Read (Plucker a)
    forall a. Read a => ReadPrec [Plucker a]
    forall a. Read a => ReadPrec (Plucker a)
    forall a. Read a => Int -> ReadS (Plucker a)
    forall a. Read a => ReadS [Plucker a]
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: forall a. Read a => Int -> ReadS (Plucker a)
    readsPrec :: Int -> ReadS (Plucker a)
    $creadList :: forall a. Read a => ReadS [Plucker a]
    readList :: ReadS [Plucker a]
    $creadPrec :: forall a. Read a => ReadPrec (Plucker a)
    readPrec :: ReadPrec (Plucker a)
    $creadListPrec :: forall a. Read a => ReadPrec [Plucker a]
    readListPrec :: ReadPrec [Plucker a]
    Read
                                                        ,(forall x. Plucker a -> Rep (Plucker a) x)
    -> (forall x. Rep (Plucker a) x -> Plucker a)
    -> Generic (Plucker a)
    forall x. Rep (Plucker a) x -> Plucker a
    forall x. Plucker a -> Rep (Plucker a) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall a x. Rep (Plucker a) x -> Plucker a
    forall a x. Plucker a -> Rep (Plucker a) x
    $cfrom :: forall a x. Plucker a -> Rep (Plucker a) x
    from :: forall x. Plucker a -> Rep (Plucker a) x
    $cto :: forall a x. Rep (Plucker a) x -> Plucker a
    to :: forall x. Rep (Plucker a) x -> Plucker a
    Generic,(forall a. Plucker a -> Rep1 Plucker a)
    -> (forall a. Rep1 Plucker a -> Plucker a) -> Generic1 Plucker
    forall a. Rep1 Plucker a -> Plucker a
    forall a. Plucker a -> Rep1 Plucker 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. Plucker a -> Rep1 Plucker a
    from1 :: forall a. Plucker a -> Rep1 Plucker a
    $cto1 :: forall a. Rep1 Plucker a -> Plucker a
    to1 :: forall a. Rep1 Plucker a -> Plucker a
    Generic1
    #if defined(MIN_VERSION_template_haskell)
                                                        ,(forall (m :: * -> *). Quote m => Plucker a -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        Plucker a -> Code m (Plucker a))
    -> Lift (Plucker a)
    forall a (m :: * -> *). (Lift a, Quote m) => Plucker a -> m Exp
    forall a (m :: * -> *).
    (Lift a, Quote m) =>
    Plucker a -> Code m (Plucker a)
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => Plucker a -> m Exp
    forall (m :: * -> *). Quote m => Plucker a -> Code m (Plucker a)
    $clift :: forall a (m :: * -> *). (Lift a, Quote m) => Plucker a -> m Exp
    lift :: forall (m :: * -> *). Quote m => Plucker a -> m Exp
    $cliftTyped :: forall a (m :: * -> *).
    (Lift a, Quote m) =>
    Plucker a -> Code m (Plucker a)
    liftTyped :: forall (m :: * -> *). Quote m => Plucker a -> Code m (Plucker a)
    Lift
    #endif
                                                        )

    instance Finite Plucker where
      type Size Plucker = 6
      toV :: forall a. Plucker a -> V (Size Plucker) a
    toV (Plucker a
    a a
    b a
    c a
    d a
    e a
    f) = Vector a -> V 6 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
    6 [a
    a,a
    b,a
    c,a
    d,a
    e,a
    f])
      fromV :: forall a. V (Size Plucker) a -> Plucker a
    fromV (V Vector a
    v) = a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker (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) (Vector a
    v Vector a -> Int -> a
    forall a. Vector a -> Int -> a
    V.! Int
    2) (Vector a
    v Vector a -> Int -> a
    forall a. Vector a -> Int -> a
    V.! Int
    3) (Vector a
    v Vector a -> Int -> a
    forall a. Vector a -> Int -> a
    V.! Int
    4) (Vector a
    v Vector a -> Int -> a
    forall a. Vector a -> Int -> a
    V.! Int
    5)

    instance Random a => Random (Plucker a) where
      random :: forall g. RandomGen g => g -> (Plucker 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
    g1) -> case g -> (a, g)
    forall g. RandomGen g => g -> (a, g)
    forall a g. (Random a, RandomGen g) => g -> (a, g)
    random g
    g1 of
          (a
    b, g
    g2) -> case g -> (a, g)
    forall g. RandomGen g => g -> (a, g)
    forall a g. (Random a, RandomGen g) => g -> (a, g)
    random g
    g2 of
            (a
    c, g
    g3) -> case g -> (a, g)
    forall g. RandomGen g => g -> (a, g)
    forall a g. (Random a, RandomGen g) => g -> (a, g)
    random g
    g3 of
              (a
    d, g
    g4) -> case g -> (a, g)
    forall g. RandomGen g => g -> (a, g)
    forall a g. (Random a, RandomGen g) => g -> (a, g)
    random g
    g4 of
                (a
    e, g
    g5) -> case g -> (a, g)
    forall g. RandomGen g => g -> (a, g)
    forall a g. (Random a, RandomGen g) => g -> (a, g)
    random g
    g5 of
                  (a
    f, g
    g6) -> (a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker a
    a a
    b a
    c a
    d a
    e a
    f, g
    g6)
      randomR :: forall g.
    RandomGen g =>
    (Plucker a, Plucker a) -> g -> (Plucker a, g)
    randomR (Plucker a
    a a
    b a
    c a
    d a
    e a
    f, Plucker a
    a' a
    b' a
    c' a
    d' a
    e' a
    f') 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
    a') g
    g of
        (a
    a'', g
    g1) -> 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
    b') g
    g1 of
          (a
    b'', g
    g2) -> 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
    c,a
    c') g
    g2 of
            (a
    c'', g
    g3) -> 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
    d,a
    d') g
    g3 of
              (a
    d'', g
    g4) -> 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
    e,a
    e') g
    g4 of
                (a
    e'', g
    g5) -> 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
    f,a
    f') g
    g5 of
                  (a
    f'', g
    g6) -> (a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker a
    a'' a
    b'' a
    c'' a
    d'' a
    e'' a
    f'', g
    g6)

    instance Functor Plucker where
      fmap :: forall a b. (a -> b) -> Plucker a -> Plucker b
    fmap a -> b
    g (Plucker a
    a a
    b a
    c a
    d a
    e a
    f) = b -> b -> b -> b -> b -> b -> Plucker b
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker (a -> b
    g a
    a) (a -> b
    g a
    b) (a -> b
    g a
    c) (a -> b
    g a
    d) (a -> b
    g a
    e) (a -> b
    g a
    f)
      {-# INLINE fmap #-}

    instance Apply Plucker where
      Plucker a -> b
    a a -> b
    b a -> b
    c a -> b
    d a -> b
    e a -> b
    f <.> :: forall a b. Plucker (a -> b) -> Plucker a -> Plucker b
    <.> Plucker a
    g a
    h a
    i a
    j a
    k a
    l =
        b -> b -> b -> b -> b -> b -> Plucker b
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker (a -> b
    a a
    g) (a -> b
    b a
    h) (a -> b
    c a
    i) (a -> b
    d a
    j) (a -> b
    e a
    k) (a -> b
    f a
    l)
      {-# INLINE (<.>) #-}

    instance Applicative Plucker where
      pure :: forall a. a -> Plucker a
    pure a
    a = a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker a
    a a
    a a
    a a
    a a
    a a
    a
      {-# INLINE pure #-}
      Plucker a -> b
    a a -> b
    b a -> b
    c a -> b
    d a -> b
    e a -> b
    f <*> :: forall a b. Plucker (a -> b) -> Plucker a -> Plucker b
    <*> Plucker a
    g a
    h a
    i a
    j a
    k a
    l =
        b -> b -> b -> b -> b -> b -> Plucker b
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker (a -> b
    a a
    g) (a -> b
    b a
    h) (a -> b
    c a
    i) (a -> b
    d a
    j) (a -> b
    e a
    k) (a -> b
    f a
    l)
      {-# INLINE (<*>) #-}

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

    instance Bind Plucker where
      Plucker a
    a a
    b a
    c a
    d a
    e a
    f >>- :: forall a b. Plucker a -> (a -> Plucker b) -> Plucker b
    >>- a -> Plucker b
    g = b -> b -> b -> b -> b -> b -> Plucker b
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker b
    a' b
    b' b
    c' b
    d' b
    e' b
    f' where
        Plucker b
    a' b
    _ b
    _ b
    _ b
    _ b
    _ = a -> Plucker b
    g a
    a
        Plucker b
    _ b
    b' b
    _ b
    _ b
    _ b
    _ = a -> Plucker b
    g a
    b
        Plucker b
    _ b
    _ b
    c' b
    _ b
    _ b
    _ = a -> Plucker b
    g a
    c
        Plucker b
    _ b
    _ b
    _ b
    d' b
    _ b
    _ = a -> Plucker b
    g a
    d
        Plucker b
    _ b
    _ b
    _ b
    _ b
    e' b
    _ = a -> Plucker b
    g a
    e
        Plucker b
    _ b
    _ b
    _ b
    _ b
    _ b
    f' = a -> Plucker b
    g a
    f
      {-# INLINE (>>-) #-}

    instance Monad Plucker where
    #if !(MIN_VERSION_base(4,11,0))
      return a = Plucker a a a a a a
      {-# INLINE return #-}
    #endif
      Plucker a
    a a
    b a
    c a
    d a
    e a
    f >>= :: forall a b. Plucker a -> (a -> Plucker b) -> Plucker b
    >>= a -> Plucker b
    g = b -> b -> b -> b -> b -> b -> Plucker b
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker b
    a' b
    b' b
    c' b
    d' b
    e' b
    f' where
        Plucker b
    a' b
    _ b
    _ b
    _ b
    _ b
    _ = a -> Plucker b
    g a
    a
        Plucker b
    _ b
    b' b
    _ b
    _ b
    _ b
    _ = a -> Plucker b
    g a
    b
        Plucker b
    _ b
    _ b
    c' b
    _ b
    _ b
    _ = a -> Plucker b
    g a
    c
        Plucker b
    _ b
    _ b
    _ b
    d' b
    _ b
    _ = a -> Plucker b
    g a
    d
        Plucker b
    _ b
    _ b
    _ b
    _ b
    e' b
    _ = a -> Plucker b
    g a
    e
        Plucker b
    _ b
    _ b
    _ b
    _ b
    _ b
    f' = a -> Plucker b
    g a
    f
      {-# INLINE (>>=) #-}

    instance Distributive Plucker where
      distribute :: forall (f :: * -> *) a. Functor f => f (Plucker a) -> Plucker (f a)
    distribute f (Plucker a)
    f = f a -> f a -> f a -> f a -> f a -> f a -> Plucker (f a)
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker ((Plucker a -> a) -> f (Plucker 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 (\(Plucker a
    x a
    _ a
    _ a
    _ a
    _ a
    _) -> a
    x) f (Plucker a)
    f)
                             ((Plucker a -> a) -> f (Plucker 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 (\(Plucker a
    _ a
    x a
    _ a
    _ a
    _ a
    _) -> a
    x) f (Plucker a)
    f)
                             ((Plucker a -> a) -> f (Plucker 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 (\(Plucker a
    _ a
    _ a
    x a
    _ a
    _ a
    _) -> a
    x) f (Plucker a)
    f)
                             ((Plucker a -> a) -> f (Plucker 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 (\(Plucker a
    _ a
    _ a
    _ a
    x a
    _ a
    _) -> a
    x) f (Plucker a)
    f)
                             ((Plucker a -> a) -> f (Plucker 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 (\(Plucker a
    _ a
    _ a
    _ a
    _ a
    x a
    _) -> a
    x) f (Plucker a)
    f)
                             ((Plucker a -> a) -> f (Plucker 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 (\(Plucker a
    _ a
    _ a
    _ a
    _ a
    _ a
    x) -> a
    x) f (Plucker a)
    f)
      {-# INLINE distribute #-}

    instance Representable Plucker where
      type Rep Plucker = E Plucker
      tabulate :: forall a. (Rep Plucker -> a) -> Plucker a
    tabulate Rep Plucker -> a
    f = a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker (Rep Plucker -> a
    f Rep Plucker
    E Plucker
    e01) (Rep Plucker -> a
    f Rep Plucker
    E Plucker
    e02) (Rep Plucker -> a
    f Rep Plucker
    E Plucker
    e03) (Rep Plucker -> a
    f Rep Plucker
    E Plucker
    e23) (Rep Plucker -> a
    f Rep Plucker
    E Plucker
    e31) (Rep Plucker -> a
    f Rep Plucker
    E Plucker
    e12)
      {-# INLINE tabulate #-}
      index :: forall a. Plucker a -> Rep Plucker -> a
    index Plucker a
    xs (E forall x. Lens' (Plucker x) x
    l) = Getting a (Plucker a) a -> Plucker a -> a
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting a (Plucker a) a
    forall x. Lens' (Plucker x) x
    l Plucker a
    xs
      {-# INLINE index #-}

    instance Foldable Plucker where
      foldMap :: forall m a. Monoid m => (a -> m) -> Plucker a -> m
    foldMap a -> m
    g (Plucker a
    a a
    b a
    c a
    d a
    e a
    f) =
        a -> m
    g a
    a m -> m -> m
    forall a. Monoid a => a -> a -> a
    `mappend` a -> m
    g a
    b m -> m -> m
    forall a. Monoid a => a -> a -> a
    `mappend` a -> m
    g a
    c m -> m -> m
    forall a. Monoid a => a -> a -> a
    `mappend` a -> m
    g a
    d m -> m -> m
    forall a. Monoid a => a -> a -> a
    `mappend` a -> m
    g a
    e m -> m -> m
    forall a. Monoid a => a -> a -> a
    `mappend` a -> m
    g a
    f
      {-# INLINE foldMap #-}
      null :: forall a. Plucker a -> Bool
    null Plucker a
    _ = Bool
    False
      length :: forall a. Plucker a -> Int
    length Plucker a
    _ =  Int
    6

    instance Traversable Plucker where
      traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Plucker a -> f (Plucker b)
    traverse a -> f b
    g (Plucker a
    a a
    b a
    c a
    d a
    e a
    f) =
        b -> b -> b -> b -> b -> b -> Plucker b
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker (b -> b -> b -> b -> b -> b -> Plucker b)
    -> f b -> f (b -> b -> b -> b -> b -> Plucker b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> f b
    g a
    a f (b -> b -> b -> b -> b -> Plucker b)
    -> f b -> f (b -> b -> b -> b -> Plucker 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
    g a
    b f (b -> b -> b -> b -> Plucker b)
    -> f b -> f (b -> b -> b -> Plucker 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
    g a
    c f (b -> b -> b -> Plucker b) -> f b -> f (b -> b -> Plucker 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
    g a
    d f (b -> b -> Plucker b) -> f b -> f (b -> Plucker 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
    g a
    e f (b -> Plucker b) -> f b -> f (Plucker 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
    g a
    f
      {-# INLINE traverse #-}

    instance Foldable1 Plucker where
      foldMap1 :: forall m a. Semigroup m => (a -> m) -> Plucker a -> m
    foldMap1 a -> m
    g (Plucker a
    a a
    b a
    c a
    d a
    e a
    f) =
        a -> m
    g a
    a m -> m -> m
    forall a. Semigroup a => a -> a -> a
    <> a -> m
    g a
    b m -> m -> m
    forall a. Semigroup a => a -> a -> a
    <> a -> m
    g a
    c m -> m -> m
    forall a. Semigroup a => a -> a -> a
    <> a -> m
    g a
    d m -> m -> m
    forall a. Semigroup a => a -> a -> a
    <> a -> m
    g a
    e m -> m -> m
    forall a. Semigroup a => a -> a -> a
    <> a -> m
    g a
    f
      {-# INLINE foldMap1 #-}

    instance Traversable1 Plucker where
      traverse1 :: forall (f :: * -> *) a b.
    Apply f =>
    (a -> f b) -> Plucker a -> f (Plucker b)
    traverse1 a -> f b
    g (Plucker a
    a a
    b a
    c a
    d a
    e a
    f) =
        b -> b -> b -> b -> b -> b -> Plucker b
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker (b -> b -> b -> b -> b -> b -> Plucker b)
    -> f b -> f (b -> b -> b -> b -> b -> Plucker b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> f b
    g a
    a f (b -> b -> b -> b -> b -> Plucker b)
    -> f b -> f (b -> b -> b -> b -> Plucker 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
    g a
    b f (b -> b -> b -> b -> Plucker b)
    -> f b -> f (b -> b -> b -> Plucker 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
    g a
    c f (b -> b -> b -> Plucker b) -> f b -> f (b -> b -> Plucker 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
    g a
    d f (b -> b -> Plucker b) -> f b -> f (b -> Plucker 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
    g a
    e f (b -> Plucker b) -> f b -> f (Plucker 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
    g a
    f
      {-# INLINE traverse1 #-}

    instance Ix a => Ix (Plucker a) where
      range :: (Plucker a, Plucker a) -> [Plucker a]
    range (Plucker a
    l1 a
    l2 a
    l3 a
    l4 a
    l5 a
    l6,Plucker a
    u1 a
    u2 a
    u3 a
    u4 a
    u5 a
    u6) =
        [a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker a
    i1 a
    i2 a
    i3 a
    i4 a
    i5 a
    i6 | 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)
                         , a
    i5 <- (a, a) -> [a]
    forall a. Ix a => (a, a) -> [a]
    range (a
    l5,a
    u5)
                         , a
    i6 <- (a, a) -> [a]
    forall a. Ix a => (a, a) -> [a]
    range (a
    l6,a
    u6)
                         ]
      {-# INLINE range #-}

      unsafeIndex :: (Plucker a, Plucker a) -> Plucker a -> Int
    unsafeIndex (Plucker a
    l1 a
    l2 a
    l3 a
    l4 a
    l5 a
    l6,Plucker a
    u1 a
    u2 a
    u3 a
    u4 a
    u5 a
    u6) (Plucker a
    i1 a
    i2 a
    i3 a
    i4 a
    i5 a
    i6) =
        (a, a) -> a -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a
    l6,a
    u6) a
    i6 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a, a) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a
    l6,a
    u6) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
        (a, a) -> a -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a
    l5,a
    u5) a
    i5 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a, a) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a
    l5,a
    u5) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
        (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 :: (Plucker a, Plucker a) -> Plucker a -> Bool
    inRange (Plucker a
    l1 a
    l2 a
    l3 a
    l4 a
    l5 a
    l6,Plucker a
    u1 a
    u2 a
    u3 a
    u4 a
    u5 a
    u6) (Plucker a
    i1 a
    i2 a
    i3 a
    i4 a
    i5 a
    i6) =
        (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 Bool -> Bool -> Bool
    &&
        (a, a) -> a -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a
    l5,a
    u5) a
    i5 Bool -> Bool -> Bool
    && (a, a) -> a -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a
    l6,a
    u6) a
    i6
      {-# INLINE inRange #-}

    instance Num a => Num (Plucker a) where
      + :: Plucker a -> Plucker a -> Plucker a
    (+) = (a -> a -> a) -> Plucker a -> Plucker a -> Plucker a
    forall a b c. (a -> b -> c) -> Plucker a -> Plucker b -> Plucker 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) -> Plucker a -> Plucker a -> Plucker a
    forall a b c. (a -> b -> c) -> Plucker a -> Plucker b -> Plucker c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 (-)
      {-# INLINE (-) #-}
      * :: Plucker a -> Plucker a -> Plucker a
    (*) = (a -> a -> a) -> Plucker a -> Plucker a -> Plucker a
    forall a b c. (a -> b -> c) -> Plucker a -> Plucker b -> Plucker 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 :: Plucker a -> Plucker a
    negate = (a -> a) -> Plucker a -> Plucker a
    forall a b. (a -> b) -> Plucker a -> Plucker 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 :: Plucker a -> Plucker a
    abs = (a -> a) -> Plucker a -> Plucker a
    forall a b. (a -> b) -> Plucker a -> Plucker 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 :: Plucker a -> Plucker a
    signum = (a -> a) -> Plucker a -> Plucker a
    forall a b. (a -> b) -> Plucker a -> Plucker 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 -> Plucker a
    fromInteger = a -> Plucker a
    forall a. a -> Plucker a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (a -> Plucker a) -> (Integer -> a) -> Integer -> Plucker 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 (Plucker a) where
      recip :: Plucker a -> Plucker a
    recip = (a -> a) -> Plucker a -> Plucker a
    forall a b. (a -> b) -> Plucker a -> Plucker 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 #-}
      / :: Plucker a -> Plucker a -> Plucker a
    (/) = (a -> a -> a) -> Plucker a -> Plucker a -> Plucker a
    forall a b c. (a -> b -> c) -> Plucker a -> Plucker b -> Plucker 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 -> Plucker a
    fromRational = a -> Plucker a
    forall a. a -> Plucker a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (a -> Plucker a) -> (Rational -> a) -> Rational -> Plucker 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 (Plucker a) where
        pi :: Plucker a
    pi = a -> Plucker a
    forall a. a -> Plucker a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure a
    forall a. Floating a => a
    pi
        {-# INLINE pi #-}
        exp :: Plucker a -> Plucker a
    exp = (a -> a) -> Plucker a -> Plucker a
    forall a b. (a -> b) -> Plucker a -> Plucker 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 :: Plucker a -> Plucker a
    sqrt = (a -> a) -> Plucker a -> Plucker a
    forall a b. (a -> b) -> Plucker a -> Plucker 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 :: Plucker a -> Plucker a
    log = (a -> a) -> Plucker a -> Plucker a
    forall a b. (a -> b) -> Plucker a -> Plucker 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 #-}
        ** :: Plucker a -> Plucker a -> Plucker a
    (**) = (a -> a -> a) -> Plucker a -> Plucker a -> Plucker a
    forall a b c. (a -> b -> c) -> Plucker a -> Plucker b -> Plucker 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 :: Plucker a -> Plucker a -> Plucker a
    logBase = (a -> a -> a) -> Plucker a -> Plucker a -> Plucker a
    forall a b c. (a -> b -> c) -> Plucker a -> Plucker b -> Plucker 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 :: Plucker a -> Plucker a
    sin = (a -> a) -> Plucker a -> Plucker a
    forall a b. (a -> b) -> Plucker a -> Plucker 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 :: Plucker a -> Plucker a
    tan = (a -> a) -> Plucker a -> Plucker a
    forall a b. (a -> b) -> Plucker a -> Plucker 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 :: Plucker a -> Plucker a
    cos = (a -> a) -> Plucker a -> Plucker a
    forall a b. (a -> b) -> Plucker a -> Plucker 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 :: Plucker a -> Plucker a
    asin = (a -> a) -> Plucker a -> Plucker a
    forall a b. (a -> b) -> Plucker a -> Plucker 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 :: Plucker a -> Plucker a
    atan = (a -> a) -> Plucker a -> Plucker a
    forall a b. (a -> b) -> Plucker a -> Plucker 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 :: Plucker a -> Plucker a
    acos = (a -> a) -> Plucker a -> Plucker a
    forall a b. (a -> b) -> Plucker a -> Plucker 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 :: Plucker a -> Plucker a
    sinh = (a -> a) -> Plucker a -> Plucker a
    forall a b. (a -> b) -> Plucker a -> Plucker 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 :: Plucker a -> Plucker a
    tanh = (a -> a) -> Plucker a -> Plucker a
    forall a b. (a -> b) -> Plucker a -> Plucker 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 :: Plucker a -> Plucker a
    cosh = (a -> a) -> Plucker a -> Plucker a
    forall a b. (a -> b) -> Plucker a -> Plucker 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 :: Plucker a -> Plucker a
    asinh = (a -> a) -> Plucker a -> Plucker a
    forall a b. (a -> b) -> Plucker a -> Plucker 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 :: Plucker a -> Plucker a
    atanh = (a -> a) -> Plucker a -> Plucker a
    forall a b. (a -> b) -> Plucker a -> Plucker 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 :: Plucker a -> Plucker a
    acosh = (a -> a) -> Plucker a -> Plucker a
    forall a b. (a -> b) -> Plucker a -> Plucker 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 Hashable a => Hashable (Plucker a) where
      hashWithSalt :: Int -> Plucker a -> Int
    hashWithSalt Int
    s (Plucker a
    a a
    b a
    c a
    d a
    e a
    f) = 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 Int -> a -> Int
    forall a. Hashable a => Int -> a -> Int
    `hashWithSalt` a
    c Int -> a -> Int
    forall a. Hashable a => Int -> a -> Int
    `hashWithSalt` a
    d Int -> a -> Int
    forall a. Hashable a => Int -> a -> Int
    `hashWithSalt` a
    e Int -> a -> Int
    forall a. Hashable a => Int -> a -> Int
    `hashWithSalt` a
    f
      {-# INLINE hashWithSalt #-}

    instance Storable a => Storable (Plucker a) where
      sizeOf :: Plucker a -> Int
    sizeOf Plucker a
    _ = Int
    6 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 :: Plucker a -> Int
    alignment Plucker a
    _ = a -> Int
    forall a. Storable a => a -> Int
    alignment (a
    forall a. HasCallStack => a
    undefined::a)
      {-# INLINE alignment #-}
      poke :: Ptr (Plucker a) -> Plucker a -> IO ()
    poke Ptr (Plucker a)
    ptr (Plucker a
    a a
    b a
    c a
    d a
    e a
    f) = do
        Ptr a -> a -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke Ptr a
    ptr' a
    a
        Ptr a -> Int -> a -> IO ()
    forall a. Storable a => Ptr a -> Int -> a -> IO ()
    pokeElemOff Ptr a
    ptr' Int
    1 a
    b
        Ptr a -> Int -> a -> IO ()
    forall a. Storable a => Ptr a -> Int -> a -> IO ()
    pokeElemOff Ptr a
    ptr' Int
    2 a
    c
        Ptr a -> Int -> a -> IO ()
    forall a. Storable a => Ptr a -> Int -> a -> IO ()
    pokeElemOff Ptr a
    ptr' Int
    3 a
    d
        Ptr a -> Int -> a -> IO ()
    forall a. Storable a => Ptr a -> Int -> a -> IO ()
    pokeElemOff Ptr a
    ptr' Int
    4 a
    e
        Ptr a -> Int -> a -> IO ()
    forall a. Storable a => Ptr a -> Int -> a -> IO ()
    pokeElemOff Ptr a
    ptr' Int
    5 a
    f
        where ptr' :: Ptr a
    ptr' = Ptr (Plucker a) -> Ptr a
    forall a b. Ptr a -> Ptr b
    castPtr Ptr (Plucker a)
    ptr
      {-# INLINE poke #-}
      peek :: Ptr (Plucker a) -> IO (Plucker a)
    peek Ptr (Plucker a)
    ptr = a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker (a -> a -> a -> a -> a -> a -> Plucker a)
    -> IO a -> IO (a -> a -> a -> a -> a -> Plucker 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 -> a -> a -> Plucker a)
    -> IO a -> IO (a -> a -> a -> a -> Plucker 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
                         IO (a -> a -> a -> a -> Plucker a)
    -> IO a -> IO (a -> a -> a -> Plucker 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
    2
                         IO (a -> a -> a -> Plucker a) -> IO a -> IO (a -> a -> Plucker 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
    3
                         IO (a -> a -> Plucker a) -> IO a -> IO (a -> Plucker 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
    4
                         IO (a -> Plucker a) -> IO a -> IO (Plucker 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
    5
        where ptr' :: Ptr a
    ptr' = Ptr (Plucker a) -> Ptr a
    forall a b. Ptr a -> Ptr b
    castPtr Ptr (Plucker a)
    ptr
      {-# INLINE peek #-}

    instance Metric Plucker where
      dot :: forall a. Num a => Plucker a -> Plucker a -> a
    dot (Plucker a
    a a
    b a
    c a
    d a
    e a
    f) (Plucker a
    g a
    h a
    i a
    j a
    k a
    l) = a
    aa -> a -> a
    forall a. Num a => a -> a -> a
    *a
    ga -> a -> a
    forall a. Num a => a -> a -> a
    +a
    ba -> a -> a
    forall a. Num a => a -> a -> a
    *a
    ha -> a -> a
    forall a. Num a => a -> a -> a
    +a
    ca -> a -> a
    forall a. Num a => a -> a -> a
    *a
    ia -> a -> a
    forall a. Num a => a -> a -> a
    +a
    da -> a -> a
    forall a. Num a => a -> a -> a
    *a
    ja -> a -> a
    forall a. Num a => a -> a -> a
    +a
    ea -> a -> a
    forall a. Num a => a -> a -> a
    *a
    ka -> a -> a
    forall a. Num a => a -> a -> a
    +a
    fa -> a -> a
    forall a. Num a => a -> a -> a
    *a
    l
      {-# INLINE dot #-}

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

    -- | Given a pair of points represented by homogeneous coordinates

    -- generate Plücker coordinates for the line through them, directed

    -- from the second towards the first.

    plucker :: Num a => V4 a -> V4 a -> Plucker a
    plucker :: forall a. Num a => V4 a -> V4 a -> Plucker a
    plucker (V4 a
    a a
    b a
    c a
    d)
            (V4 a
    e a
    f a
    g a
    h) =
      a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker (a
    aa -> a -> a
    forall a. Num a => a -> a -> a
    *a
    fa -> a -> a
    forall a. Num a => a -> a -> a
    -a
    ba -> a -> a
    forall a. Num a => a -> a -> a
    *a
    e)
              (a
    aa -> a -> a
    forall a. Num a => a -> a -> a
    *a
    ga -> a -> a
    forall a. Num a => a -> a -> a
    -a
    ca -> a -> a
    forall a. Num a => a -> a -> a
    *a
    e)
              (a
    ba -> a -> a
    forall a. Num a => a -> a -> a
    *a
    ga -> a -> a
    forall a. Num a => a -> a -> a
    -a
    ca -> a -> a
    forall a. Num a => a -> a -> a
    *a
    f)
              (a
    aa -> a -> a
    forall a. Num a => a -> a -> a
    *a
    ha -> a -> a
    forall a. Num a => a -> a -> a
    -a
    da -> a -> a
    forall a. Num a => a -> a -> a
    *a
    e)
              (a
    ba -> a -> a
    forall a. Num a => a -> a -> a
    *a
    ha -> a -> a
    forall a. Num a => a -> a -> a
    -a
    da -> a -> a
    forall a. Num a => a -> a -> a
    *a
    f)
              (a
    ca -> a -> a
    forall a. Num a => a -> a -> a
    *a
    ha -> a -> a
    forall a. Num a => a -> a -> a
    -a
    da -> a -> a
    forall a. Num a => a -> a -> a
    *a
    g)
    {-# INLINE plucker #-}

    -- | Given a pair of 3D points, generate Plücker coordinates for the

    -- line through them, directed from the second towards the first.

    plucker3D :: Num a => V3 a -> V3 a -> Plucker a
    plucker3D :: forall a. Num a => V3 a -> V3 a -> Plucker a
    plucker3D V3 a
    p V3 a
    q = a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker a
    a a
    b a
    c a
    d a
    e a
    f
      where V3 a
    a a
    b a
    c = V3 a
    p V3 a -> V3 a -> V3 a
    forall a. Num a => a -> a -> a
    - V3 a
    q
            V3 a
    d a
    e a
    f = V3 a
    p V3 a -> V3 a -> V3 a
    forall a. Num a => V3 a -> V3 a -> V3 a
    `cross` V3 a
    q

    -- | These elements form a basis for the Plücker space, or the Grassmanian manifold @Gr(2,V4)@.

    --

    -- @

    -- 'p01' :: 'Lens'' ('Plucker' a) a

    -- 'p02' :: 'Lens'' ('Plucker' a) a

    -- 'p03' :: 'Lens'' ('Plucker' a) a

    -- 'p23' :: 'Lens'' ('Plucker' a) a

    -- 'p31' :: 'Lens'' ('Plucker' a) a

    -- 'p12' :: 'Lens'' ('Plucker' a) a

    -- @

    p01, p02, p03, p23, p31, p12 :: Lens' (Plucker a) a
    p01 :: forall x. Lens' (Plucker x) x
    p01 a -> f a
    g (Plucker a
    a a
    b a
    c a
    d a
    e a
    f) = (\a
    a' -> a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker a
    a' a
    b a
    c a
    d a
    e a
    f) (a -> Plucker a) -> f a -> f (Plucker a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> f a
    g a
    a
    p02 :: forall x. Lens' (Plucker x) x
    p02 a -> f a
    g (Plucker a
    a a
    b a
    c a
    d a
    e a
    f) = (\a
    b' -> a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker a
    a a
    b' a
    c a
    d a
    e a
    f) (a -> Plucker a) -> f a -> f (Plucker a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> f a
    g a
    b
    p03 :: forall x. Lens' (Plucker x) x
    p03 a -> f a
    g (Plucker a
    a a
    b a
    c a
    d a
    e a
    f) = (\a
    c' -> a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker a
    a a
    b a
    c' a
    d a
    e a
    f) (a -> Plucker a) -> f a -> f (Plucker a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> f a
    g a
    c
    p23 :: forall x. Lens' (Plucker x) x
    p23 a -> f a
    g (Plucker a
    a a
    b a
    c a
    d a
    e a
    f) = (\a
    d' -> a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker a
    a a
    b a
    c a
    d' a
    e a
    f) (a -> Plucker a) -> f a -> f (Plucker a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> f a
    g a
    d
    p31 :: forall x. Lens' (Plucker x) x
    p31 a -> f a
    g (Plucker a
    a a
    b a
    c a
    d a
    e a
    f) = (\a
    e' -> a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker a
    a a
    b a
    c a
    d a
    e' a
    f) (a -> Plucker a) -> f a -> f (Plucker a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> f a
    g a
    e
    p12 :: forall x. Lens' (Plucker x) x
    p12 a -> f a
    g (Plucker a
    a a
    b a
    c a
    d a
    e a
    f) = a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker a
    a a
    b a
    c a
    d a
    e (a -> Plucker a) -> f a -> f (Plucker a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> f a
    g a
    f
    {-# INLINE p01 #-}
    {-# INLINE p02 #-}
    {-# INLINE p03 #-}
    {-# INLINE p23 #-}
    {-# INLINE p31 #-}
    {-# INLINE p12 #-}

    -- | These elements form an alternate basis for the Plücker space, or the Grassmanian manifold @Gr(2,V4)@.

    --

    -- @

    -- 'p10' :: 'Num' a => 'Lens'' ('Plucker' a) a

    -- 'p20' :: 'Num' a => 'Lens'' ('Plucker' a) a

    -- 'p30' :: 'Num' a => 'Lens'' ('Plucker' a) a

    -- 'p32' :: 'Num' a => 'Lens'' ('Plucker' a) a

    -- 'p13' :: 'Num' a => 'Lens'' ('Plucker' a) a

    -- 'p21' :: 'Num' a => 'Lens'' ('Plucker' a) a

    -- @

    p10, p20, p30, p32, p13, p21 :: (Functor f, Num a) => (a -> f a) -> Plucker a -> f (Plucker a)
    p10 :: forall (f :: * -> *) a.
    (Functor f, Num a) =>
    (a -> f a) -> Plucker a -> f (Plucker a)
    p10 = ((a -> f a) -> Plucker a -> f (Plucker a))
    -> (a -> f a) -> Plucker a -> f (Plucker a)
    forall (f :: * -> *) a r.
    (Functor f, Num a) =>
    ((a -> f a) -> r) -> (a -> f a) -> r
    anti (a -> f a) -> Plucker a -> f (Plucker a)
    forall x. Lens' (Plucker x) x
    p01
    p20 :: forall (f :: * -> *) a.
    (Functor f, Num a) =>
    (a -> f a) -> Plucker a -> f (Plucker a)
    p20 = ((a -> f a) -> Plucker a -> f (Plucker a))
    -> (a -> f a) -> Plucker a -> f (Plucker a)
    forall (f :: * -> *) a r.
    (Functor f, Num a) =>
    ((a -> f a) -> r) -> (a -> f a) -> r
    anti (a -> f a) -> Plucker a -> f (Plucker a)
    forall x. Lens' (Plucker x) x
    p02
    p30 :: forall (f :: * -> *) a.
    (Functor f, Num a) =>
    (a -> f a) -> Plucker a -> f (Plucker a)
    p30 = ((a -> f a) -> Plucker a -> f (Plucker a))
    -> (a -> f a) -> Plucker a -> f (Plucker a)
    forall (f :: * -> *) a r.
    (Functor f, Num a) =>
    ((a -> f a) -> r) -> (a -> f a) -> r
    anti (a -> f a) -> Plucker a -> f (Plucker a)
    forall x. Lens' (Plucker x) x
    p03
    p32 :: forall (f :: * -> *) a.
    (Functor f, Num a) =>
    (a -> f a) -> Plucker a -> f (Plucker a)
    p32 = ((a -> f a) -> Plucker a -> f (Plucker a))
    -> (a -> f a) -> Plucker a -> f (Plucker a)
    forall (f :: * -> *) a r.
    (Functor f, Num a) =>
    ((a -> f a) -> r) -> (a -> f a) -> r
    anti (a -> f a) -> Plucker a -> f (Plucker a)
    forall x. Lens' (Plucker x) x
    p23
    p13 :: forall (f :: * -> *) a.
    (Functor f, Num a) =>
    (a -> f a) -> Plucker a -> f (Plucker a)
    p13 = ((a -> f a) -> Plucker a -> f (Plucker a))
    -> (a -> f a) -> Plucker a -> f (Plucker a)
    forall (f :: * -> *) a r.
    (Functor f, Num a) =>
    ((a -> f a) -> r) -> (a -> f a) -> r
    anti (a -> f a) -> Plucker a -> f (Plucker a)
    forall x. Lens' (Plucker x) x
    p31
    p21 :: forall (f :: * -> *) a.
    (Functor f, Num a) =>
    (a -> f a) -> Plucker a -> f (Plucker a)
    p21 = ((a -> f a) -> Plucker a -> f (Plucker a))
    -> (a -> f a) -> Plucker a -> f (Plucker a)
    forall (f :: * -> *) a r.
    (Functor f, Num a) =>
    ((a -> f a) -> r) -> (a -> f a) -> r
    anti (a -> f a) -> Plucker a -> f (Plucker a)
    forall (f :: * -> *) a.
    (Functor f, Num a) =>
    (a -> f a) -> Plucker a -> f (Plucker a)
    p21
    {-# INLINE p10 #-}
    {-# INLINE p20 #-}
    {-# INLINE p30 #-}
    {-# INLINE p32 #-}
    {-# INLINE p13 #-}
    {-# INLINE p21 #-}

    anti :: (Functor f, Num a) => ((a -> f a) -> r) -> (a -> f a) -> r
    anti :: forall (f :: * -> *) a r.
    (Functor f, Num a) =>
    ((a -> f a) -> r) -> (a -> f a) -> r
    anti (a -> f a) -> r
    k a -> f a
    f = (a -> f a) -> r
    k ((a -> a) -> f 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 a -> a
    forall a. Num a => a -> a
    negate (f a -> f a) -> (a -> f a) -> a -> f a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> f a
    f (a -> f a) -> (a -> a) -> a -> f a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> a
    forall a. Num a => a -> a
    negate)

    e01, e02, e03, e23, e31, e12 :: E Plucker
    e01 :: E Plucker
    e01 = (forall x. Lens' (Plucker x) x) -> E Plucker
    forall (t :: * -> *). (forall x. Lens' (t x) x) -> E t
    E (x -> f x) -> Plucker x -> f (Plucker x)
    forall x. Lens' (Plucker x) x
    p01
    e02 :: E Plucker
    e02 = (forall x. Lens' (Plucker x) x) -> E Plucker
    forall (t :: * -> *). (forall x. Lens' (t x) x) -> E t
    E (x -> f x) -> Plucker x -> f (Plucker x)
    forall x. Lens' (Plucker x) x
    p02
    e03 :: E Plucker
    e03 = (forall x. Lens' (Plucker x) x) -> E Plucker
    forall (t :: * -> *). (forall x. Lens' (t x) x) -> E t
    E (x -> f x) -> Plucker x -> f (Plucker x)
    forall x. Lens' (Plucker x) x
    p03
    e23 :: E Plucker
    e23 = (forall x. Lens' (Plucker x) x) -> E Plucker
    forall (t :: * -> *). (forall x. Lens' (t x) x) -> E t
    E (x -> f x) -> Plucker x -> f (Plucker x)
    forall x. Lens' (Plucker x) x
    p23
    e31 :: E Plucker
    e31 = (forall x. Lens' (Plucker x) x) -> E Plucker
    forall (t :: * -> *). (forall x. Lens' (t x) x) -> E t
    E (x -> f x) -> Plucker x -> f (Plucker x)
    forall x. Lens' (Plucker x) x
    p31
    e12 :: E Plucker
    e12 = (forall x. Lens' (Plucker x) x) -> E Plucker
    forall (t :: * -> *). (forall x. Lens' (t x) x) -> E t
    E (x -> f x) -> Plucker x -> f (Plucker x)
    forall x. Lens' (Plucker x) x
    p12

    instance WithIndex.FunctorWithIndex (E Plucker) Plucker where
      imap :: forall a b. (E Plucker -> a -> b) -> Plucker a -> Plucker b
    imap E Plucker -> a -> b
    f (Plucker a
    a a
    b a
    c a
    d a
    e a
    g) = b -> b -> b -> b -> b -> b -> Plucker b
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker (E Plucker -> a -> b
    f E Plucker
    e01 a
    a) (E Plucker -> a -> b
    f E Plucker
    e02 a
    b) (E Plucker -> a -> b
    f E Plucker
    e03 a
    c) (E Plucker -> a -> b
    f E Plucker
    e23 a
    d) (E Plucker -> a -> b
    f E Plucker
    e31 a
    e) (E Plucker -> a -> b
    f E Plucker
    e12 a
    g)
      {-# INLINE imap #-}

    instance WithIndex.FoldableWithIndex (E Plucker) Plucker where
      ifoldMap :: forall m a. Monoid m => (E Plucker -> a -> m) -> Plucker a -> m
    ifoldMap E Plucker -> a -> m
    f (Plucker a
    a a
    b a
    c a
    d a
    e a
    g) = E Plucker -> a -> m
    f E Plucker
    e01 a
    a m -> m -> m
    forall a. Monoid a => a -> a -> a
    `mappend` E Plucker -> a -> m
    f E Plucker
    e02 a
    b m -> m -> m
    forall a. Monoid a => a -> a -> a
    `mappend` E Plucker -> a -> m
    f E Plucker
    e03 a
    c
                               m -> m -> m
    forall a. Monoid a => a -> a -> a
    `mappend` E Plucker -> a -> m
    f E Plucker
    e23 a
    d m -> m -> m
    forall a. Monoid a => a -> a -> a
    `mappend` E Plucker -> a -> m
    f E Plucker
    e31 a
    e m -> m -> m
    forall a. Monoid a => a -> a -> a
    `mappend` E Plucker -> a -> m
    f E Plucker
    e12 a
    g
      {-# INLINE ifoldMap #-}

    instance WithIndex.TraversableWithIndex (E Plucker) Plucker where
      itraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (E Plucker -> a -> f b) -> Plucker a -> f (Plucker b)
    itraverse E Plucker -> a -> f b
    f (Plucker a
    a a
    b a
    c a
    d a
    e a
    g) = b -> b -> b -> b -> b -> b -> Plucker b
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker (b -> b -> b -> b -> b -> b -> Plucker b)
    -> f b -> f (b -> b -> b -> b -> b -> Plucker b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> E Plucker -> a -> f b
    f E Plucker
    e01 a
    a f (b -> b -> b -> b -> b -> Plucker b)
    -> f b -> f (b -> b -> b -> b -> Plucker 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 Plucker -> a -> f b
    f E Plucker
    e02 a
    b f (b -> b -> b -> b -> Plucker b)
    -> f b -> f (b -> b -> b -> Plucker 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 Plucker -> a -> f b
    f E Plucker
    e03 a
    c
                                                  f (b -> b -> b -> Plucker b) -> f b -> f (b -> b -> Plucker 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 Plucker -> a -> f b
    f E Plucker
    e23 a
    d f (b -> b -> Plucker b) -> f b -> f (b -> Plucker 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 Plucker -> a -> f b
    f E Plucker
    e31 a
    e f (b -> Plucker b) -> f b -> f (Plucker 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 Plucker -> a -> f b
    f E Plucker
    e12 a
    g
      {-# INLINE itraverse #-}

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

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

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

    instance Each (Plucker a) (Plucker b) a b where
      each :: Traversal (Plucker a) (Plucker b) a b
    each = (a -> f b) -> Plucker a -> f (Plucker 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) -> Plucker a -> f (Plucker b)
    traverse
      {-# INLINE each #-}

    -- | Valid Plücker coordinates @p@ will have @'squaredError' p '==' 0@

    --

    -- That said, floating point makes a mockery of this claim, so you may want to use 'nearZero'.

    squaredError :: Num a => Plucker a -> a
    squaredError :: forall a. Num a => Plucker a -> a
    squaredError Plucker a
    v = Plucker a
    v Plucker a -> Plucker a -> a
    forall a. Num a => Plucker a -> Plucker a -> a
    >< Plucker a
    v
    {-# INLINE squaredError #-}

    -- | This isn't th actual metric because this bilinear form gives rise to an isotropic quadratic space

    infixl 5 ><
    (><) :: Num a => Plucker a -> Plucker a -> a
    Plucker a
    a a
    b a
    c a
    d a
    e a
    f >< :: forall a. Num a => Plucker a -> Plucker a -> a
    >< Plucker a
    g a
    h a
    i a
    j a
    k a
    l = a
    aa -> a -> a
    forall a. Num a => a -> a -> a
    *a
    la -> a -> a
    forall a. Num a => a -> a -> a
    -a
    ba -> a -> a
    forall a. Num a => a -> a -> a
    *a
    ka -> a -> a
    forall a. Num a => a -> a -> a
    +a
    ca -> a -> a
    forall a. Num a => a -> a -> a
    *a
    ja -> a -> a
    forall a. Num a => a -> a -> a
    +a
    da -> a -> a
    forall a. Num a => a -> a -> a
    *a
    ia -> a -> a
    forall a. Num a => a -> a -> a
    -a
    ea -> a -> a
    forall a. Num a => a -> a -> a
    *a
    ha -> a -> a
    forall a. Num a => a -> a -> a
    +a
    fa -> a -> a
    forall a. Num a => a -> a -> a
    *a
    g
    {-# INLINE (><) #-}

    -- | Checks if the line is near-isotropic (isotropic vectors in this

    -- quadratic space represent lines in real 3d space).

    isotropic :: Epsilon a => Plucker a -> Bool
    isotropic :: forall a. Epsilon a => Plucker a -> Bool
    isotropic Plucker a
    a = a -> Bool
    forall a. Epsilon a => a -> Bool
    nearZero (Plucker a
    a Plucker a -> Plucker a -> a
    forall a. Num a => Plucker a -> Plucker a -> a
    >< Plucker a
    a)
    {-# INLINE isotropic #-}

    -- | Checks if two lines intersect (or nearly intersect).

    intersects :: (Epsilon a, Ord a) => Plucker a -> Plucker a -> Bool
    intersects :: forall a. (Epsilon a, Ord a) => Plucker a -> Plucker a -> Bool
    intersects Plucker a
    a Plucker a
    b = Bool -> Bool
    not (Plucker a
    a Plucker a -> Plucker a -> Bool
    forall a. Epsilon a => Plucker a -> Plucker a -> Bool
    `parallel` Plucker a
    b) Bool -> Bool -> Bool
    && Plucker a -> Plucker a -> LinePass
    forall a. (Epsilon a, Ord a) => Plucker a -> Plucker a -> LinePass
    passes Plucker a
    a Plucker a
    b LinePass -> LinePass -> Bool
    forall a. Eq a => a -> a -> Bool
    == LinePass
    Coplanar
    -- intersects :: Epsilon a => Plucker a -> Plucker a -> Bool

    -- intersects a b = nearZero (a >< b)

    {-# INLINE intersects #-}

    -- | Describe how two lines pass each other.

    data LinePass = Coplanar
                  -- ^ The lines are coplanar (parallel or intersecting).

                  | Clockwise
                  -- ^ The lines pass each other clockwise (right-handed

                  -- screw)

                  | Counterclockwise
                  -- ^ The lines pass each other counterclockwise

                  -- (left-handed screw).

                    deriving (LinePass -> LinePass -> Bool
    (LinePass -> LinePass -> Bool)
    -> (LinePass -> LinePass -> Bool) -> Eq LinePass
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: LinePass -> LinePass -> Bool
    == :: LinePass -> LinePass -> Bool
    $c/= :: LinePass -> LinePass -> Bool
    /= :: LinePass -> LinePass -> Bool
    Eq, Int -> LinePass -> ShowS
    [LinePass] -> ShowS
    LinePass -> String
    (Int -> LinePass -> ShowS)
    -> (LinePass -> String) -> ([LinePass] -> ShowS) -> Show LinePass
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> LinePass -> ShowS
    showsPrec :: Int -> LinePass -> ShowS
    $cshow :: LinePass -> String
    show :: LinePass -> String
    $cshowList :: [LinePass] -> ShowS
    showList :: [LinePass] -> ShowS
    Show,(forall x. LinePass -> Rep LinePass x)
    -> (forall x. Rep LinePass x -> LinePass) -> Generic LinePass
    forall x. Rep LinePass x -> LinePass
    forall x. LinePass -> Rep LinePass x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. LinePass -> Rep LinePass x
    from :: forall x. LinePass -> Rep LinePass x
    $cto :: forall x. Rep LinePass x -> LinePass
    to :: forall x. Rep LinePass x -> LinePass
    Generic)

    -- | Check how two lines pass each other. @passes l1 l2@ describes

    -- @l2@ when looking down @l1@.

    passes :: (Epsilon a, Ord a) => Plucker a -> Plucker a -> LinePass
    passes :: forall a. (Epsilon a, Ord a) => Plucker a -> Plucker a -> LinePass
    passes Plucker a
    a Plucker a
    b
      | a -> Bool
    forall a. Epsilon a => a -> Bool
    nearZero a
    s = LinePass
    Coplanar
      | a
    s a -> a -> Bool
    forall a. Ord a => a -> a -> Bool
    > a
    0 = LinePass
    Counterclockwise
      | Bool
    otherwise = LinePass
    Clockwise
      where s :: a
    s = (V3 a
    u1 V3 a -> V3 a -> a
    forall a. Num a => V3 a -> V3 a -> a
    forall (f :: * -> *) a. (Metric f, Num a) => f a -> f a -> a
    `dot` V3 a
    v2) a -> a -> a
    forall a. Num a => a -> a -> a
    + (V3 a
    u2 V3 a -> V3 a -> a
    forall a. Num a => V3 a -> V3 a -> a
    forall (f :: * -> *) a. (Metric f, Num a) => f a -> f a -> a
    `dot` V3 a
    v1)
            V2 V3 a
    u1 V3 a
    v1 = Plucker a -> V2 (V3 a)
    forall a. Plucker a -> V2 (V3 a)
    toUV Plucker a
    a
            V2 V3 a
    u2 V3 a
    v2 = Plucker a -> V2 (V3 a)
    forall a. Plucker a -> V2 (V3 a)
    toUV Plucker a
    b
    {-# INLINE passes #-}

    -- | Checks if two lines are parallel.

    parallel :: Epsilon a => Plucker a -> Plucker a -> Bool
    parallel :: forall a. Epsilon a => Plucker a -> Plucker a -> Bool
    parallel Plucker a
    a Plucker a
    b = V3 a -> Bool
    forall a. Epsilon a => a -> Bool
    nearZero (V3 a -> Bool) -> V3 a -> Bool
    forall a b. (a -> b) -> a -> b
    $ V3 a
    u1 V3 a -> V3 a -> V3 a
    forall a. Num a => V3 a -> V3 a -> V3 a
    `cross` V3 a
    u2
      where V2 V3 a
    u1 V3 a
    _ = Plucker a -> V2 (V3 a)
    forall a. Plucker a -> V2 (V3 a)
    toUV Plucker a
    a
            V2 V3 a
    u2 V3 a
    _ = Plucker a -> V2 (V3 a)
    forall a. Plucker a -> V2 (V3 a)
    toUV Plucker a
    b
    {-# INLINE parallel #-}

    -- | Represent a Plücker coordinate as a pair of 3-tuples, typically

    -- denoted U and V.

    toUV :: Plucker a -> V2 (V3 a)
    toUV :: forall a. Plucker a -> V2 (V3 a)
    toUV (Plucker a
    a a
    b a
    c a
    d a
    e a
    f) = V3 a -> V3 a -> V2 (V3 a)
    forall a. a -> a -> V2 a
    V2 (a -> a -> a -> V3 a
    forall a. a -> a -> a -> V3 a
    V3 a
    a a
    b a
    c) (a -> a -> a -> V3 a
    forall a. a -> a -> a -> V3 a
    V3 a
    d a
    e a
    f)

    -- | Checks if two lines coincide in space. In other words, undirected equality.

    coincides :: (Epsilon a, Fractional a) => Plucker a -> Plucker a -> Bool
    coincides :: forall a.
    (Epsilon a, Fractional a) =>
    Plucker a -> Plucker a -> Bool
    coincides Plucker a
    p1 Plucker a
    p2 = (a -> Bool) -> Plucker a -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    Foldable.all a -> Bool
    forall a. Epsilon a => a -> Bool
    nearZero (Plucker a -> Bool) -> Plucker a -> Bool
    forall a b. (a -> b) -> a -> b
    $ (a
    s a -> Plucker a -> Plucker a
    forall (f :: * -> *) a. (Functor f, Num a) => a -> f a -> f a
    *^ Plucker a
    p2) Plucker a -> Plucker a -> Plucker a
    forall a. Num a => a -> a -> a
    - Plucker a
    p1
      where s :: a
    s = a -> (First a -> a) -> OptionCompat (First a) -> a
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe a
    1 First a -> a
    forall a. First a -> a
    getFirst (OptionCompat (First a) -> a)
    -> (Plucker (OptionCompat (First a)) -> OptionCompat (First a))
    -> Plucker (OptionCompat (First a))
    -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . OptionCompat (First a) -> OptionCompat (First a)
    forall a. OptionCompat a -> OptionCompat a
    getOptionCompat (OptionCompat (First a) -> OptionCompat (First a))
    -> (Plucker (OptionCompat (First a)) -> OptionCompat (First a))
    -> Plucker (OptionCompat (First a))
    -> OptionCompat (First a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Plucker (OptionCompat (First a)) -> OptionCompat (First a)
    forall m. Monoid m => Plucker m -> m
    forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
    fold (Plucker (OptionCompat (First a)) -> a)
    -> Plucker (OptionCompat (First a)) -> a
    forall a b. (a -> b) -> a -> b
    $ a -> a -> OptionCompat (First a)
    forall {a}.
    (Epsilon a, Fractional a) =>
    a -> a -> OptionCompat (First a)
    saveDiv (a -> a -> OptionCompat (First a))
    -> Plucker a -> Plucker (a -> OptionCompat (First a))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Plucker a
    p1 Plucker (a -> OptionCompat (First a))
    -> Plucker a -> Plucker (OptionCompat (First a))
    forall a b. Plucker (a -> b) -> Plucker a -> Plucker b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Plucker a
    p2
            saveDiv :: a -> a -> OptionCompat (First a)
    saveDiv a
    x a
    y | a -> Bool
    forall a. Epsilon a => a -> Bool
    nearZero a
    y = OptionCompat (First a) -> OptionCompat (First a)
    forall a. OptionCompat a -> OptionCompat a
    optionCompat OptionCompat (First a)
    forall a. Maybe a
    Nothing
                        | Bool
    otherwise  = OptionCompat (First a) -> OptionCompat (First a)
    forall a. OptionCompat a -> OptionCompat a
    optionCompat (OptionCompat (First a) -> OptionCompat (First a))
    -> (First a -> OptionCompat (First a))
    -> First a
    -> OptionCompat (First a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . First a -> OptionCompat (First a)
    forall a. a -> Maybe a
    Just (First a -> OptionCompat (First a))
    -> First a -> OptionCompat (First a)
    forall a b. (a -> b) -> a -> b
    $ a -> First a
    forall a. a -> First a
    First (a
    x a -> a -> a
    forall a. Fractional a => a -> a -> a
    / a
    y)
    {-# INLINABLE coincides #-}

    -- | Checks if two lines coincide in space, and have the same

    -- orientation.

    coincides' :: (Epsilon a, Fractional a, Ord a) => Plucker a -> Plucker a -> Bool
    coincides' :: forall a.
    (Epsilon a, Fractional a, Ord a) =>
    Plucker a -> Plucker a -> Bool
    coincides' Plucker a
    p1 Plucker a
    p2 = (a -> Bool) -> Plucker a -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    Foldable.all a -> Bool
    forall a. Epsilon a => a -> Bool
    nearZero ((a
    s a -> Plucker a -> Plucker a
    forall (f :: * -> *) a. (Functor f, Num a) => a -> f a -> f a
    *^ Plucker a
    p2) Plucker a -> Plucker a -> Plucker a
    forall a. Num a => a -> a -> a
    - Plucker a
    p1) Bool -> Bool -> Bool
    && a
    s a -> a -> Bool
    forall a. Ord a => a -> a -> Bool
    > a
    0
      where s :: a
    s = a -> (First a -> a) -> OptionCompat (First a) -> a
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe a
    1 First a -> a
    forall a. First a -> a
    getFirst (OptionCompat (First a) -> a)
    -> (Plucker (OptionCompat (First a)) -> OptionCompat (First a))
    -> Plucker (OptionCompat (First a))
    -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . OptionCompat (First a) -> OptionCompat (First a)
    forall a. OptionCompat a -> OptionCompat a
    getOptionCompat (OptionCompat (First a) -> OptionCompat (First a))
    -> (Plucker (OptionCompat (First a)) -> OptionCompat (First a))
    -> Plucker (OptionCompat (First a))
    -> OptionCompat (First a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Plucker (OptionCompat (First a)) -> OptionCompat (First a)
    forall m. Monoid m => Plucker m -> m
    forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
    fold (Plucker (OptionCompat (First a)) -> a)
    -> Plucker (OptionCompat (First a)) -> a
    forall a b. (a -> b) -> a -> b
    $ a -> a -> OptionCompat (First a)
    forall {a}.
    (Epsilon a, Fractional a) =>
    a -> a -> OptionCompat (First a)
    saveDiv (a -> a -> OptionCompat (First a))
    -> Plucker a -> Plucker (a -> OptionCompat (First a))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Plucker a
    p1 Plucker (a -> OptionCompat (First a))
    -> Plucker a -> Plucker (OptionCompat (First a))
    forall a b. Plucker (a -> b) -> Plucker a -> Plucker b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Plucker a
    p2
            saveDiv :: a -> a -> OptionCompat (First a)
    saveDiv a
    x a
    y | a -> Bool
    forall a. Epsilon a => a -> Bool
    nearZero a
    y = OptionCompat (First a) -> OptionCompat (First a)
    forall a. OptionCompat a -> OptionCompat a
    optionCompat OptionCompat (First a)
    forall a. Maybe a
    Nothing
                        | Bool
    otherwise  = OptionCompat (First a) -> OptionCompat (First a)
    forall a. OptionCompat a -> OptionCompat a
    optionCompat (OptionCompat (First a) -> OptionCompat (First a))
    -> (First a -> OptionCompat (First a))
    -> First a
    -> OptionCompat (First a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . First a -> OptionCompat (First a)
    forall a. a -> Maybe a
    Just (First a -> OptionCompat (First a))
    -> First a -> OptionCompat (First a)
    forall a b. (a -> b) -> a -> b
    $ a -> First a
    forall a. a -> First a
    First (a
    x a -> a -> a
    forall a. Fractional a => a -> a -> a
    / a
    y)
    {-# INLINABLE coincides' #-}

    -- The coincides and coincides' functions above require the use of a Maybe type

    -- with the following Monoid instance:

    --

    --   instance Semigroup a => Monoid (Maybe a) where ...

    --

    -- Unfortunately, Maybe has only had such an instance since base-4.11. Prior

    -- to that, its Monoid instance had an instance context of Monoid a, which is

    -- too strong. To compensate, we use CPP to define an OptionCompat type

    -- synonym, which is an alias for Maybe on recent versions of base and an alias

    -- for Data.Semigroup.Option on older versions of base. We don't want to use

    -- Option on recent versions of base, as it is deprecated.

    #if MIN_VERSION_base(4,11,0)
    type OptionCompat = Maybe

    optionCompat :: Maybe a -> OptionCompat a
    optionCompat :: forall a. OptionCompat a -> OptionCompat a
    optionCompat = Maybe a -> Maybe a
    forall a. a -> a
    id

    getOptionCompat :: OptionCompat a -> Maybe a
    getOptionCompat :: forall a. OptionCompat a -> OptionCompat a
    getOptionCompat = OptionCompat a -> OptionCompat a
    forall a. a -> a
    id
    #else
    type OptionCompat = Option

    optionCompat :: Maybe a -> OptionCompat a
    optionCompat = Option

    getOptionCompat :: OptionCompat a -> Maybe a
    getOptionCompat = getOption
    #endif

    -- | The minimum squared distance of a line from the origin.

    quadranceToOrigin :: Fractional a => Plucker a -> a
    quadranceToOrigin :: forall a. Fractional a => Plucker a -> a
    quadranceToOrigin Plucker a
    p = (V3 a
    v V3 a -> V3 a -> a
    forall a. Num a => V3 a -> V3 a -> a
    forall (f :: * -> *) a. (Metric f, Num a) => f a -> f a -> a
    `dot` V3 a
    v) a -> a -> a
    forall a. Fractional a => a -> a -> a
    / (V3 a
    u V3 a -> V3 a -> a
    forall a. Num a => V3 a -> V3 a -> a
    forall (f :: * -> *) a. (Metric f, Num a) => f a -> f a -> a
    `dot` V3 a
    u)
      where V2 V3 a
    u V3 a
    v = Plucker a -> V2 (V3 a)
    forall a. Plucker a -> V2 (V3 a)
    toUV Plucker a
    p
    {-# INLINE quadranceToOrigin #-}

    -- | The point where a line is closest to the origin.

    closestToOrigin :: Fractional a => Plucker a -> V3 a
    closestToOrigin :: forall a. Fractional a => Plucker a -> V3 a
    closestToOrigin Plucker a
    p = V4 a -> V3 a
    forall a. Fractional a => V4 a -> V3 a
    normalizePoint (V4 a -> V3 a) -> V4 a -> V3 a
    forall a b. (a -> b) -> a -> b
    $ a -> a -> a -> a -> V4 a
    forall a. a -> a -> a -> a -> V4 a
    V4 a
    x a
    y a
    z (V3 a
    u V3 a -> V3 a -> a
    forall a. Num a => V3 a -> V3 a -> a
    forall (f :: * -> *) a. (Metric f, Num a) => f a -> f a -> a
    `dot` V3 a
    u)
      where V2 V3 a
    u V3 a
    v = Plucker a -> V2 (V3 a)
    forall a. Plucker a -> V2 (V3 a)
    toUV Plucker a
    p
            V3 a
    x a
    y a
    z = V3 a
    v V3 a -> V3 a -> V3 a
    forall a. Num a => V3 a -> V3 a -> V3 a
    `cross` V3 a
    u
    {-# INLINE closestToOrigin #-}

    -- | Not all 6-dimensional points correspond to a line in 3D. This

    -- predicate tests that a Plücker coordinate lies on the Grassmann

    -- manifold, and does indeed represent a 3D line.

    isLine :: Epsilon a => Plucker a -> Bool
    isLine :: forall a. Epsilon a => Plucker a -> Bool
    isLine Plucker a
    p = a -> Bool
    forall a. Epsilon a => a -> Bool
    nearZero (a -> Bool) -> a -> Bool
    forall a b. (a -> b) -> a -> b
    $ V3 a
    u V3 a -> V3 a -> a
    forall a. Num a => V3 a -> V3 a -> a
    forall (f :: * -> *) a. (Metric f, Num a) => f a -> f a -> a
    `dot` V3 a
    v
      where V2 V3 a
    u V3 a
    v = Plucker a -> V2 (V3 a)
    forall a. Plucker a -> V2 (V3 a)
    toUV Plucker a
    p
    {-# INLINE isLine #-}

    -- TODO: drag some more stuff out of my thesis

    data instance U.Vector    (Plucker a) =  V_Plucker !Int (U.Vector    a)
    data instance U.MVector s (Plucker a) = MV_Plucker !Int (U.MVector s a)
    instance U.Unbox a => U.Unbox (Plucker a)

    instance U.Unbox a => M.MVector U.MVector (Plucker a) where
      basicLength :: forall s. MVector s (Plucker a) -> Int
    basicLength (MV_Plucker Int
    n MVector s a
    _) = Int
    n
      basicUnsafeSlice :: forall s.
    Int -> Int -> MVector s (Plucker a) -> MVector s (Plucker a)
    basicUnsafeSlice Int
    m Int
    n (MV_Plucker Int
    _ MVector s a
    v) = Int -> MVector s a -> MVector s (Plucker a)
    forall s a. Int -> MVector s a -> MVector s (Plucker a)
    MV_Plucker 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
    6Int -> Int -> Int
    forall a. Num a => a -> a -> a
    *Int
    m) (Int
    6Int -> Int -> Int
    forall a. Num a => a -> a -> a
    *Int
    n) MVector s a
    v)
      basicOverlaps :: forall s. MVector s (Plucker a) -> MVector s (Plucker a) -> Bool
    basicOverlaps (MV_Plucker Int
    _ MVector s a
    v) (MV_Plucker 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 (Plucker a))
    basicUnsafeNew Int
    n = (MVector s a -> MVector s (Plucker a))
    -> ST s (MVector s a) -> ST s (MVector s (Plucker a))
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Int -> MVector s a -> MVector s (Plucker a)
    forall s a. Int -> MVector s a -> MVector s (Plucker a)
    MV_Plucker 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
    6Int -> Int -> Int
    forall a. Num a => a -> a -> a
    *Int
    n))
      basicUnsafeRead :: forall s. MVector s (Plucker a) -> Int -> ST s (Plucker a)
    basicUnsafeRead (MV_Plucker Int
    _ MVector s a
    a) Int
    i =
        do let o :: Int
    o = Int
    6Int -> 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
    a 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
    a (Int
    oInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1)
           a
    z <- 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
    a (Int
    oInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    2)
           a
    w <- 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
    a (Int
    oInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    3)
           a
    v <- 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
    a (Int
    oInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    4)
           a
    u <- 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
    a (Int
    oInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    5)
           Plucker a -> ST s (Plucker a)
    forall a. a -> ST s a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker a
    x a
    y a
    z a
    w a
    v a
    u)
      basicUnsafeWrite :: forall s. MVector s (Plucker a) -> Int -> Plucker a -> ST s ()
    basicUnsafeWrite (MV_Plucker Int
    _ MVector s a
    a) Int
    i (Plucker a
    x a
    y a
    z a
    w a
    v a
    u) =
        do let o :: Int
    o = Int
    6Int -> 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
    a 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
    a (Int
    oInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1) a
    y
           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
    a (Int
    oInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    2) a
    z
           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
    a (Int
    oInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    3) a
    w
           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
    a (Int
    oInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    4) a
    v
           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
    a (Int
    oInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    5) a
    u
      basicInitialize :: forall s. MVector s (Plucker a) -> ST s ()
    basicInitialize (MV_Plucker 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

    instance U.Unbox a => G.Vector U.Vector (Plucker a) where
      basicUnsafeFreeze :: forall s. Mutable Vector s (Plucker a) -> ST s (Vector (Plucker a))
    basicUnsafeFreeze (MV_Plucker Int
    n MVector s a
    v) = (Vector a -> Vector (Plucker a))
    -> ST s (Vector a) -> ST s (Vector (Plucker a))
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM ( Int -> Vector a -> Vector (Plucker a)
    forall a. Int -> Vector a -> Vector (Plucker a)
    V_Plucker 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 (Plucker a) -> ST s (Mutable Vector s (Plucker a))
    basicUnsafeThaw   ( V_Plucker Int
    n Vector a
    v) = (MVector s a -> MVector s (Plucker a))
    -> ST s (MVector s a) -> ST s (MVector s (Plucker a))
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Int -> MVector s a -> MVector s (Plucker a)
    forall s a. Int -> MVector s a -> MVector s (Plucker a)
    MV_Plucker 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 (Plucker a) -> Int
    basicLength       ( V_Plucker Int
    n Vector a
    _) = Int
    n
      basicUnsafeSlice :: Int -> Int -> Vector (Plucker a) -> Vector (Plucker a)
    basicUnsafeSlice Int
    m Int
    n (V_Plucker Int
    _ Vector a
    v) = Int -> Vector a -> Vector (Plucker a)
    forall a. Int -> Vector a -> Vector (Plucker a)
    V_Plucker Int
    n (Int -> Int -> Vector a -> Vector a
    forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
    G.basicUnsafeSlice (Int
    6Int -> Int -> Int
    forall a. Num a => a -> a -> a
    *Int
    m) (Int
    6Int -> Int -> Int
    forall a. Num a => a -> a -> a
    *Int
    n) Vector a
    v)
      basicUnsafeIndexM :: Vector (Plucker a) -> Int -> Box (Plucker a)
    basicUnsafeIndexM (V_Plucker Int
    _ Vector a
    a) Int
    i =
        do let o :: Int
    o = Int
    6Int -> 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
    a Int
    o
           a
    y <- Vector a -> Int -> Box a
    forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
    G.basicUnsafeIndexM Vector a
    a (Int
    oInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1)
           a
    z <- Vector a -> Int -> Box a
    forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
    G.basicUnsafeIndexM Vector a
    a (Int
    oInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    2)
           a
    w <- Vector a -> Int -> Box a
    forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
    G.basicUnsafeIndexM Vector a
    a (Int
    oInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    3)
           a
    v <- Vector a -> Int -> Box a
    forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
    G.basicUnsafeIndexM Vector a
    a (Int
    oInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    4)
           a
    u <- Vector a -> Int -> Box a
    forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
    G.basicUnsafeIndexM Vector a
    a (Int
    oInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    5)
           Plucker a -> Box (Plucker a)
    forall a. a -> Box a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker a
    x a
    y a
    z a
    w a
    v a
    u)

    instance MonadZip Plucker where
      mzipWith :: forall a b c. (a -> b -> c) -> Plucker a -> Plucker b -> Plucker c
    mzipWith = (a -> b -> c) -> Plucker a -> Plucker b -> Plucker c
    forall a b c. (a -> b -> c) -> Plucker a -> Plucker b -> Plucker c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2

    instance MonadFix Plucker where
      mfix :: forall a. (a -> Plucker a) -> Plucker a
    mfix a -> Plucker a
    f = a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker (let Plucker a
    a a
    _ a
    _ a
    _ a
    _ a
    _ = a -> Plucker a
    f a
    a in a
    a)
                       (let Plucker a
    _ a
    a a
    _ a
    _ a
    _ a
    _ = a -> Plucker a
    f a
    a in a
    a)
                       (let Plucker a
    _ a
    _ a
    a a
    _ a
    _ a
    _ = a -> Plucker a
    f a
    a in a
    a)
                       (let Plucker a
    _ a
    _ a
    _ a
    a a
    _ a
    _ = a -> Plucker a
    f a
    a in a
    a)
                       (let Plucker a
    _ a
    _ a
    _ a
    _ a
    a a
    _ = a -> Plucker a
    f a
    a in a
    a)
                       (let Plucker a
    _ a
    _ a
    _ a
    _ a
    _ a
    a = a -> Plucker a
    f a
    a in a
    a)

    instance NFData a => NFData (Plucker a) where
      rnf :: Plucker a -> ()
    rnf (Plucker a
    a a
    b a
    c a
    d a
    e a
    f) = 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 () -> () -> ()
    forall a b. a -> b -> b
    `seq` a -> ()
    forall a. NFData a => a -> ()
    rnf a
    c
                            () -> () -> ()
    forall a b. a -> b -> b
    `seq` a -> ()
    forall a. NFData a => a -> ()
    rnf a
    d () -> () -> ()
    forall a b. a -> b -> b
    `seq` a -> ()
    forall a. NFData a => a -> ()
    rnf a
    e () -> () -> ()
    forall a b. a -> b -> b
    `seq` a -> ()
    forall a. NFData a => a -> ()
    rnf a
    f

    instance Serial1 Plucker where
      serializeWith :: forall (m :: * -> *) a.
    MonadPut m =>
    (a -> m ()) -> Plucker a -> m ()
    serializeWith = (a -> m ()) -> Plucker 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 (Plucker a)
    deserializeWith m a
    k = a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker (a -> a -> a -> a -> a -> a -> Plucker a)
    -> m a -> m (a -> a -> a -> a -> a -> Plucker a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m a
    k m (a -> a -> a -> a -> a -> Plucker a)
    -> m a -> m (a -> a -> a -> a -> Plucker 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 m (a -> a -> a -> a -> Plucker a)
    -> m a -> m (a -> a -> a -> Plucker 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 m (a -> a -> a -> Plucker a) -> m a -> m (a -> a -> Plucker 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 m (a -> a -> Plucker a) -> m a -> m (a -> Plucker 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 m (a -> Plucker a) -> m a -> m (Plucker 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 (Plucker a) where
      serialize :: forall (m :: * -> *). MonadPut m => Plucker a -> m ()
    serialize = (a -> m ()) -> Plucker a -> m ()
    forall (f :: * -> *) (m :: * -> *) a.
    (Serial1 f, MonadPut m) =>
    (a -> m ()) -> f a -> m ()
    forall (m :: * -> *) a.
    MonadPut m =>
    (a -> m ()) -> Plucker 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 (Plucker a)
    deserialize = m a -> m (Plucker a)
    forall (f :: * -> *) (m :: * -> *) a.
    (Serial1 f, MonadGet m) =>
    m a -> m (f a)
    forall (m :: * -> *) a. MonadGet m => m a -> m (Plucker a)
    deserializeWith m a
    forall a (m :: * -> *). (Serial a, MonadGet m) => m a
    forall (m :: * -> *). MonadGet m => m a
    deserialize

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

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

    instance Eq1 Plucker where
      liftEq :: forall a b. (a -> b -> Bool) -> Plucker a -> Plucker b -> Bool
    liftEq a -> b -> Bool
    k (Plucker a
    a1 a
    b1 a
    c1 a
    d1 a
    e1 a
    f1)
               (Plucker b
    a2 b
    b2 b
    c2 b
    d2 b
    e2 b
    f2)
             = a -> b -> Bool
    k a
    a1 b
    a2 Bool -> Bool -> Bool
    && a -> b -> Bool
    k a
    b1 b
    b2 Bool -> Bool -> Bool
    && a -> b -> Bool
    k a
    c1 b
    c2 Bool -> Bool -> Bool
    && a -> b -> Bool
    k a
    d1 b
    d2 Bool -> Bool -> Bool
    && a -> b -> Bool
    k a
    e1 b
    e2 Bool -> Bool -> Bool
    && a -> b -> Bool
    k a
    f1 b
    f2
    instance Ord1 Plucker where
      liftCompare :: forall a b.
    (a -> b -> Ordering) -> Plucker a -> Plucker b -> Ordering
    liftCompare a -> b -> Ordering
    k (Plucker a
    a1 a
    b1 a
    c1 a
    d1 a
    e1 a
    f1)
                    (Plucker b
    a2 b
    b2 b
    c2 b
    d2 b
    e2 b
    f2)
                = a -> b -> Ordering
    k a
    a1 b
    a2 Ordering -> Ordering -> Ordering
    forall a. Monoid a => a -> a -> a
    `mappend` a -> b -> Ordering
    k a
    b1 b
    b2 Ordering -> Ordering -> Ordering
    forall a. Monoid a => a -> a -> a
    `mappend` a -> b -> Ordering
    k a
    c1 b
    c2 Ordering -> Ordering -> Ordering
    forall a. Monoid a => a -> a -> a
    `mappend` a -> b -> Ordering
    k a
    d1 b
    d2 Ordering -> Ordering -> Ordering
    forall a. Monoid a => a -> a -> a
    `mappend` a -> b -> Ordering
    k a
    e1 b
    e2 Ordering -> Ordering -> Ordering
    forall a. Monoid a => a -> a -> a
    `mappend` a -> b -> Ordering
    k a
    f1 b
    f2
    instance Read1 Plucker where
      liftReadsPrec :: forall a. (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Plucker a)
    liftReadsPrec Int -> ReadS a
    k ReadS [a]
    _ Int
    z = Bool -> ReadS (Plucker a) -> ReadS (Plucker a)
    forall a. Bool -> ReadS a -> ReadS a
    readParen (Int
    z Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    10) (ReadS (Plucker a) -> ReadS (Plucker a))
    -> ReadS (Plucker a) -> ReadS (Plucker a)
    forall a b. (a -> b) -> a -> b
    $ \String
    r ->
         [ (a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker a
    a a
    b a
    c a
    d a
    e a
    f, String
    r7)
         | (String
    "Plucker",String
    r1) <- ReadS String
    lex String
    r
         , (a
    a,String
    r2) <- Int -> ReadS a
    k Int
    11 String
    r1
         , (a
    b,String
    r3) <- Int -> ReadS a
    k Int
    11 String
    r2
         , (a
    c,String
    r4) <- Int -> ReadS a
    k Int
    11 String
    r3
         , (a
    d,String
    r5) <- Int -> ReadS a
    k Int
    11 String
    r4
         , (a
    e,String
    r6) <- Int -> ReadS a
    k Int
    11 String
    r5
         , (a
    f,String
    r7) <- Int -> ReadS a
    k Int
    11 String
    r6
         ]
    instance Show1 Plucker where
      liftShowsPrec :: forall a.
    (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Plucker a -> ShowS
    liftShowsPrec Int -> a -> ShowS
    k [a] -> ShowS
    _ Int
    z (Plucker a
    a a
    b a
    c a
    d a
    e a
    f) = Bool -> ShowS -> ShowS
    showParen (Int
    z Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    10) (ShowS -> ShowS) -> ShowS -> ShowS
    forall a b. (a -> b) -> a -> b
    $
         String -> ShowS
    showString String
    "Plucker " ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> a -> ShowS
    k Int
    11 a
    a ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> ShowS
    showChar Char
    ' ' ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> a -> ShowS
    k Int
    11 a
    b ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> ShowS
    showChar Char
    ' ' ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> a -> ShowS
    k Int
    11 a
    c ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> ShowS
    showChar Char
    ' ' ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> a -> ShowS
    k Int
    11 a
    d ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> ShowS
    showChar Char
    ' ' ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> a -> ShowS
    k Int
    11 a
    e ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> ShowS
    showChar Char
    ' ' ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> a -> ShowS
    k Int
    11 a
    f

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

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

    instance Field3 (Plucker a) (Plucker a) a a where
      _3 :: Lens (Plucker a) (Plucker a) a a
    _3 a -> f a
    f (Plucker a
    x a
    y a
    z a
    u a
    v a
    w) = a -> f a
    f a
    z f a -> (a -> Plucker a) -> f (Plucker a)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \a
    z' -> a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker a
    x a
    y a
    z' a
    u a
    v a
    w

    instance Field4 (Plucker a) (Plucker a) a a where
      _4 :: Lens (Plucker a) (Plucker a) a a
    _4 a -> f a
    f (Plucker a
    x a
    y a
    z a
    u a
    v a
    w) = a -> f a
    f a
    u f a -> (a -> Plucker a) -> f (Plucker a)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \a
    u' -> a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker a
    x a
    y a
    z a
    u' a
    v a
    w

    instance Field5 (Plucker a) (Plucker a) a a where
      _5 :: Lens (Plucker a) (Plucker a) a a
    _5 a -> f a
    f (Plucker a
    x a
    y a
    z a
    u a
    v a
    w) = a -> f a
    f a
    v f a -> (a -> Plucker a) -> f (Plucker a)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \a
    v' -> a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker a
    x a
    y a
    z a
    u a
    v' a
    w

    instance Field6 (Plucker a) (Plucker a) a a where
      _6 :: Lens (Plucker a) (Plucker a) a a
    _6 a -> f a
    f (Plucker a
    x a
    y a
    z a
    u a
    v a
    w) = a -> f a
    f a
    w f a -> (a -> Plucker a) -> f (Plucker a)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \a
    w' -> a -> a -> a -> a -> a -> a -> Plucker a
    forall a. a -> a -> a -> a -> a -> a -> Plucker a
    Plucker a
    x a
    y a
    z a
    u a
    v a
    w'

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