Safe Haskell	Safe
Language	Haskell98

Numeric.Coalgebra.Hyperbolic

Documentation

class Hyperbolic r where #

Minimal complete definition

cosh, sinh

Methods

cosh :: r #

sinh :: r #

Instances

Hyperbolic HyperBasis #
Methods cosh :: HyperBasis # sinh :: HyperBasis #
Hyperbolic HyperBasis' #
Methods cosh :: HyperBasis' # sinh :: HyperBasis' #
Rig r => Hyperbolic (Hyper r) #
Methods cosh :: Hyper r # sinh :: Hyper r #
Rig r => Hyperbolic (Hyper' r) #
Methods cosh :: Hyper' r # sinh :: Hyper' r #
Rig r => Hyperbolic (HyperBasis -> r) #
Methods cosh :: HyperBasis -> r # sinh :: HyperBasis -> r #
Rig r => Hyperbolic (HyperBasis' -> r) #
Methods cosh :: HyperBasis' -> r # sinh :: HyperBasis' -> r #
Hyperbolic a => Hyperbolic (Covector r a) #
Methods cosh :: Covector r a # sinh :: Covector r a #

data HyperBasis #

Constructors

Cosh
Sinh

Instances

Bounded HyperBasis #
Methods minBound :: HyperBasis # maxBound :: HyperBasis #
Enum HyperBasis #
Methods succ :: HyperBasis -> HyperBasis # pred :: HyperBasis -> HyperBasis # toEnum :: Int -> HyperBasis # fromEnum :: HyperBasis -> Int # enumFrom :: HyperBasis -> [HyperBasis] # enumFromThen :: HyperBasis -> HyperBasis -> [HyperBasis] # enumFromTo :: HyperBasis -> HyperBasis -> [HyperBasis] # enumFromThenTo :: HyperBasis -> HyperBasis -> HyperBasis -> [HyperBasis] #
Eq HyperBasis #
Methods (==) :: HyperBasis -> HyperBasis -> Bool # (/=) :: HyperBasis -> HyperBasis -> Bool #
Data HyperBasis #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HyperBasis -> c HyperBasis # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HyperBasis # toConstr :: HyperBasis -> Constr # dataTypeOf :: HyperBasis -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c HyperBasis) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HyperBasis) # gmapT :: (forall b. Data b => b -> b) -> HyperBasis -> HyperBasis # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HyperBasis -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HyperBasis -> r # gmapQ :: (forall d. Data d => d -> u) -> HyperBasis -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HyperBasis -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HyperBasis -> m HyperBasis # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HyperBasis -> m HyperBasis # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HyperBasis -> m HyperBasis #
Ord HyperBasis #
Methods compare :: HyperBasis -> HyperBasis -> Ordering # (<) :: HyperBasis -> HyperBasis -> Bool # (<=) :: HyperBasis -> HyperBasis -> Bool # (>) :: HyperBasis -> HyperBasis -> Bool # (>=) :: HyperBasis -> HyperBasis -> Bool # max :: HyperBasis -> HyperBasis -> HyperBasis # min :: HyperBasis -> HyperBasis -> HyperBasis #
Read HyperBasis #
Methods readsPrec :: Int -> ReadS HyperBasis # readList :: ReadS [HyperBasis] # readPrec :: ReadPrec HyperBasis # readListPrec :: ReadPrec [HyperBasis] #
Show HyperBasis #
Methods showsPrec :: Int -> HyperBasis -> ShowS # show :: HyperBasis -> String # showList :: [HyperBasis] -> ShowS #
Ix HyperBasis #
Methods range :: (HyperBasis, HyperBasis) -> [HyperBasis] # index :: (HyperBasis, HyperBasis) -> HyperBasis -> Int # unsafeIndex :: (HyperBasis, HyperBasis) -> HyperBasis -> Int inRange :: (HyperBasis, HyperBasis) -> HyperBasis -> Bool # rangeSize :: (HyperBasis, HyperBasis) -> Int # unsafeRangeSize :: (HyperBasis, HyperBasis) -> Int
Hyperbolic HyperBasis #
Methods cosh :: HyperBasis # sinh :: HyperBasis #
MonadReader HyperBasis Hyper #
Methods ask :: Hyper HyperBasis # local :: (HyperBasis -> HyperBasis) -> Hyper a -> Hyper a # reader :: (HyperBasis -> a) -> Hyper a #
(Commutative k, Semiring k) => Coalgebra k HyperBasis #	the hyperbolic trigonometric coalgebra
Methods comult :: (HyperBasis -> k) -> HyperBasis -> HyperBasis -> k #
Semiring k => Algebra k HyperBasis #	the trivial diagonal algebra
Methods mult :: (HyperBasis -> HyperBasis -> k) -> HyperBasis -> k #
(Commutative k, Semiring k) => Bialgebra k HyperBasis #

(Commutative k, Semiring k) => CounitalCoalgebra k HyperBasis #
Methods counit :: (HyperBasis -> k) -> k #
Semiring k => UnitalAlgebra k HyperBasis #
Methods unit :: k -> HyperBasis -> k #
(Commutative k, Group k, InvolutiveSemiring k) => HopfAlgebra k HyperBasis #
Methods antipode :: (HyperBasis -> k) -> HyperBasis -> k #
(Commutative k, Group k, InvolutiveSemiring k) => InvolutiveCoalgebra k HyperBasis #
Methods coinv :: (HyperBasis -> k) -> HyperBasis -> k #
(Commutative k, Group k, InvolutiveSemiring k) => InvolutiveAlgebra k HyperBasis #
Methods inv :: (HyperBasis -> k) -> HyperBasis -> k #
Rig r => Hyperbolic (HyperBasis -> r) #
Methods cosh :: HyperBasis -> r # sinh :: HyperBasis -> r #

data Hyper a #

Constructors

Hyper a a

Instances

Monad Hyper #
Methods (>>=) :: Hyper a -> (a -> Hyper b) -> Hyper b # (>>) :: Hyper a -> Hyper b -> Hyper b # return :: a -> Hyper a # fail :: String -> Hyper a #
Functor Hyper #
Methods fmap :: (a -> b) -> Hyper a -> Hyper b # (<$) :: a -> Hyper b -> Hyper a #
Applicative Hyper #
Methods pure :: a -> Hyper a # (<>) :: Hyper (a -> b) -> Hyper a -> Hyper b # liftA2 :: (a -> b -> c) -> Hyper a -> Hyper b -> Hyper c # (>) :: Hyper a -> Hyper b -> Hyper b # (<*) :: Hyper a -> Hyper b -> Hyper a #
Foldable Hyper #
Methods fold :: Monoid m => Hyper m -> m # foldMap :: Monoid m => (a -> m) -> Hyper a -> m # foldr :: (a -> b -> b) -> b -> Hyper a -> b # foldr' :: (a -> b -> b) -> b -> Hyper a -> b # foldl :: (b -> a -> b) -> b -> Hyper a -> b # foldl' :: (b -> a -> b) -> b -> Hyper a -> b # foldr1 :: (a -> a -> a) -> Hyper a -> a # foldl1 :: (a -> a -> a) -> Hyper a -> a # toList :: Hyper a -> [a] # null :: Hyper a -> Bool # length :: Hyper a -> Int # elem :: Eq a => a -> Hyper a -> Bool # maximum :: Ord a => Hyper a -> a # minimum :: Ord a => Hyper a -> a # sum :: Num a => Hyper a -> a # product :: Num a => Hyper a -> a #
Traversable Hyper #
Methods traverse :: Applicative f => (a -> f b) -> Hyper a -> f (Hyper b) # sequenceA :: Applicative f => Hyper (f a) -> f (Hyper a) # mapM :: Monad m => (a -> m b) -> Hyper a -> m (Hyper b) # sequence :: Monad m => Hyper (m a) -> m (Hyper a) #
Distributive Hyper #
Methods distribute :: Functor f => f (Hyper a) -> Hyper (f a) # collect :: Functor f => (a -> Hyper b) -> f a -> Hyper (f b) # distributeM :: Monad m => m (Hyper a) -> Hyper (m a) # collectM :: Monad m => (a -> Hyper b) -> m a -> Hyper (m b) #
Representable Hyper #
Associated Types type Rep (Hyper :: * -> ) :: # Methods tabulate :: (Rep Hyper -> a) -> Hyper a # index :: Hyper a -> Rep Hyper -> a #
Traversable1 Hyper #
Methods traverse1 :: Apply f => (a -> f b) -> Hyper a -> f (Hyper b) # sequence1 :: Apply f => Hyper (f b) -> f (Hyper b) #
Foldable1 Hyper #
Methods fold1 :: Semigroup m => Hyper m -> m # foldMap1 :: Semigroup m => (a -> m) -> Hyper a -> m # toNonEmpty :: Hyper a -> NonEmpty a #
Apply Hyper #
Methods (<.>) :: Hyper (a -> b) -> Hyper a -> Hyper b # (.>) :: Hyper a -> Hyper b -> Hyper b # (<.) :: Hyper a -> Hyper b -> Hyper a # liftF2 :: (a -> b -> c) -> Hyper a -> Hyper b -> Hyper c #
Bind Hyper #
Methods (>>-) :: Hyper a -> (a -> Hyper b) -> Hyper b # join :: Hyper (Hyper a) -> Hyper a #
MonadReader HyperBasis Hyper #
Methods ask :: Hyper HyperBasis # local :: (HyperBasis -> HyperBasis) -> Hyper a -> Hyper a # reader :: (HyperBasis -> a) -> Hyper a #
RightModule r s => RightModule r (Hyper s) #
Methods (*.) :: Hyper s -> r -> Hyper s #
LeftModule r s => LeftModule r (Hyper s) #
Methods (.*) :: r -> Hyper s -> Hyper s #
Eq a => Eq (Hyper a) #
Methods (==) :: Hyper a -> Hyper a -> Bool # (/=) :: Hyper a -> Hyper a -> Bool #
Data a => Data (Hyper a) #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Hyper a -> c (Hyper a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Hyper a) # toConstr :: Hyper a -> Constr # dataTypeOf :: Hyper a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (Hyper a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Hyper a)) # gmapT :: (forall b. Data b => b -> b) -> Hyper a -> Hyper a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Hyper a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Hyper a -> r # gmapQ :: (forall d. Data d => d -> u) -> Hyper a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Hyper a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Hyper a -> m (Hyper a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Hyper a -> m (Hyper a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Hyper a -> m (Hyper a) #
Read a => Read (Hyper a) #
Methods readsPrec :: Int -> ReadS (Hyper a) # readList :: ReadS [Hyper a] # readPrec :: ReadPrec (Hyper a) # readListPrec :: ReadPrec [Hyper a] #
Show a => Show (Hyper a) #
Methods showsPrec :: Int -> Hyper a -> ShowS # show :: Hyper a -> String # showList :: [Hyper a] -> ShowS #
Idempotent r => Idempotent (Hyper r) #

Abelian r => Abelian (Hyper r) #

Partitionable r => Partitionable (Hyper r) #
Methods partitionWith :: (Hyper r -> Hyper r -> r) -> Hyper r -> NonEmpty r #
Additive r => Additive (Hyper r) #
Methods (+) :: Hyper r -> Hyper r -> Hyper r # sinnum1p :: Natural -> Hyper r -> Hyper r # sumWith1 :: Foldable1 f => (a -> Hyper r) -> f a -> Hyper r #
Monoidal r => Monoidal (Hyper r) #
Methods zero :: Hyper r # sinnum :: Natural -> Hyper r -> Hyper r # sumWith :: Foldable f => (a -> Hyper r) -> f a -> Hyper r #
(Commutative k, Semiring k) => Semiring (Hyper k) #

(Commutative k, Semiring k) => Multiplicative (Hyper k) #
Methods (*) :: Hyper k -> Hyper k -> Hyper k # pow1p :: Hyper k -> Natural -> Hyper k # productWith1 :: Foldable1 f => (a -> Hyper k) -> f a -> Hyper k #
Group r => Group (Hyper r) #
Methods (-) :: Hyper r -> Hyper r -> Hyper r # negate :: Hyper r -> Hyper r # subtract :: Hyper r -> Hyper r -> Hyper r # times :: Integral n => n -> Hyper r -> Hyper r #
(Commutative k, Rig k) => Unital (Hyper k) #
Methods one :: Hyper k # pow :: Hyper k -> Natural -> Hyper k # productWith :: Foldable f => (a -> Hyper k) -> f a -> Hyper k #
(Commutative k, Semiring k) => Commutative (Hyper k) #

(Commutative r, Group r, InvolutiveSemiring r) => InvolutiveSemiring (Hyper r) #

(Commutative r, Group r, InvolutiveSemiring r) => InvolutiveMultiplication (Hyper r) #
Methods adjoint :: Hyper r -> Hyper r #
(Commutative r, Rig r) => Rig (Hyper r) #
Methods fromNatural :: Natural -> Hyper r #
(Commutative r, Ring r) => Ring (Hyper r) #
Methods fromInteger :: Integer -> Hyper r #
Rig r => Hyperbolic (Hyper r) #
Methods cosh :: Hyper r # sinh :: Hyper r #
(Commutative r, Semiring r) => RightModule (Hyper r) (Hyper r) #
Methods (*.) :: Hyper r -> Hyper r -> Hyper r #
(Commutative r, Semiring r) => LeftModule (Hyper r) (Hyper r) #
Methods (.*) :: Hyper r -> Hyper r -> Hyper r #
type Rep Hyper #
type Rep Hyper = HyperBasis