Numeric.Algebra.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, Monoidal k, Semiring k) => Coalgebra k HyperBasis'

Methods

comult :: (HyperBasis' -> k) -> HyperBasis' -> HyperBasis' -> k

(Commutative k, Semiring k) => Algebra k HyperBasis'

Methods

mult :: (HyperBasis' -> HyperBasis' -> k) -> HyperBasis' -> k

(Commutative k, Monoidal k, Semiring k) => Bialgebra k HyperBasis'

(Commutative k, Monoidal k, Semiring k) => CounitalCoalgebra k HyperBasis'

Methods

counit :: (HyperBasis' -> k) -> k

(Commutative k, Monoidal 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

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

(Commutative r, InvolutiveSemiring r, Rng r) => Quadrance r (Hyper' r)

Methods

quadrance :: Hyper' r -> r

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 r, InvolutiveSemiring r, DivisionRing r) => Division (Hyper' r)

Methods

recip :: Hyper' r -> Hyper' r

(/) :: Hyper' r -> Hyper' r -> Hyper' r

(\\) :: Hyper' r -> Hyper' r -> Hyper' r

(^) :: Integral n => Hyper' r -> n -> Hyper' r

(Commutative k, Semiring k) => Commutative (Hyper' k)

(Commutative r, InvolutiveSemiring r, Rng r) => InvolutiveSemiring (Hyper' r)

(Commutative r, InvolutiveSemiring r, Rng 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'