-- |
-- Module      : Data.Simplex.Abstract
-- Copyright   : (c) Justus Sagemüller 2018
-- License     : GPL v3
-- 
-- Maintainer  : (@) jsagemue $ uni-koeln.de
-- Stability   : experimental
-- Portability : portable
-- 

{-# LANGUAGE TypeFamilies             #-}
{-# LANGUAGE StandaloneDeriving       #-}
{-# LANGUAGE DeriveFunctor            #-}
{-# LANGUAGE DeriveFoldable           #-}
{-# LANGUAGE DeriveTraversable        #-}
{-# LANGUAGE UndecidableInstances     #-}
{-# LANGUAGE FlexibleContexts         #-}
{-# LANGUAGE FlexibleInstances        #-}
{-# LANGUAGE ConstraintKinds          #-}

module Data.Simplex.Abstract where

import Data.Manifold.Types.Primitive
import Math.Manifold.Core.PseudoAffine
import Data.Manifold.PseudoAffine

import Math.LinearMap.Category (spanVariance, dualNorm', (<$|), (<.>^), SimpleSpace)
import Data.VectorSpace (VectorSpace, Scalar)

import Data.Foldable (toList)
import Data.Traversable (Traversable)

import GHC.Generics

data family AbstractSimplex v x

data instance AbstractSimplex ℝ⁰ x = ℝ⁰Simplex !x
 deriving (a -> AbstractSimplex ℝ⁰ b -> AbstractSimplex ℝ⁰ a
(a -> b) -> AbstractSimplex ℝ⁰ a -> AbstractSimplex ℝ⁰ b
(forall a b.
 (a -> b) -> AbstractSimplex ℝ⁰ a -> AbstractSimplex ℝ⁰ b)
-> (forall a b. a -> AbstractSimplex ℝ⁰ b -> AbstractSimplex ℝ⁰ a)
-> Functor (AbstractSimplex ℝ⁰)
forall a b. a -> AbstractSimplex ℝ⁰ b -> AbstractSimplex ℝ⁰ a
forall a b.
(a -> b) -> AbstractSimplex ℝ⁰ a -> AbstractSimplex ℝ⁰ b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> AbstractSimplex ℝ⁰ b -> AbstractSimplex ℝ⁰ a
$c<$ :: forall a b. a -> AbstractSimplex ℝ⁰ b -> AbstractSimplex ℝ⁰ a
fmap :: (a -> b) -> AbstractSimplex ℝ⁰ a -> AbstractSimplex ℝ⁰ b
$cfmap :: forall a b.
(a -> b) -> AbstractSimplex ℝ⁰ a -> AbstractSimplex ℝ⁰ b
Functor, AbstractSimplex ℝ⁰ a -> Bool
(a -> m) -> AbstractSimplex ℝ⁰ a -> m
(a -> b -> b) -> b -> AbstractSimplex ℝ⁰ a -> b
(forall m. Monoid m => AbstractSimplex ℝ⁰ m -> m)
-> (forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ⁰ a -> m)
-> (forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ⁰ a -> m)
-> (forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ⁰ a -> b)
-> (forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ⁰ a -> b)
-> (forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ⁰ a -> b)
-> (forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ⁰ a -> b)
-> (forall a. (a -> a -> a) -> AbstractSimplex ℝ⁰ a -> a)
-> (forall a. (a -> a -> a) -> AbstractSimplex ℝ⁰ a -> a)
-> (forall a. AbstractSimplex ℝ⁰ a -> [a])
-> (forall a. AbstractSimplex ℝ⁰ a -> Bool)
-> (forall a. AbstractSimplex ℝ⁰ a -> Int)
-> (forall a. Eq a => a -> AbstractSimplex ℝ⁰ a -> Bool)
-> (forall a. Ord a => AbstractSimplex ℝ⁰ a -> a)
-> (forall a. Ord a => AbstractSimplex ℝ⁰ a -> a)
-> (forall a. Num a => AbstractSimplex ℝ⁰ a -> a)
-> (forall a. Num a => AbstractSimplex ℝ⁰ a -> a)
-> Foldable (AbstractSimplex ℝ⁰)
forall a. Eq a => a -> AbstractSimplex ℝ⁰ a -> Bool
forall a. Num a => AbstractSimplex ℝ⁰ a -> a
forall a. Ord a => AbstractSimplex ℝ⁰ a -> a
forall m. Monoid m => AbstractSimplex ℝ⁰ m -> m
forall a. AbstractSimplex ℝ⁰ a -> Bool
forall a. AbstractSimplex ℝ⁰ a -> Int
forall a. AbstractSimplex ℝ⁰ a -> [a]
forall a. (a -> a -> a) -> AbstractSimplex ℝ⁰ a -> a
forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ⁰ a -> m
forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ⁰ a -> b
forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ⁰ a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: AbstractSimplex ℝ⁰ a -> a
$cproduct :: forall a. Num a => AbstractSimplex ℝ⁰ a -> a
sum :: AbstractSimplex ℝ⁰ a -> a
$csum :: forall a. Num a => AbstractSimplex ℝ⁰ a -> a
minimum :: AbstractSimplex ℝ⁰ a -> a
$cminimum :: forall a. Ord a => AbstractSimplex ℝ⁰ a -> a
maximum :: AbstractSimplex ℝ⁰ a -> a
$cmaximum :: forall a. Ord a => AbstractSimplex ℝ⁰ a -> a
elem :: a -> AbstractSimplex ℝ⁰ a -> Bool
$celem :: forall a. Eq a => a -> AbstractSimplex ℝ⁰ a -> Bool
length :: AbstractSimplex ℝ⁰ a -> Int
$clength :: forall a. AbstractSimplex ℝ⁰ a -> Int
null :: AbstractSimplex ℝ⁰ a -> Bool
$cnull :: forall a. AbstractSimplex ℝ⁰ a -> Bool
toList :: AbstractSimplex ℝ⁰ a -> [a]
$ctoList :: forall a. AbstractSimplex ℝ⁰ a -> [a]
foldl1 :: (a -> a -> a) -> AbstractSimplex ℝ⁰ a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> AbstractSimplex ℝ⁰ a -> a
foldr1 :: (a -> a -> a) -> AbstractSimplex ℝ⁰ a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> AbstractSimplex ℝ⁰ a -> a
foldl' :: (b -> a -> b) -> b -> AbstractSimplex ℝ⁰ a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ⁰ a -> b
foldl :: (b -> a -> b) -> b -> AbstractSimplex ℝ⁰ a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ⁰ a -> b
foldr' :: (a -> b -> b) -> b -> AbstractSimplex ℝ⁰ a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ⁰ a -> b
foldr :: (a -> b -> b) -> b -> AbstractSimplex ℝ⁰ a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ⁰ a -> b
foldMap' :: (a -> m) -> AbstractSimplex ℝ⁰ a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ⁰ a -> m
foldMap :: (a -> m) -> AbstractSimplex ℝ⁰ a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ⁰ a -> m
fold :: AbstractSimplex ℝ⁰ m -> m
$cfold :: forall m. Monoid m => AbstractSimplex ℝ⁰ m -> m
Foldable, Functor (AbstractSimplex ℝ⁰)
Foldable (AbstractSimplex ℝ⁰)
Functor (AbstractSimplex ℝ⁰)
-> Foldable (AbstractSimplex ℝ⁰)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> AbstractSimplex ℝ⁰ a -> f (AbstractSimplex ℝ⁰ b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    AbstractSimplex ℝ⁰ (f a) -> f (AbstractSimplex ℝ⁰ a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> AbstractSimplex ℝ⁰ a -> m (AbstractSimplex ℝ⁰ b))
-> (forall (m :: * -> *) a.
    Monad m =>
    AbstractSimplex ℝ⁰ (m a) -> m (AbstractSimplex ℝ⁰ a))
-> Traversable (AbstractSimplex ℝ⁰)
(a -> f b) -> AbstractSimplex ℝ⁰ a -> f (AbstractSimplex ℝ⁰ b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
AbstractSimplex ℝ⁰ (m a) -> m (AbstractSimplex ℝ⁰ a)
forall (f :: * -> *) a.
Applicative f =>
AbstractSimplex ℝ⁰ (f a) -> f (AbstractSimplex ℝ⁰ a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AbstractSimplex ℝ⁰ a -> m (AbstractSimplex ℝ⁰ b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AbstractSimplex ℝ⁰ a -> f (AbstractSimplex ℝ⁰ b)
sequence :: AbstractSimplex ℝ⁰ (m a) -> m (AbstractSimplex ℝ⁰ a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
AbstractSimplex ℝ⁰ (m a) -> m (AbstractSimplex ℝ⁰ a)
mapM :: (a -> m b) -> AbstractSimplex ℝ⁰ a -> m (AbstractSimplex ℝ⁰ b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AbstractSimplex ℝ⁰ a -> m (AbstractSimplex ℝ⁰ b)
sequenceA :: AbstractSimplex ℝ⁰ (f a) -> f (AbstractSimplex ℝ⁰ a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
AbstractSimplex ℝ⁰ (f a) -> f (AbstractSimplex ℝ⁰ a)
traverse :: (a -> f b) -> AbstractSimplex ℝ⁰ a -> f (AbstractSimplex ℝ⁰ b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AbstractSimplex ℝ⁰ a -> f (AbstractSimplex ℝ⁰ b)
$cp2Traversable :: Foldable (AbstractSimplex ℝ⁰)
$cp1Traversable :: Functor (AbstractSimplex ℝ⁰)
Traversable)
instance Applicative (AbstractSimplex ℝ⁰) where
  pure :: a -> AbstractSimplex ℝ⁰ a
pure = a -> AbstractSimplex ℝ⁰ a
forall a. a -> AbstractSimplex ℝ⁰ a
ℝ⁰Simplex
  ℝ⁰Simplex p <*> :: AbstractSimplex ℝ⁰ (a -> b)
-> AbstractSimplex ℝ⁰ a -> AbstractSimplex ℝ⁰ b
<*> ℝ⁰Simplex q = b -> AbstractSimplex ℝ⁰ b
forall a. a -> AbstractSimplex ℝ⁰ a
ℝ⁰Simplex (b -> AbstractSimplex ℝ⁰ b) -> b -> AbstractSimplex ℝ⁰ b
forall a b. (a -> b) -> a -> b
$ a -> b
p a
q

data instance AbstractSimplex ℝ  x = ℝSimplex !x !x
 deriving (a -> AbstractSimplex ℝ b -> AbstractSimplex ℝ a
(a -> b) -> AbstractSimplex ℝ a -> AbstractSimplex ℝ b
(forall a b.
 (a -> b) -> AbstractSimplex ℝ a -> AbstractSimplex ℝ b)
-> (forall a b. a -> AbstractSimplex ℝ b -> AbstractSimplex ℝ a)
-> Functor (AbstractSimplex ℝ)
forall a b. a -> AbstractSimplex ℝ b -> AbstractSimplex ℝ a
forall a b. (a -> b) -> AbstractSimplex ℝ a -> AbstractSimplex ℝ b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> AbstractSimplex ℝ b -> AbstractSimplex ℝ a
$c<$ :: forall a b. a -> AbstractSimplex ℝ b -> AbstractSimplex ℝ a
fmap :: (a -> b) -> AbstractSimplex ℝ a -> AbstractSimplex ℝ b
$cfmap :: forall a b. (a -> b) -> AbstractSimplex ℝ a -> AbstractSimplex ℝ b
Functor, AbstractSimplex ℝ a -> Bool
(a -> m) -> AbstractSimplex ℝ a -> m
(a -> b -> b) -> b -> AbstractSimplex ℝ a -> b
(forall m. Monoid m => AbstractSimplex ℝ m -> m)
-> (forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ a -> m)
-> (forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ a -> m)
-> (forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ a -> b)
-> (forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ a -> b)
-> (forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ a -> b)
-> (forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ a -> b)
-> (forall a. (a -> a -> a) -> AbstractSimplex ℝ a -> a)
-> (forall a. (a -> a -> a) -> AbstractSimplex ℝ a -> a)
-> (forall a. AbstractSimplex ℝ a -> [a])
-> (forall a. AbstractSimplex ℝ a -> Bool)
-> (forall a. AbstractSimplex ℝ a -> Int)
-> (forall a. Eq a => a -> AbstractSimplex ℝ a -> Bool)
-> (forall a. Ord a => AbstractSimplex ℝ a -> a)
-> (forall a. Ord a => AbstractSimplex ℝ a -> a)
-> (forall a. Num a => AbstractSimplex ℝ a -> a)
-> (forall a. Num a => AbstractSimplex ℝ a -> a)
-> Foldable (AbstractSimplex ℝ)
forall a. Eq a => a -> AbstractSimplex ℝ a -> Bool
forall a. Num a => AbstractSimplex ℝ a -> a
forall a. Ord a => AbstractSimplex ℝ a -> a
forall m. Monoid m => AbstractSimplex ℝ m -> m
forall a. AbstractSimplex ℝ a -> Bool
forall a. AbstractSimplex ℝ a -> Int
forall a. AbstractSimplex ℝ a -> [a]
forall a. (a -> a -> a) -> AbstractSimplex ℝ a -> a
forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ a -> m
forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ a -> b
forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: AbstractSimplex ℝ a -> a
$cproduct :: forall a. Num a => AbstractSimplex ℝ a -> a
sum :: AbstractSimplex ℝ a -> a
$csum :: forall a. Num a => AbstractSimplex ℝ a -> a
minimum :: AbstractSimplex ℝ a -> a
$cminimum :: forall a. Ord a => AbstractSimplex ℝ a -> a
maximum :: AbstractSimplex ℝ a -> a
$cmaximum :: forall a. Ord a => AbstractSimplex ℝ a -> a
elem :: a -> AbstractSimplex ℝ a -> Bool
$celem :: forall a. Eq a => a -> AbstractSimplex ℝ a -> Bool
length :: AbstractSimplex ℝ a -> Int
$clength :: forall a. AbstractSimplex ℝ a -> Int
null :: AbstractSimplex ℝ a -> Bool
$cnull :: forall a. AbstractSimplex ℝ a -> Bool
toList :: AbstractSimplex ℝ a -> [a]
$ctoList :: forall a. AbstractSimplex ℝ a -> [a]
foldl1 :: (a -> a -> a) -> AbstractSimplex ℝ a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> AbstractSimplex ℝ a -> a
foldr1 :: (a -> a -> a) -> AbstractSimplex ℝ a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> AbstractSimplex ℝ a -> a
foldl' :: (b -> a -> b) -> b -> AbstractSimplex ℝ a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ a -> b
foldl :: (b -> a -> b) -> b -> AbstractSimplex ℝ a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ a -> b
foldr' :: (a -> b -> b) -> b -> AbstractSimplex ℝ a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ a -> b
foldr :: (a -> b -> b) -> b -> AbstractSimplex ℝ a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ a -> b
foldMap' :: (a -> m) -> AbstractSimplex ℝ a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ a -> m
foldMap :: (a -> m) -> AbstractSimplex ℝ a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ a -> m
fold :: AbstractSimplex ℝ m -> m
$cfold :: forall m. Monoid m => AbstractSimplex ℝ m -> m
Foldable, Functor (AbstractSimplex ℝ)
Foldable (AbstractSimplex ℝ)
Functor (AbstractSimplex ℝ)
-> Foldable (AbstractSimplex ℝ)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> AbstractSimplex ℝ a -> f (AbstractSimplex ℝ b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    AbstractSimplex ℝ (f a) -> f (AbstractSimplex ℝ a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> AbstractSimplex ℝ a -> m (AbstractSimplex ℝ b))
-> (forall (m :: * -> *) a.
    Monad m =>
    AbstractSimplex ℝ (m a) -> m (AbstractSimplex ℝ a))
-> Traversable (AbstractSimplex ℝ)
(a -> f b) -> AbstractSimplex ℝ a -> f (AbstractSimplex ℝ b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
AbstractSimplex ℝ (m a) -> m (AbstractSimplex ℝ a)
forall (f :: * -> *) a.
Applicative f =>
AbstractSimplex ℝ (f a) -> f (AbstractSimplex ℝ a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AbstractSimplex ℝ a -> m (AbstractSimplex ℝ b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AbstractSimplex ℝ a -> f (AbstractSimplex ℝ b)
sequence :: AbstractSimplex ℝ (m a) -> m (AbstractSimplex ℝ a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
AbstractSimplex ℝ (m a) -> m (AbstractSimplex ℝ a)
mapM :: (a -> m b) -> AbstractSimplex ℝ a -> m (AbstractSimplex ℝ b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AbstractSimplex ℝ a -> m (AbstractSimplex ℝ b)
sequenceA :: AbstractSimplex ℝ (f a) -> f (AbstractSimplex ℝ a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
AbstractSimplex ℝ (f a) -> f (AbstractSimplex ℝ a)
traverse :: (a -> f b) -> AbstractSimplex ℝ a -> f (AbstractSimplex ℝ b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AbstractSimplex ℝ a -> f (AbstractSimplex ℝ b)
$cp2Traversable :: Foldable (AbstractSimplex ℝ)
$cp1Traversable :: Functor (AbstractSimplex ℝ)
Traversable)
data instance AbstractSimplex ℝ¹ x = ℝ¹Simplex !x !x
 deriving (a -> AbstractSimplex ℝ¹ b -> AbstractSimplex ℝ¹ a
(a -> b) -> AbstractSimplex ℝ¹ a -> AbstractSimplex ℝ¹ b
(forall a b.
 (a -> b) -> AbstractSimplex ℝ¹ a -> AbstractSimplex ℝ¹ b)
-> (forall a b. a -> AbstractSimplex ℝ¹ b -> AbstractSimplex ℝ¹ a)
-> Functor (AbstractSimplex ℝ¹)
forall a b. a -> AbstractSimplex ℝ¹ b -> AbstractSimplex ℝ¹ a
forall a b.
(a -> b) -> AbstractSimplex ℝ¹ a -> AbstractSimplex ℝ¹ b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> AbstractSimplex ℝ¹ b -> AbstractSimplex ℝ¹ a
$c<$ :: forall a b. a -> AbstractSimplex ℝ¹ b -> AbstractSimplex ℝ¹ a
fmap :: (a -> b) -> AbstractSimplex ℝ¹ a -> AbstractSimplex ℝ¹ b
$cfmap :: forall a b.
(a -> b) -> AbstractSimplex ℝ¹ a -> AbstractSimplex ℝ¹ b
Functor, AbstractSimplex ℝ¹ a -> Bool
(a -> m) -> AbstractSimplex ℝ¹ a -> m
(a -> b -> b) -> b -> AbstractSimplex ℝ¹ a -> b
(forall m. Monoid m => AbstractSimplex ℝ¹ m -> m)
-> (forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ¹ a -> m)
-> (forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ¹ a -> m)
-> (forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ¹ a -> b)
-> (forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ¹ a -> b)
-> (forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ¹ a -> b)
-> (forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ¹ a -> b)
-> (forall a. (a -> a -> a) -> AbstractSimplex ℝ¹ a -> a)
-> (forall a. (a -> a -> a) -> AbstractSimplex ℝ¹ a -> a)
-> (forall a. AbstractSimplex ℝ¹ a -> [a])
-> (forall a. AbstractSimplex ℝ¹ a -> Bool)
-> (forall a. AbstractSimplex ℝ¹ a -> Int)
-> (forall a. Eq a => a -> AbstractSimplex ℝ¹ a -> Bool)
-> (forall a. Ord a => AbstractSimplex ℝ¹ a -> a)
-> (forall a. Ord a => AbstractSimplex ℝ¹ a -> a)
-> (forall a. Num a => AbstractSimplex ℝ¹ a -> a)
-> (forall a. Num a => AbstractSimplex ℝ¹ a -> a)
-> Foldable (AbstractSimplex ℝ¹)
forall a. Eq a => a -> AbstractSimplex ℝ¹ a -> Bool
forall a. Num a => AbstractSimplex ℝ¹ a -> a
forall a. Ord a => AbstractSimplex ℝ¹ a -> a
forall m. Monoid m => AbstractSimplex ℝ¹ m -> m
forall a. AbstractSimplex ℝ¹ a -> Bool
forall a. AbstractSimplex ℝ¹ a -> Int
forall a. AbstractSimplex ℝ¹ a -> [a]
forall a. (a -> a -> a) -> AbstractSimplex ℝ¹ a -> a
forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ¹ a -> m
forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ¹ a -> b
forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ¹ a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: AbstractSimplex ℝ¹ a -> a
$cproduct :: forall a. Num a => AbstractSimplex ℝ¹ a -> a
sum :: AbstractSimplex ℝ¹ a -> a
$csum :: forall a. Num a => AbstractSimplex ℝ¹ a -> a
minimum :: AbstractSimplex ℝ¹ a -> a
$cminimum :: forall a. Ord a => AbstractSimplex ℝ¹ a -> a
maximum :: AbstractSimplex ℝ¹ a -> a
$cmaximum :: forall a. Ord a => AbstractSimplex ℝ¹ a -> a
elem :: a -> AbstractSimplex ℝ¹ a -> Bool
$celem :: forall a. Eq a => a -> AbstractSimplex ℝ¹ a -> Bool
length :: AbstractSimplex ℝ¹ a -> Int
$clength :: forall a. AbstractSimplex ℝ¹ a -> Int
null :: AbstractSimplex ℝ¹ a -> Bool
$cnull :: forall a. AbstractSimplex ℝ¹ a -> Bool
toList :: AbstractSimplex ℝ¹ a -> [a]
$ctoList :: forall a. AbstractSimplex ℝ¹ a -> [a]
foldl1 :: (a -> a -> a) -> AbstractSimplex ℝ¹ a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> AbstractSimplex ℝ¹ a -> a
foldr1 :: (a -> a -> a) -> AbstractSimplex ℝ¹ a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> AbstractSimplex ℝ¹ a -> a
foldl' :: (b -> a -> b) -> b -> AbstractSimplex ℝ¹ a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ¹ a -> b
foldl :: (b -> a -> b) -> b -> AbstractSimplex ℝ¹ a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ¹ a -> b
foldr' :: (a -> b -> b) -> b -> AbstractSimplex ℝ¹ a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ¹ a -> b
foldr :: (a -> b -> b) -> b -> AbstractSimplex ℝ¹ a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ¹ a -> b
foldMap' :: (a -> m) -> AbstractSimplex ℝ¹ a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ¹ a -> m
foldMap :: (a -> m) -> AbstractSimplex ℝ¹ a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ¹ a -> m
fold :: AbstractSimplex ℝ¹ m -> m
$cfold :: forall m. Monoid m => AbstractSimplex ℝ¹ m -> m
Foldable, Functor (AbstractSimplex ℝ¹)
Foldable (AbstractSimplex ℝ¹)
Functor (AbstractSimplex ℝ¹)
-> Foldable (AbstractSimplex ℝ¹)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> AbstractSimplex ℝ¹ a -> f (AbstractSimplex ℝ¹ b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    AbstractSimplex ℝ¹ (f a) -> f (AbstractSimplex ℝ¹ a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> AbstractSimplex ℝ¹ a -> m (AbstractSimplex ℝ¹ b))
-> (forall (m :: * -> *) a.
    Monad m =>
    AbstractSimplex ℝ¹ (m a) -> m (AbstractSimplex ℝ¹ a))
-> Traversable (AbstractSimplex ℝ¹)
(a -> f b) -> AbstractSimplex ℝ¹ a -> f (AbstractSimplex ℝ¹ b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
AbstractSimplex ℝ¹ (m a) -> m (AbstractSimplex ℝ¹ a)
forall (f :: * -> *) a.
Applicative f =>
AbstractSimplex ℝ¹ (f a) -> f (AbstractSimplex ℝ¹ a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AbstractSimplex ℝ¹ a -> m (AbstractSimplex ℝ¹ b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AbstractSimplex ℝ¹ a -> f (AbstractSimplex ℝ¹ b)
sequence :: AbstractSimplex ℝ¹ (m a) -> m (AbstractSimplex ℝ¹ a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
AbstractSimplex ℝ¹ (m a) -> m (AbstractSimplex ℝ¹ a)
mapM :: (a -> m b) -> AbstractSimplex ℝ¹ a -> m (AbstractSimplex ℝ¹ b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AbstractSimplex ℝ¹ a -> m (AbstractSimplex ℝ¹ b)
sequenceA :: AbstractSimplex ℝ¹ (f a) -> f (AbstractSimplex ℝ¹ a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
AbstractSimplex ℝ¹ (f a) -> f (AbstractSimplex ℝ¹ a)
traverse :: (a -> f b) -> AbstractSimplex ℝ¹ a -> f (AbstractSimplex ℝ¹ b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AbstractSimplex ℝ¹ a -> f (AbstractSimplex ℝ¹ b)
$cp2Traversable :: Foldable (AbstractSimplex ℝ¹)
$cp1Traversable :: Functor (AbstractSimplex ℝ¹)
Traversable)

data instance AbstractSimplex ℝ² x = ℝ²Simplex !x !x !x
 deriving (a -> AbstractSimplex ℝ² b -> AbstractSimplex ℝ² a
(a -> b) -> AbstractSimplex ℝ² a -> AbstractSimplex ℝ² b
(forall a b.
 (a -> b) -> AbstractSimplex ℝ² a -> AbstractSimplex ℝ² b)
-> (forall a b. a -> AbstractSimplex ℝ² b -> AbstractSimplex ℝ² a)
-> Functor (AbstractSimplex ℝ²)
forall a b. a -> AbstractSimplex ℝ² b -> AbstractSimplex ℝ² a
forall a b.
(a -> b) -> AbstractSimplex ℝ² a -> AbstractSimplex ℝ² b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> AbstractSimplex ℝ² b -> AbstractSimplex ℝ² a
$c<$ :: forall a b. a -> AbstractSimplex ℝ² b -> AbstractSimplex ℝ² a
fmap :: (a -> b) -> AbstractSimplex ℝ² a -> AbstractSimplex ℝ² b
$cfmap :: forall a b.
(a -> b) -> AbstractSimplex ℝ² a -> AbstractSimplex ℝ² b
Functor, AbstractSimplex ℝ² a -> Bool
(a -> m) -> AbstractSimplex ℝ² a -> m
(a -> b -> b) -> b -> AbstractSimplex ℝ² a -> b
(forall m. Monoid m => AbstractSimplex ℝ² m -> m)
-> (forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ² a -> m)
-> (forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ² a -> m)
-> (forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ² a -> b)
-> (forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ² a -> b)
-> (forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ² a -> b)
-> (forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ² a -> b)
-> (forall a. (a -> a -> a) -> AbstractSimplex ℝ² a -> a)
-> (forall a. (a -> a -> a) -> AbstractSimplex ℝ² a -> a)
-> (forall a. AbstractSimplex ℝ² a -> [a])
-> (forall a. AbstractSimplex ℝ² a -> Bool)
-> (forall a. AbstractSimplex ℝ² a -> Int)
-> (forall a. Eq a => a -> AbstractSimplex ℝ² a -> Bool)
-> (forall a. Ord a => AbstractSimplex ℝ² a -> a)
-> (forall a. Ord a => AbstractSimplex ℝ² a -> a)
-> (forall a. Num a => AbstractSimplex ℝ² a -> a)
-> (forall a. Num a => AbstractSimplex ℝ² a -> a)
-> Foldable (AbstractSimplex ℝ²)
forall a. Eq a => a -> AbstractSimplex ℝ² a -> Bool
forall a. Num a => AbstractSimplex ℝ² a -> a
forall a. Ord a => AbstractSimplex ℝ² a -> a
forall m. Monoid m => AbstractSimplex ℝ² m -> m
forall a. AbstractSimplex ℝ² a -> Bool
forall a. AbstractSimplex ℝ² a -> Int
forall a. AbstractSimplex ℝ² a -> [a]
forall a. (a -> a -> a) -> AbstractSimplex ℝ² a -> a
forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ² a -> m
forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ² a -> b
forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ² a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: AbstractSimplex ℝ² a -> a
$cproduct :: forall a. Num a => AbstractSimplex ℝ² a -> a
sum :: AbstractSimplex ℝ² a -> a
$csum :: forall a. Num a => AbstractSimplex ℝ² a -> a
minimum :: AbstractSimplex ℝ² a -> a
$cminimum :: forall a. Ord a => AbstractSimplex ℝ² a -> a
maximum :: AbstractSimplex ℝ² a -> a
$cmaximum :: forall a. Ord a => AbstractSimplex ℝ² a -> a
elem :: a -> AbstractSimplex ℝ² a -> Bool
$celem :: forall a. Eq a => a -> AbstractSimplex ℝ² a -> Bool
length :: AbstractSimplex ℝ² a -> Int
$clength :: forall a. AbstractSimplex ℝ² a -> Int
null :: AbstractSimplex ℝ² a -> Bool
$cnull :: forall a. AbstractSimplex ℝ² a -> Bool
toList :: AbstractSimplex ℝ² a -> [a]
$ctoList :: forall a. AbstractSimplex ℝ² a -> [a]
foldl1 :: (a -> a -> a) -> AbstractSimplex ℝ² a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> AbstractSimplex ℝ² a -> a
foldr1 :: (a -> a -> a) -> AbstractSimplex ℝ² a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> AbstractSimplex ℝ² a -> a
foldl' :: (b -> a -> b) -> b -> AbstractSimplex ℝ² a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ² a -> b
foldl :: (b -> a -> b) -> b -> AbstractSimplex ℝ² a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ² a -> b
foldr' :: (a -> b -> b) -> b -> AbstractSimplex ℝ² a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ² a -> b
foldr :: (a -> b -> b) -> b -> AbstractSimplex ℝ² a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ² a -> b
foldMap' :: (a -> m) -> AbstractSimplex ℝ² a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ² a -> m
foldMap :: (a -> m) -> AbstractSimplex ℝ² a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ² a -> m
fold :: AbstractSimplex ℝ² m -> m
$cfold :: forall m. Monoid m => AbstractSimplex ℝ² m -> m
Foldable, Functor (AbstractSimplex ℝ²)
Foldable (AbstractSimplex ℝ²)
Functor (AbstractSimplex ℝ²)
-> Foldable (AbstractSimplex ℝ²)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> AbstractSimplex ℝ² a -> f (AbstractSimplex ℝ² b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    AbstractSimplex ℝ² (f a) -> f (AbstractSimplex ℝ² a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> AbstractSimplex ℝ² a -> m (AbstractSimplex ℝ² b))
-> (forall (m :: * -> *) a.
    Monad m =>
    AbstractSimplex ℝ² (m a) -> m (AbstractSimplex ℝ² a))
-> Traversable (AbstractSimplex ℝ²)
(a -> f b) -> AbstractSimplex ℝ² a -> f (AbstractSimplex ℝ² b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
AbstractSimplex ℝ² (m a) -> m (AbstractSimplex ℝ² a)
forall (f :: * -> *) a.
Applicative f =>
AbstractSimplex ℝ² (f a) -> f (AbstractSimplex ℝ² a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AbstractSimplex ℝ² a -> m (AbstractSimplex ℝ² b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AbstractSimplex ℝ² a -> f (AbstractSimplex ℝ² b)
sequence :: AbstractSimplex ℝ² (m a) -> m (AbstractSimplex ℝ² a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
AbstractSimplex ℝ² (m a) -> m (AbstractSimplex ℝ² a)
mapM :: (a -> m b) -> AbstractSimplex ℝ² a -> m (AbstractSimplex ℝ² b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AbstractSimplex ℝ² a -> m (AbstractSimplex ℝ² b)
sequenceA :: AbstractSimplex ℝ² (f a) -> f (AbstractSimplex ℝ² a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
AbstractSimplex ℝ² (f a) -> f (AbstractSimplex ℝ² a)
traverse :: (a -> f b) -> AbstractSimplex ℝ² a -> f (AbstractSimplex ℝ² b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AbstractSimplex ℝ² a -> f (AbstractSimplex ℝ² b)
$cp2Traversable :: Foldable (AbstractSimplex ℝ²)
$cp1Traversable :: Functor (AbstractSimplex ℝ²)
Traversable)

data instance AbstractSimplex ℝ³ x = ℝ³Simplex !x !x !x !x
 deriving (a -> AbstractSimplex ℝ³ b -> AbstractSimplex ℝ³ a
(a -> b) -> AbstractSimplex ℝ³ a -> AbstractSimplex ℝ³ b
(forall a b.
 (a -> b) -> AbstractSimplex ℝ³ a -> AbstractSimplex ℝ³ b)
-> (forall a b. a -> AbstractSimplex ℝ³ b -> AbstractSimplex ℝ³ a)
-> Functor (AbstractSimplex ℝ³)
forall a b. a -> AbstractSimplex ℝ³ b -> AbstractSimplex ℝ³ a
forall a b.
(a -> b) -> AbstractSimplex ℝ³ a -> AbstractSimplex ℝ³ b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> AbstractSimplex ℝ³ b -> AbstractSimplex ℝ³ a
$c<$ :: forall a b. a -> AbstractSimplex ℝ³ b -> AbstractSimplex ℝ³ a
fmap :: (a -> b) -> AbstractSimplex ℝ³ a -> AbstractSimplex ℝ³ b
$cfmap :: forall a b.
(a -> b) -> AbstractSimplex ℝ³ a -> AbstractSimplex ℝ³ b
Functor, AbstractSimplex ℝ³ a -> Bool
(a -> m) -> AbstractSimplex ℝ³ a -> m
(a -> b -> b) -> b -> AbstractSimplex ℝ³ a -> b
(forall m. Monoid m => AbstractSimplex ℝ³ m -> m)
-> (forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ³ a -> m)
-> (forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ³ a -> m)
-> (forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ³ a -> b)
-> (forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ³ a -> b)
-> (forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ³ a -> b)
-> (forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ³ a -> b)
-> (forall a. (a -> a -> a) -> AbstractSimplex ℝ³ a -> a)
-> (forall a. (a -> a -> a) -> AbstractSimplex ℝ³ a -> a)
-> (forall a. AbstractSimplex ℝ³ a -> [a])
-> (forall a. AbstractSimplex ℝ³ a -> Bool)
-> (forall a. AbstractSimplex ℝ³ a -> Int)
-> (forall a. Eq a => a -> AbstractSimplex ℝ³ a -> Bool)
-> (forall a. Ord a => AbstractSimplex ℝ³ a -> a)
-> (forall a. Ord a => AbstractSimplex ℝ³ a -> a)
-> (forall a. Num a => AbstractSimplex ℝ³ a -> a)
-> (forall a. Num a => AbstractSimplex ℝ³ a -> a)
-> Foldable (AbstractSimplex ℝ³)
forall a. Eq a => a -> AbstractSimplex ℝ³ a -> Bool
forall a. Num a => AbstractSimplex ℝ³ a -> a
forall a. Ord a => AbstractSimplex ℝ³ a -> a
forall m. Monoid m => AbstractSimplex ℝ³ m -> m
forall a. AbstractSimplex ℝ³ a -> Bool
forall a. AbstractSimplex ℝ³ a -> Int
forall a. AbstractSimplex ℝ³ a -> [a]
forall a. (a -> a -> a) -> AbstractSimplex ℝ³ a -> a
forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ³ a -> m
forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ³ a -> b
forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ³ a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: AbstractSimplex ℝ³ a -> a
$cproduct :: forall a. Num a => AbstractSimplex ℝ³ a -> a
sum :: AbstractSimplex ℝ³ a -> a
$csum :: forall a. Num a => AbstractSimplex ℝ³ a -> a
minimum :: AbstractSimplex ℝ³ a -> a
$cminimum :: forall a. Ord a => AbstractSimplex ℝ³ a -> a
maximum :: AbstractSimplex ℝ³ a -> a
$cmaximum :: forall a. Ord a => AbstractSimplex ℝ³ a -> a
elem :: a -> AbstractSimplex ℝ³ a -> Bool
$celem :: forall a. Eq a => a -> AbstractSimplex ℝ³ a -> Bool
length :: AbstractSimplex ℝ³ a -> Int
$clength :: forall a. AbstractSimplex ℝ³ a -> Int
null :: AbstractSimplex ℝ³ a -> Bool
$cnull :: forall a. AbstractSimplex ℝ³ a -> Bool
toList :: AbstractSimplex ℝ³ a -> [a]
$ctoList :: forall a. AbstractSimplex ℝ³ a -> [a]
foldl1 :: (a -> a -> a) -> AbstractSimplex ℝ³ a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> AbstractSimplex ℝ³ a -> a
foldr1 :: (a -> a -> a) -> AbstractSimplex ℝ³ a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> AbstractSimplex ℝ³ a -> a
foldl' :: (b -> a -> b) -> b -> AbstractSimplex ℝ³ a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ³ a -> b
foldl :: (b -> a -> b) -> b -> AbstractSimplex ℝ³ a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ³ a -> b
foldr' :: (a -> b -> b) -> b -> AbstractSimplex ℝ³ a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ³ a -> b
foldr :: (a -> b -> b) -> b -> AbstractSimplex ℝ³ a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ³ a -> b
foldMap' :: (a -> m) -> AbstractSimplex ℝ³ a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ³ a -> m
foldMap :: (a -> m) -> AbstractSimplex ℝ³ a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ³ a -> m
fold :: AbstractSimplex ℝ³ m -> m
$cfold :: forall m. Monoid m => AbstractSimplex ℝ³ m -> m
Foldable, Functor (AbstractSimplex ℝ³)
Foldable (AbstractSimplex ℝ³)
Functor (AbstractSimplex ℝ³)
-> Foldable (AbstractSimplex ℝ³)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> AbstractSimplex ℝ³ a -> f (AbstractSimplex ℝ³ b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    AbstractSimplex ℝ³ (f a) -> f (AbstractSimplex ℝ³ a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> AbstractSimplex ℝ³ a -> m (AbstractSimplex ℝ³ b))
-> (forall (m :: * -> *) a.
    Monad m =>
    AbstractSimplex ℝ³ (m a) -> m (AbstractSimplex ℝ³ a))
-> Traversable (AbstractSimplex ℝ³)
(a -> f b) -> AbstractSimplex ℝ³ a -> f (AbstractSimplex ℝ³ b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
AbstractSimplex ℝ³ (m a) -> m (AbstractSimplex ℝ³ a)
forall (f :: * -> *) a.
Applicative f =>
AbstractSimplex ℝ³ (f a) -> f (AbstractSimplex ℝ³ a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AbstractSimplex ℝ³ a -> m (AbstractSimplex ℝ³ b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AbstractSimplex ℝ³ a -> f (AbstractSimplex ℝ³ b)
sequence :: AbstractSimplex ℝ³ (m a) -> m (AbstractSimplex ℝ³ a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
AbstractSimplex ℝ³ (m a) -> m (AbstractSimplex ℝ³ a)
mapM :: (a -> m b) -> AbstractSimplex ℝ³ a -> m (AbstractSimplex ℝ³ b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AbstractSimplex ℝ³ a -> m (AbstractSimplex ℝ³ b)
sequenceA :: AbstractSimplex ℝ³ (f a) -> f (AbstractSimplex ℝ³ a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
AbstractSimplex ℝ³ (f a) -> f (AbstractSimplex ℝ³ a)
traverse :: (a -> f b) -> AbstractSimplex ℝ³ a -> f (AbstractSimplex ℝ³ b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AbstractSimplex ℝ³ a -> f (AbstractSimplex ℝ³ b)
$cp2Traversable :: Foldable (AbstractSimplex ℝ³)
$cp1Traversable :: Functor (AbstractSimplex ℝ³)
Traversable)

data instance AbstractSimplex ℝ⁴ x = ℝ⁴Simplex !x !x !x !x !x
 deriving (a -> AbstractSimplex ℝ⁴ b -> AbstractSimplex ℝ⁴ a
(a -> b) -> AbstractSimplex ℝ⁴ a -> AbstractSimplex ℝ⁴ b
(forall a b.
 (a -> b) -> AbstractSimplex ℝ⁴ a -> AbstractSimplex ℝ⁴ b)
-> (forall a b. a -> AbstractSimplex ℝ⁴ b -> AbstractSimplex ℝ⁴ a)
-> Functor (AbstractSimplex ℝ⁴)
forall a b. a -> AbstractSimplex ℝ⁴ b -> AbstractSimplex ℝ⁴ a
forall a b.
(a -> b) -> AbstractSimplex ℝ⁴ a -> AbstractSimplex ℝ⁴ b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> AbstractSimplex ℝ⁴ b -> AbstractSimplex ℝ⁴ a
$c<$ :: forall a b. a -> AbstractSimplex ℝ⁴ b -> AbstractSimplex ℝ⁴ a
fmap :: (a -> b) -> AbstractSimplex ℝ⁴ a -> AbstractSimplex ℝ⁴ b
$cfmap :: forall a b.
(a -> b) -> AbstractSimplex ℝ⁴ a -> AbstractSimplex ℝ⁴ b
Functor, AbstractSimplex ℝ⁴ a -> Bool
(a -> m) -> AbstractSimplex ℝ⁴ a -> m
(a -> b -> b) -> b -> AbstractSimplex ℝ⁴ a -> b
(forall m. Monoid m => AbstractSimplex ℝ⁴ m -> m)
-> (forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ⁴ a -> m)
-> (forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ⁴ a -> m)
-> (forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ⁴ a -> b)
-> (forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ⁴ a -> b)
-> (forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ⁴ a -> b)
-> (forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ⁴ a -> b)
-> (forall a. (a -> a -> a) -> AbstractSimplex ℝ⁴ a -> a)
-> (forall a. (a -> a -> a) -> AbstractSimplex ℝ⁴ a -> a)
-> (forall a. AbstractSimplex ℝ⁴ a -> [a])
-> (forall a. AbstractSimplex ℝ⁴ a -> Bool)
-> (forall a. AbstractSimplex ℝ⁴ a -> Int)
-> (forall a. Eq a => a -> AbstractSimplex ℝ⁴ a -> Bool)
-> (forall a. Ord a => AbstractSimplex ℝ⁴ a -> a)
-> (forall a. Ord a => AbstractSimplex ℝ⁴ a -> a)
-> (forall a. Num a => AbstractSimplex ℝ⁴ a -> a)
-> (forall a. Num a => AbstractSimplex ℝ⁴ a -> a)
-> Foldable (AbstractSimplex ℝ⁴)
forall a. Eq a => a -> AbstractSimplex ℝ⁴ a -> Bool
forall a. Num a => AbstractSimplex ℝ⁴ a -> a
forall a. Ord a => AbstractSimplex ℝ⁴ a -> a
forall m. Monoid m => AbstractSimplex ℝ⁴ m -> m
forall a. AbstractSimplex ℝ⁴ a -> Bool
forall a. AbstractSimplex ℝ⁴ a -> Int
forall a. AbstractSimplex ℝ⁴ a -> [a]
forall a. (a -> a -> a) -> AbstractSimplex ℝ⁴ a -> a
forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ⁴ a -> m
forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ⁴ a -> b
forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ⁴ a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: AbstractSimplex ℝ⁴ a -> a
$cproduct :: forall a. Num a => AbstractSimplex ℝ⁴ a -> a
sum :: AbstractSimplex ℝ⁴ a -> a
$csum :: forall a. Num a => AbstractSimplex ℝ⁴ a -> a
minimum :: AbstractSimplex ℝ⁴ a -> a
$cminimum :: forall a. Ord a => AbstractSimplex ℝ⁴ a -> a
maximum :: AbstractSimplex ℝ⁴ a -> a
$cmaximum :: forall a. Ord a => AbstractSimplex ℝ⁴ a -> a
elem :: a -> AbstractSimplex ℝ⁴ a -> Bool
$celem :: forall a. Eq a => a -> AbstractSimplex ℝ⁴ a -> Bool
length :: AbstractSimplex ℝ⁴ a -> Int
$clength :: forall a. AbstractSimplex ℝ⁴ a -> Int
null :: AbstractSimplex ℝ⁴ a -> Bool
$cnull :: forall a. AbstractSimplex ℝ⁴ a -> Bool
toList :: AbstractSimplex ℝ⁴ a -> [a]
$ctoList :: forall a. AbstractSimplex ℝ⁴ a -> [a]
foldl1 :: (a -> a -> a) -> AbstractSimplex ℝ⁴ a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> AbstractSimplex ℝ⁴ a -> a
foldr1 :: (a -> a -> a) -> AbstractSimplex ℝ⁴ a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> AbstractSimplex ℝ⁴ a -> a
foldl' :: (b -> a -> b) -> b -> AbstractSimplex ℝ⁴ a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ⁴ a -> b
foldl :: (b -> a -> b) -> b -> AbstractSimplex ℝ⁴ a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ⁴ a -> b
foldr' :: (a -> b -> b) -> b -> AbstractSimplex ℝ⁴ a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ⁴ a -> b
foldr :: (a -> b -> b) -> b -> AbstractSimplex ℝ⁴ a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ⁴ a -> b
foldMap' :: (a -> m) -> AbstractSimplex ℝ⁴ a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ⁴ a -> m
foldMap :: (a -> m) -> AbstractSimplex ℝ⁴ a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ⁴ a -> m
fold :: AbstractSimplex ℝ⁴ m -> m
$cfold :: forall m. Monoid m => AbstractSimplex ℝ⁴ m -> m
Foldable, Functor (AbstractSimplex ℝ⁴)
Foldable (AbstractSimplex ℝ⁴)
Functor (AbstractSimplex ℝ⁴)
-> Foldable (AbstractSimplex ℝ⁴)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> AbstractSimplex ℝ⁴ a -> f (AbstractSimplex ℝ⁴ b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    AbstractSimplex ℝ⁴ (f a) -> f (AbstractSimplex ℝ⁴ a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> AbstractSimplex ℝ⁴ a -> m (AbstractSimplex ℝ⁴ b))
-> (forall (m :: * -> *) a.
    Monad m =>
    AbstractSimplex ℝ⁴ (m a) -> m (AbstractSimplex ℝ⁴ a))
-> Traversable (AbstractSimplex ℝ⁴)
(a -> f b) -> AbstractSimplex ℝ⁴ a -> f (AbstractSimplex ℝ⁴ b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
AbstractSimplex ℝ⁴ (m a) -> m (AbstractSimplex ℝ⁴ a)
forall (f :: * -> *) a.
Applicative f =>
AbstractSimplex ℝ⁴ (f a) -> f (AbstractSimplex ℝ⁴ a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AbstractSimplex ℝ⁴ a -> m (AbstractSimplex ℝ⁴ b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AbstractSimplex ℝ⁴ a -> f (AbstractSimplex ℝ⁴ b)
sequence :: AbstractSimplex ℝ⁴ (m a) -> m (AbstractSimplex ℝ⁴ a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
AbstractSimplex ℝ⁴ (m a) -> m (AbstractSimplex ℝ⁴ a)
mapM :: (a -> m b) -> AbstractSimplex ℝ⁴ a -> m (AbstractSimplex ℝ⁴ b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AbstractSimplex ℝ⁴ a -> m (AbstractSimplex ℝ⁴ b)
sequenceA :: AbstractSimplex ℝ⁴ (f a) -> f (AbstractSimplex ℝ⁴ a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
AbstractSimplex ℝ⁴ (f a) -> f (AbstractSimplex ℝ⁴ a)
traverse :: (a -> f b) -> AbstractSimplex ℝ⁴ a -> f (AbstractSimplex ℝ⁴ b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AbstractSimplex ℝ⁴ a -> f (AbstractSimplex ℝ⁴ b)
$cp2Traversable :: Foldable (AbstractSimplex ℝ⁴)
$cp1Traversable :: Functor (AbstractSimplex ℝ⁴)
Traversable)

data instance AbstractSimplex (ℝ, v) x = ConeSimplex !x !(AbstractSimplex v x)
deriving instance (Functor (AbstractSimplex v)) => Functor (AbstractSimplex (ℝ,v))
deriving instance (Foldable (AbstractSimplex v)) => Foldable (AbstractSimplex (ℝ,v))
deriving instance (Traversable (AbstractSimplex v)) => Traversable (AbstractSimplex (ℝ,v))

newtype instance AbstractSimplex (GenericNeedle m) x
       = GenericSimplex (AbstractSimplex (Rep m ()) x)
deriving instance (Functor (AbstractSimplex (Rep m ())))
         => Functor (AbstractSimplex (GenericNeedle m))
deriving instance (Foldable (AbstractSimplex (Rep m ())))
         => Foldable (AbstractSimplex (GenericNeedle m))
deriving instance (Traversable (AbstractSimplex (Rep m ())))
         => Traversable (AbstractSimplex (GenericNeedle m))

newtype instance AbstractSimplex (NeedleProductSpace f g p) x
         = GenProdSimplex (AbstractSimplex (Needle (f p), Needle (g p)) x)
deriving instance (Functor (AbstractSimplex (Needle (f p), Needle (g p))))
         => Functor (AbstractSimplex (NeedleProductSpace f g p))
deriving instance (Foldable (AbstractSimplex (Needle (f p), Needle (g p))))
         => Foldable (AbstractSimplex (NeedleProductSpace f g p))
deriving instance (Traversable (AbstractSimplex (Needle (f p), Needle (g p))))
         => Traversable (AbstractSimplex (NeedleProductSpace f g p))


type Simplex m = AbstractSimplex (Needle m) m
type SimplexF m y = AbstractSimplex (Needle m) (FibreBundle m y)

type SimplexSpanning m
    = ( WithField ℝ Manifold m, VectorSpace (Needle m)
      , Traversable (AbstractSimplex (Needle m)) )

seenFromOneVertex :: (WithField ℝ Manifold m, Foldable (AbstractSimplex (Needle m)))
       => Simplex m -> (m, [Needle m])
seenFromOneVertex :: Simplex m -> (m, [Needle m])
seenFromOneVertex Simplex m
s = case Simplex m -> [m]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList Simplex m
s of
      (m
p₀:[m]
ps) -> (m
p₀, [ case m
pm -> m -> Maybe (Needle m)
forall x. PseudoAffine x => x -> x -> Maybe (Needle x)
.-~.m
p₀ of
                         Just Needle m
v -> Needle m
v
                         Maybe (Needle m)
Nothing -> [Char] -> Needle m
forall a. HasCallStack => [Char] -> a
error [Char]
"A simplex must always be path-connected."
                      | m
p <- [m]
ps ])
      [] -> [Char] -> (m, [Needle m])
forall a. HasCallStack => [Char] -> a
error [Char]
"A simplex type must contain at least one value!"     

toBarycentric :: ( WithField ℝ Manifold m
                 , Foldable (AbstractSimplex (Needle m))
                 , SimpleSpace (Needle m) )
       => Simplex m -> m -> [ℝ]
toBarycentric :: Simplex m -> m -> [ℝ]
toBarycentric Simplex m
s = case Simplex m -> (m, [Needle m])
forall m.
(WithField ℝ Manifold m, Foldable (AbstractSimplex (Needle m))) =>
Simplex m -> (m, [Needle m])
seenFromOneVertex Simplex m
s of
     (m
p₀, [Needle m]
vs) -> let v's :: [DualVector (Needle m)]
v's = (Variance (Needle m) -> Norm (Needle m)
forall v. SimpleSpace v => Variance v -> Norm v
dualNorm' ([Needle m] -> Variance (Needle m)
forall v. LSpace v => [v] -> Variance v
spanVariance [Needle m]
vs)Norm (Needle m) -> Needle m -> DualVector (Needle m)
forall v. LSpace v => Norm v -> v -> DualVector v
<$|) (Needle m -> DualVector (Needle m))
-> [Needle m] -> [DualVector (Needle m)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Needle m]
vs
                 in \m
q -> case m
qm -> m -> Maybe (Needle m)
forall x. PseudoAffine x => x -> x -> Maybe (Needle x)
.-~.m
p₀ of
                           Just Needle m
w -> let vws :: [ℝ]
vws = (DualVector (Needle m) -> Needle m -> Scalar (Needle m)
forall v. LinearSpace v => DualVector v -> v -> Scalar v
<.>^Needle m
w) (DualVector (Needle m) -> ℝ) -> [DualVector (Needle m)] -> [ℝ]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [DualVector (Needle m)]
v's
                                     in (ℝ
1 ℝ -> ℝ -> ℝ
forall a. Num a => a -> a -> a
- [ℝ] -> ℝ
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [ℝ]
vws) ℝ -> [ℝ] -> [ℝ]
forall a. a -> [a] -> [a]
: [ℝ]
vws
                           Maybe (Needle m)
Nothing -> []