manifolds-0.6.0.0: Coordinate-free hypersurfaces
Copyright(c) Justus Sagemüller 2018
LicenseGPL v3
Maintainer(@) jsagemue $ uni-koeln.de
Stabilityexperimental
Portabilityportable
Safe HaskellNone
LanguageHaskell2010

Data.Simplex.Abstract

Description

 

Documentation

data family AbstractSimplex v x Source #

Instances

Instances details
Functor (AbstractSimplex v) => Functor (AbstractSimplex (, v)) Source # 
Instance details

Defined in Data.Simplex.Abstract

Methods

fmap :: (a -> b) -> AbstractSimplex (, v) a -> AbstractSimplex (, v) b #

(<$) :: a -> AbstractSimplex (, v) b -> AbstractSimplex (, v) a #

Functor (AbstractSimplex (Needle (f p), Needle (g p))) => Functor (AbstractSimplex (NeedleProductSpace f g p)) Source # 
Instance details

Defined in Data.Simplex.Abstract

Functor (AbstractSimplex (Rep m ())) => Functor (AbstractSimplex (GenericNeedle m)) Source # 
Instance details

Defined in Data.Simplex.Abstract

Functor (AbstractSimplex ) Source # 
Instance details

Defined in Data.Simplex.Abstract

Functor (AbstractSimplex ℝ⁰) Source # 
Instance details

Defined in Data.Simplex.Abstract

Functor (AbstractSimplex ℝ⁴) Source # 
Instance details

Defined in Data.Simplex.Abstract

Functor (AbstractSimplex ℝ³) Source # 
Instance details

Defined in Data.Simplex.Abstract

Functor (AbstractSimplex ℝ²) Source # 
Instance details

Defined in Data.Simplex.Abstract

Functor (AbstractSimplex ℝ¹) Source # 
Instance details

Defined in Data.Simplex.Abstract

Applicative (AbstractSimplex ℝ⁰) Source # 
Instance details

Defined in Data.Simplex.Abstract

Foldable (AbstractSimplex v) => Foldable (AbstractSimplex (, v)) Source # 
Instance details

Defined in Data.Simplex.Abstract

Methods

fold :: Monoid m => AbstractSimplex (, v) m -> m #

foldMap :: Monoid m => (a -> m) -> AbstractSimplex (, v) a -> m #

foldMap' :: Monoid m => (a -> m) -> AbstractSimplex (, v) a -> m #

foldr :: (a -> b -> b) -> b -> AbstractSimplex (, v) a -> b #

foldr' :: (a -> b -> b) -> b -> AbstractSimplex (, v) a -> b #

foldl :: (b -> a -> b) -> b -> AbstractSimplex (, v) a -> b #

foldl' :: (b -> a -> b) -> b -> AbstractSimplex (, v) a -> b #

foldr1 :: (a -> a -> a) -> AbstractSimplex (, v) a -> a #

foldl1 :: (a -> a -> a) -> AbstractSimplex (, v) a -> a #

toList :: AbstractSimplex (, v) a -> [a] #

null :: AbstractSimplex (, v) a -> Bool #

length :: AbstractSimplex (, v) a -> Int #

elem :: Eq a => a -> AbstractSimplex (, v) a -> Bool #

maximum :: Ord a => AbstractSimplex (, v) a -> a #

minimum :: Ord a => AbstractSimplex (, v) a -> a #

sum :: Num a => AbstractSimplex (, v) a -> a #

product :: Num a => AbstractSimplex (, v) a -> a #

Foldable (AbstractSimplex (Needle (f p), Needle (g p))) => Foldable (AbstractSimplex (NeedleProductSpace f g p)) Source # 
Instance details

Defined in Data.Simplex.Abstract

Methods

fold :: Monoid m => AbstractSimplex (NeedleProductSpace f g p) m -> m #

foldMap :: Monoid m => (a -> m) -> AbstractSimplex (NeedleProductSpace f g p) a -> m #

foldMap' :: Monoid m => (a -> m) -> AbstractSimplex (NeedleProductSpace f g p) a -> m #

foldr :: (a -> b -> b) -> b -> AbstractSimplex (NeedleProductSpace f g p) a -> b #

foldr' :: (a -> b -> b) -> b -> AbstractSimplex (NeedleProductSpace f g p) a -> b #

foldl :: (b -> a -> b) -> b -> AbstractSimplex (NeedleProductSpace f g p) a -> b #

foldl' :: (b -> a -> b) -> b -> AbstractSimplex (NeedleProductSpace f g p) a -> b #

foldr1 :: (a -> a -> a) -> AbstractSimplex (NeedleProductSpace f g p) a -> a #

foldl1 :: (a -> a -> a) -> AbstractSimplex (NeedleProductSpace f g p) a -> a #

toList :: AbstractSimplex (NeedleProductSpace f g p) a -> [a] #

null :: AbstractSimplex (NeedleProductSpace f g p) a -> Bool #

length :: AbstractSimplex (NeedleProductSpace f g p) a -> Int #

elem :: Eq a => a -> AbstractSimplex (NeedleProductSpace f g p) a -> Bool #

maximum :: Ord a => AbstractSimplex (NeedleProductSpace f g p) a -> a #

minimum :: Ord a => AbstractSimplex (NeedleProductSpace f g p) a -> a #

sum :: Num a => AbstractSimplex (NeedleProductSpace f g p) a -> a #

product :: Num a => AbstractSimplex (NeedleProductSpace f g p) a -> a #

Foldable (AbstractSimplex (Rep m ())) => Foldable (AbstractSimplex (GenericNeedle m)) Source # 
Instance details

Defined in Data.Simplex.Abstract

Methods

fold :: Monoid m0 => AbstractSimplex (GenericNeedle m) m0 -> m0 #

foldMap :: Monoid m0 => (a -> m0) -> AbstractSimplex (GenericNeedle m) a -> m0 #

foldMap' :: Monoid m0 => (a -> m0) -> AbstractSimplex (GenericNeedle m) a -> m0 #

foldr :: (a -> b -> b) -> b -> AbstractSimplex (GenericNeedle m) a -> b #

foldr' :: (a -> b -> b) -> b -> AbstractSimplex (GenericNeedle m) a -> b #

foldl :: (b -> a -> b) -> b -> AbstractSimplex (GenericNeedle m) a -> b #

foldl' :: (b -> a -> b) -> b -> AbstractSimplex (GenericNeedle m) a -> b #

foldr1 :: (a -> a -> a) -> AbstractSimplex (GenericNeedle m) a -> a #

foldl1 :: (a -> a -> a) -> AbstractSimplex (GenericNeedle m) a -> a #

toList :: AbstractSimplex (GenericNeedle m) a -> [a] #

null :: AbstractSimplex (GenericNeedle m) a -> Bool #

length :: AbstractSimplex (GenericNeedle m) a -> Int #

elem :: Eq a => a -> AbstractSimplex (GenericNeedle m) a -> Bool #

maximum :: Ord a => AbstractSimplex (GenericNeedle m) a -> a #

minimum :: Ord a => AbstractSimplex (GenericNeedle m) a -> a #

sum :: Num a => AbstractSimplex (GenericNeedle m) a -> a #

product :: Num a => AbstractSimplex (GenericNeedle m) a -> a #

Foldable (AbstractSimplex ) Source # 
Instance details

Defined in Data.Simplex.Abstract

Methods

fold :: Monoid m => AbstractSimplex m -> m #

foldMap :: Monoid m => (a -> m) -> AbstractSimplex a -> m #

foldMap' :: Monoid m => (a -> m) -> AbstractSimplex a -> m #

foldr :: (a -> b -> b) -> b -> AbstractSimplex a -> b #

foldr' :: (a -> b -> b) -> b -> AbstractSimplex a -> b #

foldl :: (b -> a -> b) -> b -> AbstractSimplex a -> b #

foldl' :: (b -> a -> b) -> b -> AbstractSimplex a -> b #

foldr1 :: (a -> a -> a) -> AbstractSimplex a -> a #

foldl1 :: (a -> a -> a) -> AbstractSimplex a -> a #

toList :: AbstractSimplex a -> [a] #

null :: AbstractSimplex a -> Bool #

length :: AbstractSimplex a -> Int #

elem :: Eq a => a -> AbstractSimplex a -> Bool #

maximum :: Ord a => AbstractSimplex a -> a #

minimum :: Ord a => AbstractSimplex a -> a #

sum :: Num a => AbstractSimplex a -> a #

product :: Num a => AbstractSimplex a -> a #

Foldable (AbstractSimplex ℝ⁰) Source # 
Instance details

Defined in Data.Simplex.Abstract

Methods

fold :: Monoid m => AbstractSimplex ℝ⁰ m -> m #

foldMap :: Monoid m => (a -> m) -> AbstractSimplex ℝ⁰ a -> m #

foldMap' :: Monoid m => (a -> m) -> AbstractSimplex ℝ⁰ a -> m #

foldr :: (a -> b -> b) -> b -> AbstractSimplex ℝ⁰ a -> b #

foldr' :: (a -> b -> b) -> b -> AbstractSimplex ℝ⁰ a -> b #

foldl :: (b -> a -> b) -> b -> AbstractSimplex ℝ⁰ a -> b #

foldl' :: (b -> a -> b) -> b -> AbstractSimplex ℝ⁰ a -> b #

foldr1 :: (a -> a -> a) -> AbstractSimplex ℝ⁰ a -> a #

foldl1 :: (a -> a -> a) -> AbstractSimplex ℝ⁰ a -> a #

toList :: AbstractSimplex ℝ⁰ a -> [a] #

null :: AbstractSimplex ℝ⁰ a -> Bool #

length :: AbstractSimplex ℝ⁰ a -> Int #

elem :: Eq a => a -> AbstractSimplex ℝ⁰ a -> Bool #

maximum :: Ord a => AbstractSimplex ℝ⁰ a -> a #

minimum :: Ord a => AbstractSimplex ℝ⁰ a -> a #

sum :: Num a => AbstractSimplex ℝ⁰ a -> a #

product :: Num a => AbstractSimplex ℝ⁰ a -> a #

Foldable (AbstractSimplex ℝ⁴) Source # 
Instance details

Defined in Data.Simplex.Abstract

Methods

fold :: Monoid m => AbstractSimplex ℝ⁴ m -> m #

foldMap :: Monoid m => (a -> m) -> AbstractSimplex ℝ⁴ a -> m #

foldMap' :: Monoid m => (a -> m) -> AbstractSimplex ℝ⁴ a -> m #

foldr :: (a -> b -> b) -> b -> AbstractSimplex ℝ⁴ a -> b #

foldr' :: (a -> b -> b) -> b -> AbstractSimplex ℝ⁴ a -> b #

foldl :: (b -> a -> b) -> b -> AbstractSimplex ℝ⁴ a -> b #

foldl' :: (b -> a -> b) -> b -> AbstractSimplex ℝ⁴ a -> b #

foldr1 :: (a -> a -> a) -> AbstractSimplex ℝ⁴ a -> a #

foldl1 :: (a -> a -> a) -> AbstractSimplex ℝ⁴ a -> a #

toList :: AbstractSimplex ℝ⁴ a -> [a] #

null :: AbstractSimplex ℝ⁴ a -> Bool #

length :: AbstractSimplex ℝ⁴ a -> Int #

elem :: Eq a => a -> AbstractSimplex ℝ⁴ a -> Bool #

maximum :: Ord a => AbstractSimplex ℝ⁴ a -> a #

minimum :: Ord a => AbstractSimplex ℝ⁴ a -> a #

sum :: Num a => AbstractSimplex ℝ⁴ a -> a #

product :: Num a => AbstractSimplex ℝ⁴ a -> a #

Foldable (AbstractSimplex ℝ³) Source # 
Instance details

Defined in Data.Simplex.Abstract

Methods

fold :: Monoid m => AbstractSimplex ℝ³ m -> m #

foldMap :: Monoid m => (a -> m) -> AbstractSimplex ℝ³ a -> m #

foldMap' :: Monoid m => (a -> m) -> AbstractSimplex ℝ³ a -> m #

foldr :: (a -> b -> b) -> b -> AbstractSimplex ℝ³ a -> b #

foldr' :: (a -> b -> b) -> b -> AbstractSimplex ℝ³ a -> b #

foldl :: (b -> a -> b) -> b -> AbstractSimplex ℝ³ a -> b #

foldl' :: (b -> a -> b) -> b -> AbstractSimplex ℝ³ a -> b #

foldr1 :: (a -> a -> a) -> AbstractSimplex ℝ³ a -> a #

foldl1 :: (a -> a -> a) -> AbstractSimplex ℝ³ a -> a #

toList :: AbstractSimplex ℝ³ a -> [a] #

null :: AbstractSimplex ℝ³ a -> Bool #

length :: AbstractSimplex ℝ³ a -> Int #

elem :: Eq a => a -> AbstractSimplex ℝ³ a -> Bool #

maximum :: Ord a => AbstractSimplex ℝ³ a -> a #

minimum :: Ord a => AbstractSimplex ℝ³ a -> a #

sum :: Num a => AbstractSimplex ℝ³ a -> a #

product :: Num a => AbstractSimplex ℝ³ a -> a #

Foldable (AbstractSimplex ℝ²) Source # 
Instance details

Defined in Data.Simplex.Abstract

Methods

fold :: Monoid m => AbstractSimplex ℝ² m -> m #

foldMap :: Monoid m => (a -> m) -> AbstractSimplex ℝ² a -> m #

foldMap' :: Monoid m => (a -> m) -> AbstractSimplex ℝ² a -> m #

foldr :: (a -> b -> b) -> b -> AbstractSimplex ℝ² a -> b #

foldr' :: (a -> b -> b) -> b -> AbstractSimplex ℝ² a -> b #

foldl :: (b -> a -> b) -> b -> AbstractSimplex ℝ² a -> b #

foldl' :: (b -> a -> b) -> b -> AbstractSimplex ℝ² a -> b #

foldr1 :: (a -> a -> a) -> AbstractSimplex ℝ² a -> a #

foldl1 :: (a -> a -> a) -> AbstractSimplex ℝ² a -> a #

toList :: AbstractSimplex ℝ² a -> [a] #

null :: AbstractSimplex ℝ² a -> Bool #

length :: AbstractSimplex ℝ² a -> Int #

elem :: Eq a => a -> AbstractSimplex ℝ² a -> Bool #

maximum :: Ord a => AbstractSimplex ℝ² a -> a #

minimum :: Ord a => AbstractSimplex ℝ² a -> a #

sum :: Num a => AbstractSimplex ℝ² a -> a #

product :: Num a => AbstractSimplex ℝ² a -> a #

Foldable (AbstractSimplex ℝ¹) Source # 
Instance details

Defined in Data.Simplex.Abstract

Methods

fold :: Monoid m => AbstractSimplex ℝ¹ m -> m #

foldMap :: Monoid m => (a -> m) -> AbstractSimplex ℝ¹ a -> m #

foldMap' :: Monoid m => (a -> m) -> AbstractSimplex ℝ¹ a -> m #

foldr :: (a -> b -> b) -> b -> AbstractSimplex ℝ¹ a -> b #

foldr' :: (a -> b -> b) -> b -> AbstractSimplex ℝ¹ a -> b #

foldl :: (b -> a -> b) -> b -> AbstractSimplex ℝ¹ a -> b #

foldl' :: (b -> a -> b) -> b -> AbstractSimplex ℝ¹ a -> b #

foldr1 :: (a -> a -> a) -> AbstractSimplex ℝ¹ a -> a #

foldl1 :: (a -> a -> a) -> AbstractSimplex ℝ¹ a -> a #

toList :: AbstractSimplex ℝ¹ a -> [a] #

null :: AbstractSimplex ℝ¹ a -> Bool #

length :: AbstractSimplex ℝ¹ a -> Int #

elem :: Eq a => a -> AbstractSimplex ℝ¹ a -> Bool #

maximum :: Ord a => AbstractSimplex ℝ¹ a -> a #

minimum :: Ord a => AbstractSimplex ℝ¹ a -> a #

sum :: Num a => AbstractSimplex ℝ¹ a -> a #

product :: Num a => AbstractSimplex ℝ¹ a -> a #

Traversable (AbstractSimplex v) => Traversable (AbstractSimplex (, v)) Source # 
Instance details

Defined in Data.Simplex.Abstract

Methods

traverse :: Applicative f => (a -> f b) -> AbstractSimplex (, v) a -> f (AbstractSimplex (, v) b) #

sequenceA :: Applicative f => AbstractSimplex (, v) (f a) -> f (AbstractSimplex (, v) a) #

mapM :: Monad m => (a -> m b) -> AbstractSimplex (, v) a -> m (AbstractSimplex (, v) b) #

sequence :: Monad m => AbstractSimplex (, v) (m a) -> m (AbstractSimplex (, v) a) #

Traversable (AbstractSimplex (Needle (f p), Needle (g p))) => Traversable (AbstractSimplex (NeedleProductSpace f g p)) Source # 
Instance details

Defined in Data.Simplex.Abstract

Traversable (AbstractSimplex (Rep m ())) => Traversable (AbstractSimplex (GenericNeedle m)) Source # 
Instance details

Defined in Data.Simplex.Abstract

Traversable (AbstractSimplex ) Source # 
Instance details

Defined in Data.Simplex.Abstract

Methods

traverse :: Applicative f => (a -> f b) -> AbstractSimplex a -> f (AbstractSimplex b) #

sequenceA :: Applicative f => AbstractSimplex (f a) -> f (AbstractSimplex a) #

mapM :: Monad m => (a -> m b) -> AbstractSimplex a -> m (AbstractSimplex b) #

sequence :: Monad m => AbstractSimplex (m a) -> m (AbstractSimplex a) #

Traversable (AbstractSimplex ℝ⁰) Source # 
Instance details

Defined in Data.Simplex.Abstract

Traversable (AbstractSimplex ℝ⁴) Source # 
Instance details

Defined in Data.Simplex.Abstract

Traversable (AbstractSimplex ℝ³) Source # 
Instance details

Defined in Data.Simplex.Abstract

Traversable (AbstractSimplex ℝ²) Source # 
Instance details

Defined in Data.Simplex.Abstract

Traversable (AbstractSimplex ℝ¹) Source # 
Instance details

Defined in Data.Simplex.Abstract

data AbstractSimplex x Source # 
Instance details

Defined in Data.Simplex.Abstract

data AbstractSimplex ℝ⁰ x Source # 
Instance details

Defined in Data.Simplex.Abstract

data AbstractSimplex ℝ⁴ x Source # 
Instance details

Defined in Data.Simplex.Abstract

data AbstractSimplex ℝ⁴ x = ℝ⁴Simplex !x !x !x !x !x
data AbstractSimplex ℝ³ x Source # 
Instance details

Defined in Data.Simplex.Abstract

data AbstractSimplex ℝ³ x = ℝ³Simplex !x !x !x !x
data AbstractSimplex ℝ² x Source # 
Instance details

Defined in Data.Simplex.Abstract

data AbstractSimplex ℝ¹ x Source # 
Instance details

Defined in Data.Simplex.Abstract

newtype AbstractSimplex (GenericNeedle m) x Source # 
Instance details

Defined in Data.Simplex.Abstract

data AbstractSimplex (, v) x Source # 
Instance details

Defined in Data.Simplex.Abstract

newtype AbstractSimplex (NeedleProductSpace f g p) x Source # 
Instance details

Defined in Data.Simplex.Abstract