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

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

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

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

data instance AbstractSimplex ℝ⁴ x = ℝ⁴Simplex !x !x !x !x !x
 deriving (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
<$ :: forall a b. a -> AbstractSimplex ℝ⁴ b -> AbstractSimplex ℝ⁴ a
$c<$ :: forall a b. a -> AbstractSimplex ℝ⁴ b -> AbstractSimplex ℝ⁴ a
fmap :: forall a b.
(a -> b) -> AbstractSimplex ℝ⁴ a -> AbstractSimplex ℝ⁴ b
$cfmap :: forall a b.
(a -> b) -> AbstractSimplex ℝ⁴ a -> AbstractSimplex ℝ⁴ b
Functor, 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 :: forall a. Num a => AbstractSimplex ℝ⁴ a -> a
$cproduct :: forall a. Num a => AbstractSimplex ℝ⁴ a -> a
sum :: forall a. Num a => AbstractSimplex ℝ⁴ a -> a
$csum :: forall a. Num a => AbstractSimplex ℝ⁴ a -> a
minimum :: forall a. Ord a => AbstractSimplex ℝ⁴ a -> a
$cminimum :: forall a. Ord a => AbstractSimplex ℝ⁴ a -> a
maximum :: forall a. Ord a => AbstractSimplex ℝ⁴ a -> a
$cmaximum :: forall a. Ord a => AbstractSimplex ℝ⁴ a -> a
elem :: forall a. Eq a => a -> AbstractSimplex ℝ⁴ a -> Bool
$celem :: forall a. Eq a => a -> AbstractSimplex ℝ⁴ a -> Bool
length :: forall a. AbstractSimplex ℝ⁴ a -> Int
$clength :: forall a. AbstractSimplex ℝ⁴ a -> Int
null :: forall a. AbstractSimplex ℝ⁴ a -> Bool
$cnull :: forall a. AbstractSimplex ℝ⁴ a -> Bool
toList :: forall a. AbstractSimplex ℝ⁴ a -> [a]
$ctoList :: forall a. AbstractSimplex ℝ⁴ a -> [a]
foldl1 :: forall a. (a -> a -> a) -> AbstractSimplex ℝ⁴ a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> AbstractSimplex ℝ⁴ a -> a
foldr1 :: forall a. (a -> a -> a) -> AbstractSimplex ℝ⁴ a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> AbstractSimplex ℝ⁴ a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ⁴ a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ⁴ a -> b
foldl :: forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ⁴ a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> AbstractSimplex ℝ⁴ a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ⁴ a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ⁴ a -> b
foldr :: forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ⁴ a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> AbstractSimplex ℝ⁴ a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ⁴ a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ⁴ a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ⁴ a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> AbstractSimplex ℝ⁴ a -> m
fold :: forall m. Monoid m => AbstractSimplex ℝ⁴ m -> m
$cfold :: forall m. Monoid m => AbstractSimplex ℝ⁴ m -> m
Foldable, Functor (AbstractSimplex ℝ⁴)
Foldable (AbstractSimplex ℝ⁴)
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 :: forall (m :: * -> *) a.
Monad m =>
AbstractSimplex ℝ⁴ (m a) -> m (AbstractSimplex ℝ⁴ a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
AbstractSimplex ℝ⁴ (m a) -> m (AbstractSimplex ℝ⁴ a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AbstractSimplex ℝ⁴ a -> m (AbstractSimplex ℝ⁴ b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AbstractSimplex ℝ⁴ a -> m (AbstractSimplex ℝ⁴ b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
AbstractSimplex ℝ⁴ (f a) -> f (AbstractSimplex ℝ⁴ a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
AbstractSimplex ℝ⁴ (f a) -> f (AbstractSimplex ℝ⁴ a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AbstractSimplex ℝ⁴ a -> f (AbstractSimplex ℝ⁴ b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AbstractSimplex ℝ⁴ a -> f (AbstractSimplex ℝ⁴ b)
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 :: forall m.
(WithField ℝ Manifold m, Foldable (AbstractSimplex (Needle m))) =>
Simplex m -> (m, [Needle m])
seenFromOneVertex Simplex m
s = case forall (t :: * -> *) a. Foldable t => t a -> [a]
toList Simplex m
s of
      (m
p₀:[m]
ps) -> (m
p₀, [ case m
pforall x. PseudoAffine x => x -> x -> Maybe (Needle x)
.-~.m
p₀ of
                         Just Needle m
v -> Needle m
v
                         Maybe (Needle m)
Nothing -> forall a. HasCallStack => [Char] -> a
error [Char]
"A simplex must always be path-connected."
                      | m
p <- [m]
ps ])
      [] -> 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 :: forall m.
(WithField ℝ Manifold m, Foldable (AbstractSimplex (Needle m)),
 SimpleSpace (Needle m)) =>
Simplex m -> m -> [ℝ]
toBarycentric Simplex m
s = case 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 :: [Needle' m]
v's = (forall v. SimpleSpace v => Variance v -> Norm v
dualNorm' (forall v. LSpace v => [v] -> Variance v
spanVariance [Needle m]
vs)forall v. LSpace v => Norm v -> v -> DualVector v
<$|) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Needle m]
vs
                 in \m
q -> case m
qforall x. PseudoAffine x => x -> x -> Maybe (Needle x)
.-~.m
p₀ of
                           Just Needle m
w -> let vws :: [ℝ]
vws = (forall v. LinearSpace v => DualVector v -> v -> Scalar v
<.>^Needle m
w) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [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 -> []