Safe Haskell	None
Language	Haskell2010

Naqsha.Geometry.Internal

Description

The internal module that exposes the basic geometric types in naqsha. This interface is subject to change and hence use with caution.

Synopsis

Documentation

newtype Angle #

An abstract angle. Internally, angles are represented as a 64-bit integer with each unit contribute 1/2^64 fraction of a complete circle. This means that angles are accurate up to a resolution of 2 π / 2^64 radians. Angles form a group under the angular addition and the fact that these are represented as integers means one can expect high speed accurate angle arithmetic.

When expressing angles one can use a more convenient notation:

myAngle   = degree 21.71167
yourAngle = degree 21 <> minute 42 <> second 42

Constructors

Angle
Fields unAngle :: Int64

Instances

Bounded Angle #
Methods minBound :: Angle # maxBound :: Angle #
Enum Angle #
Methods succ :: Angle -> Angle # pred :: Angle -> Angle # toEnum :: Int -> Angle # fromEnum :: Angle -> Int # enumFrom :: Angle -> [Angle] # enumFromThen :: Angle -> Angle -> [Angle] # enumFromTo :: Angle -> Angle -> [Angle] # enumFromThenTo :: Angle -> Angle -> Angle -> [Angle] #
Eq Angle #
Methods (==) :: Angle -> Angle -> Bool # (/=) :: Angle -> Angle -> Bool #
Ord Angle #
Methods compare :: Angle -> Angle -> Ordering # (<) :: Angle -> Angle -> Bool # (<=) :: Angle -> Angle -> Bool # (>) :: Angle -> Angle -> Bool # (>=) :: Angle -> Angle -> Bool # max :: Angle -> Angle -> Angle # min :: Angle -> Angle -> Angle #
Read Angle #
Methods readsPrec :: Int -> ReadS Angle # readList :: ReadS [Angle] # readPrec :: ReadPrec Angle # readListPrec :: ReadPrec [Angle] #
Show Angle #
Methods showsPrec :: Int -> Angle -> ShowS # show :: Angle -> String # showList :: [Angle] -> ShowS #
Monoid Angle #
Methods mempty :: Angle # mappend :: Angle -> Angle -> Angle # mconcat :: [Angle] -> Angle #
Bits Angle #
Methods (.&.) :: Angle -> Angle -> Angle # (.\|.) :: Angle -> Angle -> Angle # xor :: Angle -> Angle -> Angle # complement :: Angle -> Angle # shift :: Angle -> Int -> Angle # rotate :: Angle -> Int -> Angle # zeroBits :: Angle # bit :: Int -> Angle # setBit :: Angle -> Int -> Angle # clearBit :: Angle -> Int -> Angle # complementBit :: Angle -> Int -> Angle # testBit :: Angle -> Int -> Bool # bitSizeMaybe :: Angle -> Maybe Int # bitSize :: Angle -> Int # isSigned :: Angle -> Bool # shiftL :: Angle -> Int -> Angle # unsafeShiftL :: Angle -> Int -> Angle # shiftR :: Angle -> Int -> Angle # unsafeShiftR :: Angle -> Int -> Angle # rotateL :: Angle -> Int -> Angle # rotateR :: Angle -> Int -> Angle # popCount :: Angle -> Int #
Group Angle #
Methods invert :: Angle -> Angle # pow :: Integral x => Angle -> x -> Angle #
Unbox Angle #

Angular Angle #
Methods toAngle :: Angle -> Angle #
Vector Vector Angle #
Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Angle -> m (Vector Angle) # basicUnsafeThaw :: PrimMonad m => Vector Angle -> m (Mutable Vector (PrimState m) Angle) # basicLength :: Vector Angle -> Int # basicUnsafeSlice :: Int -> Int -> Vector Angle -> Vector Angle # basicUnsafeIndexM :: Monad m => Vector Angle -> Int -> m Angle # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Angle -> Vector Angle -> m () # elemseq :: Vector Angle -> Angle -> b -> b #
MVector MVector Angle #
Methods basicLength :: MVector s Angle -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Angle -> MVector s Angle # basicOverlaps :: MVector s Angle -> MVector s Angle -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Angle) # basicInitialize :: PrimMonad m => MVector (PrimState m) Angle -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Angle -> m (MVector (PrimState m) Angle) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Angle -> Int -> m Angle # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Angle -> Int -> Angle -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Angle -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Angle -> Angle -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Angle -> MVector (PrimState m) Angle -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Angle -> MVector (PrimState m) Angle -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Angle -> Int -> m (MVector (PrimState m) Angle) #
data Vector Angle #
data Vector Angle = AngV (Vector Int64)
data MVector s Angle #
data MVector s Angle = MAngV (MVector s Int64)

degree :: Rational -> Angle #

Express angle in degrees.

minute :: Rational -> Angle #

Express angle in minutes.

second :: Rational -> Angle #

Express angle in seconds.

radian :: Double -> Angle #

Express angle in radians

toDegree :: Fractional r => Angle -> r #

Measure angle in degrees. This conversion may lead to loss of precision.

toRadian :: Angle -> Double #

Measure angle in radians. This conversion may lead to loss of precision.

newtype Latitude #

The latitude of a point. Positive denotes North of Equator where as negative South.

Constructors

Latitude
Fields unLat :: Angle

Instances

Bounded Latitude #
Methods minBound :: Latitude # maxBound :: Latitude #
Eq Latitude #
Methods (==) :: Latitude -> Latitude -> Bool # (/=) :: Latitude -> Latitude -> Bool #
Ord Latitude #
Methods compare :: Latitude -> Latitude -> Ordering # (<) :: Latitude -> Latitude -> Bool # (<=) :: Latitude -> Latitude -> Bool # (>) :: Latitude -> Latitude -> Bool # (>=) :: Latitude -> Latitude -> Bool # max :: Latitude -> Latitude -> Latitude # min :: Latitude -> Latitude -> Latitude #
Read Latitude #
Methods readsPrec :: Int -> ReadS Latitude # readList :: ReadS [Latitude] # readPrec :: ReadPrec Latitude # readListPrec :: ReadPrec [Latitude] #
Show Latitude #
Methods showsPrec :: Int -> Latitude -> ShowS # show :: Latitude -> String # showList :: [Latitude] -> ShowS #
Bits Latitude #
Methods (.&.) :: Latitude -> Latitude -> Latitude # (.\|.) :: Latitude -> Latitude -> Latitude # xor :: Latitude -> Latitude -> Latitude # complement :: Latitude -> Latitude # shift :: Latitude -> Int -> Latitude # rotate :: Latitude -> Int -> Latitude # zeroBits :: Latitude # bit :: Int -> Latitude # setBit :: Latitude -> Int -> Latitude # clearBit :: Latitude -> Int -> Latitude # complementBit :: Latitude -> Int -> Latitude # testBit :: Latitude -> Int -> Bool # bitSizeMaybe :: Latitude -> Maybe Int # bitSize :: Latitude -> Int # isSigned :: Latitude -> Bool # shiftL :: Latitude -> Int -> Latitude # unsafeShiftL :: Latitude -> Int -> Latitude # shiftR :: Latitude -> Int -> Latitude # unsafeShiftR :: Latitude -> Int -> Latitude # rotateL :: Latitude -> Int -> Latitude # rotateR :: Latitude -> Int -> Latitude # popCount :: Latitude -> Int #
Angular Latitude #
Methods toAngle :: Latitude -> Angle #
Vector Vector Latitude #
Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Latitude -> m (Vector Latitude) # basicUnsafeThaw :: PrimMonad m => Vector Latitude -> m (Mutable Vector (PrimState m) Latitude) # basicLength :: Vector Latitude -> Int # basicUnsafeSlice :: Int -> Int -> Vector Latitude -> Vector Latitude # basicUnsafeIndexM :: Monad m => Vector Latitude -> Int -> m Latitude # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Latitude -> Vector Latitude -> m () # elemseq :: Vector Latitude -> Latitude -> b -> b #
MVector MVector Latitude #
Methods basicLength :: MVector s Latitude -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Latitude -> MVector s Latitude # basicOverlaps :: MVector s Latitude -> MVector s Latitude -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Latitude) # basicInitialize :: PrimMonad m => MVector (PrimState m) Latitude -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Latitude -> m (MVector (PrimState m) Latitude) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Latitude -> Int -> m Latitude # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Latitude -> Int -> Latitude -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Latitude -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Latitude -> Latitude -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Latitude -> MVector (PrimState m) Latitude -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Latitude -> MVector (PrimState m) Latitude -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Latitude -> Int -> m (MVector (PrimState m) Latitude) #
data Vector Latitude #
data Vector Latitude = LatV (Vector Angle)
data MVector s Latitude #
data MVector s Latitude = MLatV (MVector s Angle)

newtype Longitude #

The longitude of a point. Positive denotes East of the Greenwich meridian where as negative denotes West.

Constructors

Longitude
Fields unLong :: Angle

Instances

Bounded Longitude #
Methods minBound :: Longitude # maxBound :: Longitude #
Eq Longitude #
Methods (==) :: Longitude -> Longitude -> Bool # (/=) :: Longitude -> Longitude -> Bool #
Ord Longitude #
Methods compare :: Longitude -> Longitude -> Ordering # (<) :: Longitude -> Longitude -> Bool # (<=) :: Longitude -> Longitude -> Bool # (>) :: Longitude -> Longitude -> Bool # (>=) :: Longitude -> Longitude -> Bool # max :: Longitude -> Longitude -> Longitude # min :: Longitude -> Longitude -> Longitude #
Read Longitude #
Methods readsPrec :: Int -> ReadS Longitude # readList :: ReadS [Longitude] # readPrec :: ReadPrec Longitude # readListPrec :: ReadPrec [Longitude] #
Show Longitude #
Methods showsPrec :: Int -> Longitude -> ShowS # show :: Longitude -> String # showList :: [Longitude] -> ShowS #
Monoid Longitude #
Methods mempty :: Longitude # mappend :: Longitude -> Longitude -> Longitude # mconcat :: [Longitude] -> Longitude #
Bits Longitude #
Methods (.&.) :: Longitude -> Longitude -> Longitude # (.\|.) :: Longitude -> Longitude -> Longitude # xor :: Longitude -> Longitude -> Longitude # complement :: Longitude -> Longitude # shift :: Longitude -> Int -> Longitude # rotate :: Longitude -> Int -> Longitude # zeroBits :: Longitude # bit :: Int -> Longitude # setBit :: Longitude -> Int -> Longitude # clearBit :: Longitude -> Int -> Longitude # complementBit :: Longitude -> Int -> Longitude # testBit :: Longitude -> Int -> Bool # bitSizeMaybe :: Longitude -> Maybe Int # bitSize :: Longitude -> Int # isSigned :: Longitude -> Bool # shiftL :: Longitude -> Int -> Longitude # unsafeShiftL :: Longitude -> Int -> Longitude # shiftR :: Longitude -> Int -> Longitude # unsafeShiftR :: Longitude -> Int -> Longitude # rotateL :: Longitude -> Int -> Longitude # rotateR :: Longitude -> Int -> Longitude # popCount :: Longitude -> Int #
Group Longitude #
Methods invert :: Longitude -> Longitude # pow :: Integral x => Longitude -> x -> Longitude #
Angular Longitude #
Methods toAngle :: Longitude -> Angle #
Vector Vector Longitude #
Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Longitude -> m (Vector Longitude) # basicUnsafeThaw :: PrimMonad m => Vector Longitude -> m (Mutable Vector (PrimState m) Longitude) # basicLength :: Vector Longitude -> Int # basicUnsafeSlice :: Int -> Int -> Vector Longitude -> Vector Longitude # basicUnsafeIndexM :: Monad m => Vector Longitude -> Int -> m Longitude # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Longitude -> Vector Longitude -> m () # elemseq :: Vector Longitude -> Longitude -> b -> b #
MVector MVector Longitude #
Methods basicLength :: MVector s Longitude -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Longitude -> MVector s Longitude # basicOverlaps :: MVector s Longitude -> MVector s Longitude -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Longitude) # basicInitialize :: PrimMonad m => MVector (PrimState m) Longitude -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Longitude -> m (MVector (PrimState m) Longitude) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Longitude -> Int -> m Longitude # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Longitude -> Int -> Longitude -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Longitude -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Longitude -> Longitude -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Longitude -> MVector (PrimState m) Longitude -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Longitude -> MVector (PrimState m) Longitude -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Longitude -> Int -> m (MVector (PrimState m) Longitude) #
data Vector Longitude #
data Vector Longitude = LongV (Vector Angle)
data MVector s Longitude #
data MVector s Longitude = MLongV (MVector s Angle)

lat :: Angle -> Latitude #

Construct latitude out of an angle.

lon :: Angle -> Longitude #

Convert angles to longitude.