Numeric.Rounded.Hardware.Backend.C

The types in this module implements rounding-mode-controlled operations in C.

There are several ways to control rounding mode in C, and an appropriate technology will be selected at compile time. This library implements the following options:

• C99 fesetround

• On x86 systems,

  • SSE2 MXCSR (for Float and Double)
  • AVX512 EVEX encoding (for Float and Double)
  • x87 Control Word (for LongDouble)
• On AArch64, FPCR

You should not need to import this module directly.

This module is not available if the package flag pure-hs is set.

Documentation

newtype CFloat

A wrapper providing particular instances for RoundedRing, RoundedFractional and RoundedSqrt.

This type is different from CFloat from Foreign.C.Types.

Constructors

CFloat Float

Instances

Eq CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

(==) :: CFloat -> CFloat -> Bool

(/=) :: CFloat -> CFloat -> Bool

Num CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

(+) :: CFloat -> CFloat -> CFloat

(-) :: CFloat -> CFloat -> CFloat

(*) :: CFloat -> CFloat -> CFloat

negate :: CFloat -> CFloat

abs :: CFloat -> CFloat

signum :: CFloat -> CFloat

fromInteger :: Integer -> CFloat

Ord CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

compare :: CFloat -> CFloat -> Ordering

(<) :: CFloat -> CFloat -> Bool

(<=) :: CFloat -> CFloat -> Bool

(>) :: CFloat -> CFloat -> Bool

(>=) :: CFloat -> CFloat -> Bool

max :: CFloat -> CFloat -> CFloat

min :: CFloat -> CFloat -> CFloat

Show CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

showsPrec :: Int -> CFloat -> ShowS

show :: CFloat -> String

showList :: [CFloat] -> ShowS

Generic CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Associated Types

type Rep CFloat :: Type -> Type

Methods

from :: CFloat -> Rep CFloat x

to :: Rep CFloat x -> CFloat

Storable CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

sizeOf :: CFloat -> Int

alignment :: CFloat -> Int

peekElemOff :: Ptr CFloat -> Int -> IO CFloat

pokeElemOff :: Ptr CFloat -> Int -> CFloat -> IO ()

peekByteOff :: Ptr b -> Int -> IO CFloat

pokeByteOff :: Ptr b -> Int -> CFloat -> IO ()

peek :: Ptr CFloat -> IO CFloat

poke :: Ptr CFloat -> CFloat -> IO ()

NFData CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

rnf :: CFloat -> ()

Unbox CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

RoundedSqrt CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

roundedSqrt :: RoundingMode -> CFloat -> CFloat

intervalSqrt :: Rounded 'TowardNegInf CFloat -> Rounded 'TowardInf CFloat -> (Rounded 'TowardNegInf CFloat, Rounded 'TowardInf CFloat)

RoundedFractional CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

roundedDiv :: RoundingMode -> CFloat -> CFloat -> CFloat

roundedRecip :: RoundingMode -> CFloat -> CFloat

roundedFromRational :: RoundingMode -> Rational -> CFloat

roundedFromRealFloat :: RealFloat b => RoundingMode -> b -> CFloat

intervalDiv :: Rounded 'TowardNegInf CFloat -> Rounded 'TowardInf CFloat -> Rounded 'TowardNegInf CFloat -> Rounded 'TowardInf CFloat -> (Rounded 'TowardNegInf CFloat, Rounded 'TowardInf CFloat)

intervalDivAdd :: Rounded 'TowardNegInf CFloat -> Rounded 'TowardInf CFloat -> Rounded 'TowardNegInf CFloat -> Rounded 'TowardInf CFloat -> Rounded 'TowardNegInf CFloat -> Rounded 'TowardInf CFloat -> (Rounded 'TowardNegInf CFloat, Rounded 'TowardInf CFloat)

intervalRecip :: Rounded 'TowardNegInf CFloat -> Rounded 'TowardInf CFloat -> (Rounded 'TowardNegInf CFloat, Rounded 'TowardInf CFloat)

intervalFromRational :: Rational -> (Rounded 'TowardNegInf CFloat, Rounded 'TowardInf CFloat)

RoundedRing CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

roundedAdd :: RoundingMode -> CFloat -> CFloat -> CFloat

roundedSub :: RoundingMode -> CFloat -> CFloat -> CFloat

roundedMul :: RoundingMode -> CFloat -> CFloat -> CFloat

roundedFusedMultiplyAdd :: RoundingMode -> CFloat -> CFloat -> CFloat -> CFloat

roundedFromInteger :: RoundingMode -> Integer -> CFloat

intervalAdd :: Rounded 'TowardNegInf CFloat -> Rounded 'TowardInf CFloat -> Rounded 'TowardNegInf CFloat -> Rounded 'TowardInf CFloat -> (Rounded 'TowardNegInf CFloat, Rounded 'TowardInf CFloat)

intervalSub :: Rounded 'TowardNegInf CFloat -> Rounded 'TowardInf CFloat -> Rounded 'TowardNegInf CFloat -> Rounded 'TowardInf CFloat -> (Rounded 'TowardNegInf CFloat, Rounded 'TowardInf CFloat)

intervalMul :: Rounded 'TowardNegInf CFloat -> Rounded 'TowardInf CFloat -> Rounded 'TowardNegInf CFloat -> Rounded 'TowardInf CFloat -> (Rounded 'TowardNegInf CFloat, Rounded 'TowardInf CFloat)

intervalMulAdd :: Rounded 'TowardNegInf CFloat -> Rounded 'TowardInf CFloat -> Rounded 'TowardNegInf CFloat -> Rounded 'TowardInf CFloat -> Rounded 'TowardNegInf CFloat -> Rounded 'TowardInf CFloat -> (Rounded 'TowardNegInf CFloat, Rounded 'TowardInf CFloat)

intervalFromInteger :: Integer -> (Rounded 'TowardNegInf CFloat, Rounded 'TowardInf CFloat)

backendNameT :: Tagged CFloat String

Vector Vector CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) CFloat -> m (Vector CFloat)

basicUnsafeThaw :: PrimMonad m => Vector CFloat -> m (Mutable Vector (PrimState m) CFloat)

basicLength :: Vector CFloat -> Int

basicUnsafeSlice :: Int -> Int -> Vector CFloat -> Vector CFloat

basicUnsafeIndexM :: Monad m => Vector CFloat -> Int -> m CFloat

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) CFloat -> Vector CFloat -> m ()

elemseq :: Vector CFloat -> CFloat -> b -> b

MVector MVector CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

basicLength :: MVector s CFloat -> Int

basicUnsafeSlice :: Int -> Int -> MVector s CFloat -> MVector s CFloat

basicOverlaps :: MVector s CFloat -> MVector s CFloat -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) CFloat)

basicInitialize :: PrimMonad m => MVector (PrimState m) CFloat -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> CFloat -> m (MVector (PrimState m) CFloat)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) CFloat -> Int -> m CFloat

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) CFloat -> Int -> CFloat -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) CFloat -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) CFloat -> CFloat -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) CFloat -> MVector (PrimState m) CFloat -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) CFloat -> MVector (PrimState m) CFloat -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) CFloat -> Int -> m (MVector (PrimState m) CFloat)

RoundedSqrt_Vector Vector CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

map_roundedSqrt :: RoundingMode -> Vector CFloat -> Vector CFloat

RoundedSqrt_Vector Vector CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

map_roundedSqrt :: RoundingMode -> Vector CFloat -> Vector CFloat

RoundedFractional_Vector Vector CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

zipWith_roundedDiv :: RoundingMode -> Vector CFloat -> Vector CFloat -> Vector CFloat

RoundedFractional_Vector Vector CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

zipWith_roundedDiv :: RoundingMode -> Vector CFloat -> Vector CFloat -> Vector CFloat

RoundedRing_Vector Vector CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

roundedSum :: RoundingMode -> Vector CFloat -> CFloat

zipWith_roundedAdd :: RoundingMode -> Vector CFloat -> Vector CFloat -> Vector CFloat

zipWith_roundedSub :: RoundingMode -> Vector CFloat -> Vector CFloat -> Vector CFloat

zipWith_roundedMul :: RoundingMode -> Vector CFloat -> Vector CFloat -> Vector CFloat

zipWith3_roundedFusedMultiplyAdd :: RoundingMode -> Vector CFloat -> Vector CFloat -> Vector CFloat -> Vector CFloat

RoundedRing_Vector Vector CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

roundedSum :: RoundingMode -> Vector CFloat -> CFloat

zipWith_roundedAdd :: RoundingMode -> Vector CFloat -> Vector CFloat -> Vector CFloat

zipWith_roundedSub :: RoundingMode -> Vector CFloat -> Vector CFloat -> Vector CFloat

zipWith_roundedMul :: RoundingMode -> Vector CFloat -> Vector CFloat -> Vector CFloat

zipWith3_roundedFusedMultiplyAdd :: RoundingMode -> Vector CFloat -> Vector CFloat -> Vector CFloat -> Vector CFloat

type Rep CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

type Rep CFloat = D1 ('MetaData "CFloat" "Numeric.Rounded.Hardware.Backend.C" "rounded-hw-0.2.0-G2mMTdTBXOG87Ub6xfZ4rG" 'True) (C1 ('MetaCons "CFloat" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Float)))

newtype Vector CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

newtype Vector CFloat = V_CFloat (Vector Float)

newtype MVector s CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

newtype MVector s CFloat = MV_CFloat (MVector s Float)

newtype CDouble

A wrapper providing particular instances for RoundedRing, RoundedFractional and RoundedSqrt.

This type is different from CDouble from Foreign.C.Types.

Constructors

CDouble Double

Instances

Eq CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

(==) :: CDouble -> CDouble -> Bool

(/=) :: CDouble -> CDouble -> Bool

Num CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

(+) :: CDouble -> CDouble -> CDouble

(-) :: CDouble -> CDouble -> CDouble

(*) :: CDouble -> CDouble -> CDouble

negate :: CDouble -> CDouble

abs :: CDouble -> CDouble

signum :: CDouble -> CDouble

fromInteger :: Integer -> CDouble

Ord CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

compare :: CDouble -> CDouble -> Ordering

(<) :: CDouble -> CDouble -> Bool

(<=) :: CDouble -> CDouble -> Bool

(>) :: CDouble -> CDouble -> Bool

(>=) :: CDouble -> CDouble -> Bool

max :: CDouble -> CDouble -> CDouble

min :: CDouble -> CDouble -> CDouble

Show CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

showsPrec :: Int -> CDouble -> ShowS

show :: CDouble -> String

showList :: [CDouble] -> ShowS

Generic CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Associated Types

type Rep CDouble :: Type -> Type

Methods

from :: CDouble -> Rep CDouble x

to :: Rep CDouble x -> CDouble

Storable CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

sizeOf :: CDouble -> Int

alignment :: CDouble -> Int

peekElemOff :: Ptr CDouble -> Int -> IO CDouble

pokeElemOff :: Ptr CDouble -> Int -> CDouble -> IO ()

peekByteOff :: Ptr b -> Int -> IO CDouble

pokeByteOff :: Ptr b -> Int -> CDouble -> IO ()

peek :: Ptr CDouble -> IO CDouble

poke :: Ptr CDouble -> CDouble -> IO ()

NFData CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

rnf :: CDouble -> ()

Unbox CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

RoundedSqrt CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

roundedSqrt :: RoundingMode -> CDouble -> CDouble

intervalSqrt :: Rounded 'TowardNegInf CDouble -> Rounded 'TowardInf CDouble -> (Rounded 'TowardNegInf CDouble, Rounded 'TowardInf CDouble)

RoundedFractional CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

roundedDiv :: RoundingMode -> CDouble -> CDouble -> CDouble

roundedRecip :: RoundingMode -> CDouble -> CDouble

roundedFromRational :: RoundingMode -> Rational -> CDouble

roundedFromRealFloat :: RealFloat b => RoundingMode -> b -> CDouble

intervalDiv :: Rounded 'TowardNegInf CDouble -> Rounded 'TowardInf CDouble -> Rounded 'TowardNegInf CDouble -> Rounded 'TowardInf CDouble -> (Rounded 'TowardNegInf CDouble, Rounded 'TowardInf CDouble)

intervalDivAdd :: Rounded 'TowardNegInf CDouble -> Rounded 'TowardInf CDouble -> Rounded 'TowardNegInf CDouble -> Rounded 'TowardInf CDouble -> Rounded 'TowardNegInf CDouble -> Rounded 'TowardInf CDouble -> (Rounded 'TowardNegInf CDouble, Rounded 'TowardInf CDouble)

intervalRecip :: Rounded 'TowardNegInf CDouble -> Rounded 'TowardInf CDouble -> (Rounded 'TowardNegInf CDouble, Rounded 'TowardInf CDouble)

intervalFromRational :: Rational -> (Rounded 'TowardNegInf CDouble, Rounded 'TowardInf CDouble)

RoundedRing CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

roundedAdd :: RoundingMode -> CDouble -> CDouble -> CDouble

roundedSub :: RoundingMode -> CDouble -> CDouble -> CDouble

roundedMul :: RoundingMode -> CDouble -> CDouble -> CDouble

roundedFusedMultiplyAdd :: RoundingMode -> CDouble -> CDouble -> CDouble -> CDouble

roundedFromInteger :: RoundingMode -> Integer -> CDouble

intervalAdd :: Rounded 'TowardNegInf CDouble -> Rounded 'TowardInf CDouble -> Rounded 'TowardNegInf CDouble -> Rounded 'TowardInf CDouble -> (Rounded 'TowardNegInf CDouble, Rounded 'TowardInf CDouble)

intervalSub :: Rounded 'TowardNegInf CDouble -> Rounded 'TowardInf CDouble -> Rounded 'TowardNegInf CDouble -> Rounded 'TowardInf CDouble -> (Rounded 'TowardNegInf CDouble, Rounded 'TowardInf CDouble)

intervalMul :: Rounded 'TowardNegInf CDouble -> Rounded 'TowardInf CDouble -> Rounded 'TowardNegInf CDouble -> Rounded 'TowardInf CDouble -> (Rounded 'TowardNegInf CDouble, Rounded 'TowardInf CDouble)

intervalMulAdd :: Rounded 'TowardNegInf CDouble -> Rounded 'TowardInf CDouble -> Rounded 'TowardNegInf CDouble -> Rounded 'TowardInf CDouble -> Rounded 'TowardNegInf CDouble -> Rounded 'TowardInf CDouble -> (Rounded 'TowardNegInf CDouble, Rounded 'TowardInf CDouble)

intervalFromInteger :: Integer -> (Rounded 'TowardNegInf CDouble, Rounded 'TowardInf CDouble)

backendNameT :: Tagged CDouble String

Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) CDouble -> m (Vector CDouble)

basicUnsafeThaw :: PrimMonad m => Vector CDouble -> m (Mutable Vector (PrimState m) CDouble)

basicLength :: Vector CDouble -> Int

basicUnsafeSlice :: Int -> Int -> Vector CDouble -> Vector CDouble

basicUnsafeIndexM :: Monad m => Vector CDouble -> Int -> m CDouble

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) CDouble -> Vector CDouble -> m ()

elemseq :: Vector CDouble -> CDouble -> b -> b

MVector MVector CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

basicLength :: MVector s CDouble -> Int

basicUnsafeSlice :: Int -> Int -> MVector s CDouble -> MVector s CDouble

basicOverlaps :: MVector s CDouble -> MVector s CDouble -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) CDouble)

basicInitialize :: PrimMonad m => MVector (PrimState m) CDouble -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> CDouble -> m (MVector (PrimState m) CDouble)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) CDouble -> Int -> m CDouble

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) CDouble -> Int -> CDouble -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) CDouble -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) CDouble -> CDouble -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) CDouble -> MVector (PrimState m) CDouble -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) CDouble -> MVector (PrimState m) CDouble -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) CDouble -> Int -> m (MVector (PrimState m) CDouble)

RoundedSqrt_Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

map_roundedSqrt :: RoundingMode -> Vector CDouble -> Vector CDouble

RoundedSqrt_Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

map_roundedSqrt :: RoundingMode -> Vector CDouble -> Vector CDouble

RoundedFractional_Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

zipWith_roundedDiv :: RoundingMode -> Vector CDouble -> Vector CDouble -> Vector CDouble

RoundedFractional_Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

zipWith_roundedDiv :: RoundingMode -> Vector CDouble -> Vector CDouble -> Vector CDouble

RoundedRing_Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

roundedSum :: RoundingMode -> Vector CDouble -> CDouble

zipWith_roundedAdd :: RoundingMode -> Vector CDouble -> Vector CDouble -> Vector CDouble

zipWith_roundedSub :: RoundingMode -> Vector CDouble -> Vector CDouble -> Vector CDouble

zipWith_roundedMul :: RoundingMode -> Vector CDouble -> Vector CDouble -> Vector CDouble

zipWith3_roundedFusedMultiplyAdd :: RoundingMode -> Vector CDouble -> Vector CDouble -> Vector CDouble -> Vector CDouble

RoundedRing_Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

roundedSum :: RoundingMode -> Vector CDouble -> CDouble

zipWith_roundedAdd :: RoundingMode -> Vector CDouble -> Vector CDouble -> Vector CDouble

zipWith_roundedSub :: RoundingMode -> Vector CDouble -> Vector CDouble -> Vector CDouble

zipWith_roundedMul :: RoundingMode -> Vector CDouble -> Vector CDouble -> Vector CDouble

zipWith3_roundedFusedMultiplyAdd :: RoundingMode -> Vector CDouble -> Vector CDouble -> Vector CDouble -> Vector CDouble

type Rep CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

type Rep CDouble = D1 ('MetaData "CDouble" "Numeric.Rounded.Hardware.Backend.C" "rounded-hw-0.2.0-G2mMTdTBXOG87Ub6xfZ4rG" 'True) (C1 ('MetaCons "CDouble" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Double)))

newtype Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

newtype Vector CDouble = V_CDouble (Vector Double)

newtype MVector s CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

newtype MVector s CDouble = MV_CDouble (MVector s Double)

data family MVector s a

Instances

MVector MVector Bool

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Bool -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Bool -> MVector s Bool

basicOverlaps :: MVector s Bool -> MVector s Bool -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Bool)

basicInitialize :: PrimMonad m => MVector (PrimState m) Bool -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Bool -> m (MVector (PrimState m) Bool)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m Bool

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Bool -> Int -> Bool -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Bool -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Bool -> Bool -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m (MVector (PrimState m) Bool)

MVector MVector Char

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Char -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Char -> MVector s Char

basicOverlaps :: MVector s Char -> MVector s Char -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Char)

basicInitialize :: PrimMonad m => MVector (PrimState m) Char -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Char -> m (MVector (PrimState m) Char)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Char -> Int -> m Char

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Char -> Int -> Char -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Char -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Char -> Char -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Char -> Int -> m (MVector (PrimState m) Char)

MVector MVector Double

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Double -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Double -> MVector s Double

basicOverlaps :: MVector s Double -> MVector s Double -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Double)

basicInitialize :: PrimMonad m => MVector (PrimState m) Double -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Double -> m (MVector (PrimState m) Double)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Double -> Int -> m Double

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Double -> Int -> Double -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Double -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Double -> Double -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Double -> Int -> m (MVector (PrimState m) Double)

MVector MVector Float

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Float -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Float -> MVector s Float

basicOverlaps :: MVector s Float -> MVector s Float -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Float)

basicInitialize :: PrimMonad m => MVector (PrimState m) Float -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Float -> m (MVector (PrimState m) Float)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Float -> Int -> m Float

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Float -> Int -> Float -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Float -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Float -> Float -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Float -> Int -> m (MVector (PrimState m) Float)

MVector MVector Int

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Int -> MVector s Int

basicOverlaps :: MVector s Int -> MVector s Int -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int)

basicInitialize :: PrimMonad m => MVector (PrimState m) Int -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Int -> m (MVector (PrimState m) Int)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int -> Int -> m Int

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int -> Int -> Int -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Int -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Int -> Int -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int -> Int -> m (MVector (PrimState m) Int)

MVector MVector Int8

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int8 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Int8 -> MVector s Int8

basicOverlaps :: MVector s Int8 -> MVector s Int8 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int8)

basicInitialize :: PrimMonad m => MVector (PrimState m) Int8 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Int8 -> m (MVector (PrimState m) Int8)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> m Int8

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> Int8 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Int8 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Int8 -> Int8 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int8 -> MVector (PrimState m) Int8 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int8 -> MVector (PrimState m) Int8 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> m (MVector (PrimState m) Int8)

MVector MVector Int16

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int16 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Int16 -> MVector s Int16

basicOverlaps :: MVector s Int16 -> MVector s Int16 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int16)

basicInitialize :: PrimMonad m => MVector (PrimState m) Int16 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Int16 -> m (MVector (PrimState m) Int16)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> m Int16

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> Int16 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Int16 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Int16 -> Int16 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int16 -> MVector (PrimState m) Int16 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int16 -> MVector (PrimState m) Int16 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> m (MVector (PrimState m) Int16)

MVector MVector Int32

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int32 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Int32 -> MVector s Int32

basicOverlaps :: MVector s Int32 -> MVector s Int32 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int32)

basicInitialize :: PrimMonad m => MVector (PrimState m) Int32 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Int32 -> m (MVector (PrimState m) Int32)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> m Int32

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> Int32 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Int32 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Int32 -> Int32 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int32 -> MVector (PrimState m) Int32 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int32 -> MVector (PrimState m) Int32 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> m (MVector (PrimState m) Int32)

MVector MVector Int64

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int64 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Int64 -> MVector s Int64

basicOverlaps :: MVector s Int64 -> MVector s Int64 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int64)

basicInitialize :: PrimMonad m => MVector (PrimState m) Int64 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Int64 -> m (MVector (PrimState m) Int64)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> m Int64

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> Int64 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Int64 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Int64 -> Int64 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int64 -> MVector (PrimState m) Int64 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int64 -> MVector (PrimState m) Int64 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> m (MVector (PrimState m) Int64)

MVector MVector Word

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Word -> MVector s Word

basicOverlaps :: MVector s Word -> MVector s Word -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word)

basicInitialize :: PrimMonad m => MVector (PrimState m) Word -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Word -> m (MVector (PrimState m) Word)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word -> Int -> m Word

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word -> Int -> Word -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Word -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Word -> Word -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word -> Int -> m (MVector (PrimState m) Word)

MVector MVector Word8

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word8 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Word8 -> MVector s Word8

basicOverlaps :: MVector s Word8 -> MVector s Word8 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word8)

basicInitialize :: PrimMonad m => MVector (PrimState m) Word8 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Word8 -> m (MVector (PrimState m) Word8)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m Word8

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> Word8 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Word8 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Word8 -> Word8 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m (MVector (PrimState m) Word8)

MVector MVector Word16

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word16 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Word16 -> MVector s Word16

basicOverlaps :: MVector s Word16 -> MVector s Word16 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word16)

basicInitialize :: PrimMonad m => MVector (PrimState m) Word16 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Word16 -> m (MVector (PrimState m) Word16)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> m Word16

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> Word16 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Word16 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Word16 -> Word16 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word16 -> MVector (PrimState m) Word16 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word16 -> MVector (PrimState m) Word16 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> m (MVector (PrimState m) Word16)

MVector MVector Word32

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word32 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Word32 -> MVector s Word32

basicOverlaps :: MVector s Word32 -> MVector s Word32 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word32)

basicInitialize :: PrimMonad m => MVector (PrimState m) Word32 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Word32 -> m (MVector (PrimState m) Word32)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> m Word32

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> Word32 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Word32 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Word32 -> Word32 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word32 -> MVector (PrimState m) Word32 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word32 -> MVector (PrimState m) Word32 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> m (MVector (PrimState m) Word32)

MVector MVector Word64

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word64 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Word64 -> MVector s Word64

basicOverlaps :: MVector s Word64 -> MVector s Word64 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word64)

basicInitialize :: PrimMonad m => MVector (PrimState m) Word64 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Word64 -> m (MVector (PrimState m) Word64)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> m Word64

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> Word64 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Word64 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Word64 -> Word64 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word64 -> MVector (PrimState m) Word64 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word64 -> MVector (PrimState m) Word64 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> m (MVector (PrimState m) Word64)

MVector MVector ()

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s () -> Int

basicUnsafeSlice :: Int -> Int -> MVector s () -> MVector s ()

basicOverlaps :: MVector s () -> MVector s () -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) ())

basicInitialize :: PrimMonad m => MVector (PrimState m) () -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> () -> m (MVector (PrimState m) ())

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) () -> Int -> m ()

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) () -> Int -> () -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) () -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) () -> () -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) () -> MVector (PrimState m) () -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) () -> MVector (PrimState m) () -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) () -> Int -> m (MVector (PrimState m) ())

MVector MVector All

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s All -> Int

basicUnsafeSlice :: Int -> Int -> MVector s All -> MVector s All

basicOverlaps :: MVector s All -> MVector s All -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) All)

basicInitialize :: PrimMonad m => MVector (PrimState m) All -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> All -> m (MVector (PrimState m) All)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) All -> Int -> m All

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) All -> Int -> All -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) All -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) All -> All -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) All -> MVector (PrimState m) All -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) All -> MVector (PrimState m) All -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) All -> Int -> m (MVector (PrimState m) All)

MVector MVector Any

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Any -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Any -> MVector s Any

basicOverlaps :: MVector s Any -> MVector s Any -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Any)

basicInitialize :: PrimMonad m => MVector (PrimState m) Any -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Any -> m (MVector (PrimState m) Any)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Any -> Int -> m Any

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Any -> Int -> Any -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Any -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Any -> Any -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Any -> MVector (PrimState m) Any -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Any -> MVector (PrimState m) Any -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Any -> Int -> m (MVector (PrimState m) Any)

MVector MVector CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

basicLength :: MVector s CDouble -> Int

basicUnsafeSlice :: Int -> Int -> MVector s CDouble -> MVector s CDouble

basicOverlaps :: MVector s CDouble -> MVector s CDouble -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) CDouble)

basicInitialize :: PrimMonad m => MVector (PrimState m) CDouble -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> CDouble -> m (MVector (PrimState m) CDouble)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) CDouble -> Int -> m CDouble

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) CDouble -> Int -> CDouble -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) CDouble -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) CDouble -> CDouble -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) CDouble -> MVector (PrimState m) CDouble -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) CDouble -> MVector (PrimState m) CDouble -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) CDouble -> Int -> m (MVector (PrimState m) CDouble)

MVector MVector CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

basicLength :: MVector s CFloat -> Int

basicUnsafeSlice :: Int -> Int -> MVector s CFloat -> MVector s CFloat

basicOverlaps :: MVector s CFloat -> MVector s CFloat -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) CFloat)

basicInitialize :: PrimMonad m => MVector (PrimState m) CFloat -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> CFloat -> m (MVector (PrimState m) CFloat)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) CFloat -> Int -> m CFloat

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) CFloat -> Int -> CFloat -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) CFloat -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) CFloat -> CFloat -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) CFloat -> MVector (PrimState m) CFloat -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) CFloat -> MVector (PrimState m) CFloat -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) CFloat -> Int -> m (MVector (PrimState m) CFloat)

MVector MVector CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

Methods

basicLength :: MVector s CDouble -> Int

basicUnsafeSlice :: Int -> Int -> MVector s CDouble -> MVector s CDouble

basicOverlaps :: MVector s CDouble -> MVector s CDouble -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) CDouble)

basicInitialize :: PrimMonad m => MVector (PrimState m) CDouble -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> CDouble -> m (MVector (PrimState m) CDouble)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) CDouble -> Int -> m CDouble

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) CDouble -> Int -> CDouble -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) CDouble -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) CDouble -> CDouble -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) CDouble -> MVector (PrimState m) CDouble -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) CDouble -> MVector (PrimState m) CDouble -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) CDouble -> Int -> m (MVector (PrimState m) CDouble)

Unbox a => MVector MVector (Complex a)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (Complex a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Complex a) -> MVector s (Complex a)

basicOverlaps :: MVector s (Complex a) -> MVector s (Complex a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Complex a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Complex a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Complex a -> m (MVector (PrimState m) (Complex a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Complex a) -> Int -> m (Complex a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Complex a) -> Int -> Complex a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Complex a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Complex a) -> Complex a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Complex a) -> MVector (PrimState m) (Complex a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Complex a) -> MVector (PrimState m) (Complex a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Complex a) -> Int -> m (MVector (PrimState m) (Complex a))

Unbox a => MVector MVector (Min a)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (Min a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Min a) -> MVector s (Min a)

basicOverlaps :: MVector s (Min a) -> MVector s (Min a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Min a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Min a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Min a -> m (MVector (PrimState m) (Min a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Min a) -> Int -> m (Min a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Min a) -> Int -> Min a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Min a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Min a) -> Min a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Min a) -> MVector (PrimState m) (Min a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Min a) -> MVector (PrimState m) (Min a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Min a) -> Int -> m (MVector (PrimState m) (Min a))

Unbox a => MVector MVector (Max a)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (Max a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Max a) -> MVector s (Max a)

basicOverlaps :: MVector s (Max a) -> MVector s (Max a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Max a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Max a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Max a -> m (MVector (PrimState m) (Max a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Max a) -> Int -> m (Max a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Max a) -> Int -> Max a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Max a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Max a) -> Max a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Max a) -> MVector (PrimState m) (Max a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Max a) -> MVector (PrimState m) (Max a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Max a) -> Int -> m (MVector (PrimState m) (Max a))

Unbox a => MVector MVector (First a)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (First a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (First a) -> MVector s (First a)

basicOverlaps :: MVector s (First a) -> MVector s (First a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (First a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (First a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> First a -> m (MVector (PrimState m) (First a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (First a) -> Int -> m (First a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (First a) -> Int -> First a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (First a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (First a) -> First a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (First a) -> MVector (PrimState m) (First a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (First a) -> MVector (PrimState m) (First a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (First a) -> Int -> m (MVector (PrimState m) (First a))

Unbox a => MVector MVector (Last a)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (Last a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Last a) -> MVector s (Last a)

basicOverlaps :: MVector s (Last a) -> MVector s (Last a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Last a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Last a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Last a -> m (MVector (PrimState m) (Last a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Last a) -> Int -> m (Last a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Last a) -> Int -> Last a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Last a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Last a) -> Last a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Last a) -> MVector (PrimState m) (Last a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Last a) -> MVector (PrimState m) (Last a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Last a) -> Int -> m (MVector (PrimState m) (Last a))

Unbox a => MVector MVector (WrappedMonoid a)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (WrappedMonoid a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (WrappedMonoid a) -> MVector s (WrappedMonoid a)

basicOverlaps :: MVector s (WrappedMonoid a) -> MVector s (WrappedMonoid a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (WrappedMonoid a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (WrappedMonoid a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> WrappedMonoid a -> m (MVector (PrimState m) (WrappedMonoid a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (WrappedMonoid a) -> Int -> m (WrappedMonoid a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (WrappedMonoid a) -> Int -> WrappedMonoid a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (WrappedMonoid a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (WrappedMonoid a) -> WrappedMonoid a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (WrappedMonoid a) -> MVector (PrimState m) (WrappedMonoid a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (WrappedMonoid a) -> MVector (PrimState m) (WrappedMonoid a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (WrappedMonoid a) -> Int -> m (MVector (PrimState m) (WrappedMonoid a))

Unbox a => MVector MVector (Identity a)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (Identity a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Identity a) -> MVector s (Identity a)

basicOverlaps :: MVector s (Identity a) -> MVector s (Identity a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Identity a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Identity a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Identity a -> m (MVector (PrimState m) (Identity a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Identity a) -> Int -> m (Identity a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Identity a) -> Int -> Identity a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Identity a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Identity a) -> Identity a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Identity a) -> MVector (PrimState m) (Identity a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Identity a) -> MVector (PrimState m) (Identity a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Identity a) -> Int -> m (MVector (PrimState m) (Identity a))

Unbox a => MVector MVector (Dual a)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (Dual a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Dual a) -> MVector s (Dual a)

basicOverlaps :: MVector s (Dual a) -> MVector s (Dual a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Dual a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Dual a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Dual a -> m (MVector (PrimState m) (Dual a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Dual a) -> Int -> m (Dual a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Dual a) -> Int -> Dual a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Dual a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Dual a) -> Dual a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Dual a) -> MVector (PrimState m) (Dual a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Dual a) -> MVector (PrimState m) (Dual a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Dual a) -> Int -> m (MVector (PrimState m) (Dual a))

Unbox a => MVector MVector (Sum a)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (Sum a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Sum a) -> MVector s (Sum a)

basicOverlaps :: MVector s (Sum a) -> MVector s (Sum a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Sum a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Sum a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Sum a -> m (MVector (PrimState m) (Sum a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Sum a) -> Int -> m (Sum a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Sum a) -> Int -> Sum a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Sum a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Sum a) -> Sum a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Sum a) -> MVector (PrimState m) (Sum a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Sum a) -> MVector (PrimState m) (Sum a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Sum a) -> Int -> m (MVector (PrimState m) (Sum a))

Unbox a => MVector MVector (Product a)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (Product a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Product a) -> MVector s (Product a)

basicOverlaps :: MVector s (Product a) -> MVector s (Product a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Product a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Product a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Product a -> m (MVector (PrimState m) (Product a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Product a) -> Int -> m (Product a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Product a) -> Int -> Product a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Product a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Product a) -> Product a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Product a) -> MVector (PrimState m) (Product a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Product a) -> MVector (PrimState m) (Product a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Product a) -> Int -> m (MVector (PrimState m) (Product a))

Unbox a => MVector MVector (Down a)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (Down a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Down a) -> MVector s (Down a)

basicOverlaps :: MVector s (Down a) -> MVector s (Down a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Down a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Down a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Down a -> m (MVector (PrimState m) (Down a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Down a) -> Int -> m (Down a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Down a) -> Int -> Down a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Down a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Down a) -> Down a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Down a) -> MVector (PrimState m) (Down a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Down a) -> MVector (PrimState m) (Down a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Down a) -> Int -> m (MVector (PrimState m) (Down a))

Unbox a => MVector MVector (ViaRational a)

Defined in Numeric.Rounded.Hardware.Backend.ViaRational

Methods

basicLength :: MVector s (ViaRational a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (ViaRational a) -> MVector s (ViaRational a)

basicOverlaps :: MVector s (ViaRational a) -> MVector s (ViaRational a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (ViaRational a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (ViaRational a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> ViaRational a -> m (MVector (PrimState m) (ViaRational a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (ViaRational a) -> Int -> m (ViaRational a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (ViaRational a) -> Int -> ViaRational a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (ViaRational a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (ViaRational a) -> ViaRational a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (ViaRational a) -> MVector (PrimState m) (ViaRational a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (ViaRational a) -> MVector (PrimState m) (ViaRational a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (ViaRational a) -> Int -> m (MVector (PrimState m) (ViaRational a))

(Unbox a, Ord a, Fractional a) => MVector MVector (Interval a)

Defined in Numeric.Rounded.Hardware.Interval.NonEmpty

Methods

basicLength :: MVector s (Interval a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Interval a) -> MVector s (Interval a)

basicOverlaps :: MVector s (Interval a) -> MVector s (Interval a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Interval a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Interval a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Interval a -> m (MVector (PrimState m) (Interval a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Interval a) -> Int -> m (Interval a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Interval a) -> Int -> Interval a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Interval a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Interval a) -> Interval a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Interval a) -> MVector (PrimState m) (Interval a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Interval a) -> MVector (PrimState m) (Interval a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Interval a) -> Int -> m (MVector (PrimState m) (Interval a))

(Unbox a, Ord a, Fractional a) => MVector MVector (Interval a)

Defined in Numeric.Rounded.Hardware.Interval

Methods

basicLength :: MVector s (Interval a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Interval a) -> MVector s (Interval a)

basicOverlaps :: MVector s (Interval a) -> MVector s (Interval a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Interval a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Interval a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Interval a -> m (MVector (PrimState m) (Interval a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Interval a) -> Int -> m (Interval a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Interval a) -> Int -> Interval a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Interval a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Interval a) -> Interval a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Interval a) -> MVector (PrimState m) (Interval a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Interval a) -> MVector (PrimState m) (Interval a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Interval a) -> Int -> m (MVector (PrimState m) (Interval a))

(Unbox a, Unbox b) => MVector MVector (a, b)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (a, b) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (a, b) -> MVector s (a, b)

basicOverlaps :: MVector s (a, b) -> MVector s (a, b) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b))

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b) -> m (MVector (PrimState m) (a, b))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b) -> Int -> m (a, b)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b) -> Int -> (a, b) -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (a, b) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (a, b) -> (a, b) -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b) -> MVector (PrimState m) (a, b) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b) -> MVector (PrimState m) (a, b) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b) -> Int -> m (MVector (PrimState m) (a, b))

(Unbox a, Unbox b) => MVector MVector (Arg a b)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (Arg a b) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Arg a b) -> MVector s (Arg a b)

basicOverlaps :: MVector s (Arg a b) -> MVector s (Arg a b) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Arg a b))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Arg a b) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Arg a b -> m (MVector (PrimState m) (Arg a b))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Arg a b) -> Int -> m (Arg a b)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Arg a b) -> Int -> Arg a b -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Arg a b) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Arg a b) -> Arg a b -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Arg a b) -> MVector (PrimState m) (Arg a b) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Arg a b) -> MVector (PrimState m) (Arg a b) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Arg a b) -> Int -> m (MVector (PrimState m) (Arg a b))

Unbox a => MVector MVector (Rounded r a)

Defined in Numeric.Rounded.Hardware.Internal.Rounding

Methods

basicLength :: MVector s (Rounded r a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Rounded r a) -> MVector s (Rounded r a)

basicOverlaps :: MVector s (Rounded r a) -> MVector s (Rounded r a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Rounded r a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Rounded r a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Rounded r a -> m (MVector (PrimState m) (Rounded r a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Rounded r a) -> Int -> m (Rounded r a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Rounded r a) -> Int -> Rounded r a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Rounded r a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Rounded r a) -> Rounded r a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Rounded r a) -> MVector (PrimState m) (Rounded r a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Rounded r a) -> MVector (PrimState m) (Rounded r a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Rounded r a) -> Int -> m (MVector (PrimState m) (Rounded r a))

(Unbox a, Unbox b, Unbox c) => MVector MVector (a, b, c)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (a, b, c) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c) -> MVector s (a, b, c)

basicOverlaps :: MVector s (a, b, c) -> MVector s (a, b, c) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c))

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c) -> m (MVector (PrimState m) (a, b, c))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c) -> Int -> m (a, b, c)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c) -> Int -> (a, b, c) -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c) -> (a, b, c) -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c) -> MVector (PrimState m) (a, b, c) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c) -> MVector (PrimState m) (a, b, c) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c) -> Int -> m (MVector (PrimState m) (a, b, c))

Unbox a => MVector MVector (Const a b)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (Const a b) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Const a b) -> MVector s (Const a b)

basicOverlaps :: MVector s (Const a b) -> MVector s (Const a b) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Const a b))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Const a b) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Const a b -> m (MVector (PrimState m) (Const a b))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Const a b) -> Int -> m (Const a b)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Const a b) -> Int -> Const a b -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Const a b) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Const a b) -> Const a b -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Const a b) -> MVector (PrimState m) (Const a b) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Const a b) -> MVector (PrimState m) (Const a b) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Const a b) -> Int -> m (MVector (PrimState m) (Const a b))

Unbox (f a) => MVector MVector (Alt f a)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (Alt f a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Alt f a) -> MVector s (Alt f a)

basicOverlaps :: MVector s (Alt f a) -> MVector s (Alt f a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Alt f a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Alt f a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Alt f a -> m (MVector (PrimState m) (Alt f a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Alt f a) -> Int -> m (Alt f a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Alt f a) -> Int -> Alt f a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Alt f a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Alt f a) -> Alt f a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Alt f a) -> MVector (PrimState m) (Alt f a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Alt f a) -> MVector (PrimState m) (Alt f a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Alt f a) -> Int -> m (MVector (PrimState m) (Alt f a))

(Unbox a, Unbox b, Unbox c, Unbox d) => MVector MVector (a, b, c, d)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (a, b, c, d) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c, d) -> MVector s (a, b, c, d)

basicOverlaps :: MVector s (a, b, c, d) -> MVector s (a, b, c, d) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c, d))

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c, d) -> m (MVector (PrimState m) (a, b, c, d))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> Int -> m (a, b, c, d)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> Int -> (a, b, c, d) -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> (a, b, c, d) -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> MVector (PrimState m) (a, b, c, d) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> MVector (PrimState m) (a, b, c, d) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> Int -> m (MVector (PrimState m) (a, b, c, d))

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => MVector MVector (a, b, c, d, e)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (a, b, c, d, e) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c, d, e) -> MVector s (a, b, c, d, e)

basicOverlaps :: MVector s (a, b, c, d, e) -> MVector s (a, b, c, d, e) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c, d, e))

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c, d, e) -> m (MVector (PrimState m) (a, b, c, d, e))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> Int -> m (a, b, c, d, e)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> Int -> (a, b, c, d, e) -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> (a, b, c, d, e) -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> MVector (PrimState m) (a, b, c, d, e) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> MVector (PrimState m) (a, b, c, d, e) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> Int -> m (MVector (PrimState m) (a, b, c, d, e))

Unbox (f (g a)) => MVector MVector (Compose f g a)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (Compose f g a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Compose f g a) -> MVector s (Compose f g a)

basicOverlaps :: MVector s (Compose f g a) -> MVector s (Compose f g a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Compose f g a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Compose f g a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Compose f g a -> m (MVector (PrimState m) (Compose f g a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Compose f g a) -> Int -> m (Compose f g a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Compose f g a) -> Int -> Compose f g a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Compose f g a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Compose f g a) -> Compose f g a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Compose f g a) -> MVector (PrimState m) (Compose f g a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Compose f g a) -> MVector (PrimState m) (Compose f g a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Compose f g a) -> Int -> m (MVector (PrimState m) (Compose f g a))

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => MVector MVector (a, b, c, d, e, f)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (a, b, c, d, e, f) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c, d, e, f) -> MVector s (a, b, c, d, e, f)

basicOverlaps :: MVector s (a, b, c, d, e, f) -> MVector s (a, b, c, d, e, f) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c, d, e, f))

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c, d, e, f) -> m (MVector (PrimState m) (a, b, c, d, e, f))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> Int -> m (a, b, c, d, e, f)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> Int -> (a, b, c, d, e, f) -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> MVector (PrimState m) (a, b, c, d, e, f) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> MVector (PrimState m) (a, b, c, d, e, f) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> Int -> m (MVector (PrimState m) (a, b, c, d, e, f))

NFData1 (MVector s)

Since: vector-0.12.1.0

Defined in Data.Vector.Unboxed.Base

Methods

liftRnf :: (a -> ()) -> MVector s a -> ()

NFData (MVector s a)

Defined in Data.Vector.Unboxed.Base

Methods

rnf :: MVector s a -> ()

newtype MVector s All

Defined in Data.Vector.Unboxed.Base

newtype MVector s All = MV_All (MVector s Bool)

newtype MVector s Any

Defined in Data.Vector.Unboxed.Base

newtype MVector s Any = MV_Any (MVector s Bool)

newtype MVector s Bool

Defined in Data.Vector.Unboxed.Base

newtype MVector s Bool = MV_Bool (MVector s Word8)

newtype MVector s Char

Defined in Data.Vector.Unboxed.Base

newtype MVector s Char = MV_Char (MVector s Char)

newtype MVector s Double

Defined in Data.Vector.Unboxed.Base

newtype MVector s Double = MV_Double (MVector s Double)

newtype MVector s Float

Defined in Data.Vector.Unboxed.Base

newtype MVector s Float = MV_Float (MVector s Float)

newtype MVector s Word64

Defined in Data.Vector.Unboxed.Base

newtype MVector s Word64 = MV_Word64 (MVector s Word64)

newtype MVector s Word32

Defined in Data.Vector.Unboxed.Base

newtype MVector s Word32 = MV_Word32 (MVector s Word32)

newtype MVector s Word16

Defined in Data.Vector.Unboxed.Base

newtype MVector s Word16 = MV_Word16 (MVector s Word16)

newtype MVector s Word8

Defined in Data.Vector.Unboxed.Base

newtype MVector s Word8 = MV_Word8 (MVector s Word8)

newtype MVector s Word

Defined in Data.Vector.Unboxed.Base

newtype MVector s Word = MV_Word (MVector s Word)

newtype MVector s Int64

Defined in Data.Vector.Unboxed.Base

newtype MVector s Int64 = MV_Int64 (MVector s Int64)

newtype MVector s Int32

Defined in Data.Vector.Unboxed.Base

newtype MVector s Int32 = MV_Int32 (MVector s Int32)

newtype MVector s Int16

Defined in Data.Vector.Unboxed.Base

newtype MVector s Int16 = MV_Int16 (MVector s Int16)

newtype MVector s Int8

Defined in Data.Vector.Unboxed.Base

newtype MVector s Int8 = MV_Int8 (MVector s Int8)

newtype MVector s Int

Defined in Data.Vector.Unboxed.Base

newtype MVector s Int = MV_Int (MVector s Int)

newtype MVector s ()

Defined in Data.Vector.Unboxed.Base

newtype MVector s () = MV_Unit Int

newtype MVector s CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

newtype MVector s CFloat = MV_CFloat (MVector s Float)

newtype MVector s CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

newtype MVector s CDouble = MV_CDouble (MVector s Double)

newtype MVector s CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

newtype MVector s CDouble = MV_CDouble (MVector s Double)

newtype MVector s (WrappedMonoid a)

Defined in Data.Vector.Unboxed.Base

newtype MVector s (WrappedMonoid a) = MV_WrappedMonoid (MVector s a)

newtype MVector s (Last a)

Defined in Data.Vector.Unboxed.Base

newtype MVector s (Last a) = MV_Last (MVector s a)

newtype MVector s (First a)

Defined in Data.Vector.Unboxed.Base

newtype MVector s (First a) = MV_First (MVector s a)

newtype MVector s (Max a)

Defined in Data.Vector.Unboxed.Base

newtype MVector s (Max a) = MV_Max (MVector s a)

newtype MVector s (Min a)

Defined in Data.Vector.Unboxed.Base

newtype MVector s (Min a) = MV_Min (MVector s a)

newtype MVector s (Product a)

Defined in Data.Vector.Unboxed.Base

newtype MVector s (Product a) = MV_Product (MVector s a)

newtype MVector s (Sum a)

Defined in Data.Vector.Unboxed.Base

newtype MVector s (Sum a) = MV_Sum (MVector s a)

newtype MVector s (Dual a)

Defined in Data.Vector.Unboxed.Base

newtype MVector s (Dual a) = MV_Dual (MVector s a)

newtype MVector s (Down a)

Defined in Data.Vector.Unboxed.Base

newtype MVector s (Down a) = MV_Down (MVector s a)

newtype MVector s (Identity a)

Defined in Data.Vector.Unboxed.Base

newtype MVector s (Identity a) = MV_Identity (MVector s a)

newtype MVector s (Complex a)

Defined in Data.Vector.Unboxed.Base

newtype MVector s (Complex a) = MV_Complex (MVector s (a, a))

newtype MVector s (ViaRational a)

Defined in Numeric.Rounded.Hardware.Backend.ViaRational

newtype MVector s (ViaRational a) = MV_ViaRational (MVector s a)

newtype MVector s (Interval a)

Defined in Numeric.Rounded.Hardware.Interval.NonEmpty

newtype MVector s (Interval a) = MV_Interval (MVector s (a, a))

newtype MVector s (Interval a)

Defined in Numeric.Rounded.Hardware.Interval

newtype MVector s (Interval a) = MV_Interval (MVector s (a, a))

newtype MVector s (Rounded r a)

Defined in Numeric.Rounded.Hardware.Internal.Rounding

newtype MVector s (Rounded r a) = MV_Rounded (MVector s a)

data MVector s (a, b)

Defined in Data.Vector.Unboxed.Base

data MVector s (a, b) = MV_2 !Int !(MVector s a) !(MVector s b)

newtype MVector s (Arg a b)

Defined in Data.Vector.Unboxed.Base

newtype MVector s (Arg a b) = MV_Arg (MVector s (a, b))

data MVector s (a, b, c)

Defined in Data.Vector.Unboxed.Base

data MVector s (a, b, c) = MV_3 !Int !(MVector s a) !(MVector s b) !(MVector s c)

newtype MVector s (Alt f a)

Defined in Data.Vector.Unboxed.Base

newtype MVector s (Alt f a) = MV_Alt (MVector s (f a))

newtype MVector s (Const a b)

Defined in Data.Vector.Unboxed.Base

newtype MVector s (Const a b) = MV_Const (MVector s a)

data MVector s (a, b, c, d)

Defined in Data.Vector.Unboxed.Base

data MVector s (a, b, c, d) = MV_4 !Int !(MVector s a) !(MVector s b) !(MVector s c) !(MVector s d)

data MVector s (a, b, c, d, e)

Defined in Data.Vector.Unboxed.Base

data MVector s (a, b, c, d, e) = MV_5 !Int !(MVector s a) !(MVector s b) !(MVector s c) !(MVector s d) !(MVector s e)

newtype MVector s (Compose f g a)

Defined in Data.Vector.Unboxed.Base

newtype MVector s (Compose f g a) = MV_Compose (MVector s (f (g a)))

data MVector s (a, b, c, d, e, f)

Defined in Data.Vector.Unboxed.Base

data MVector s (a, b, c, d, e, f) = MV_6 !Int !(MVector s a) !(MVector s b) !(MVector s c) !(MVector s d) !(MVector s e) !(MVector s f)

data family Vector a

Instances

NFData1 Vector

Since: vector-0.12.1.0

Defined in Data.Vector.Unboxed.Base

Methods

liftRnf :: (a -> ()) -> Vector a -> ()

Vector Vector Bool

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Bool -> m (Vector Bool)

basicUnsafeThaw :: PrimMonad m => Vector Bool -> m (Mutable Vector (PrimState m) Bool)

basicLength :: Vector Bool -> Int

basicUnsafeSlice :: Int -> Int -> Vector Bool -> Vector Bool

basicUnsafeIndexM :: Monad m => Vector Bool -> Int -> m Bool

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Bool -> Vector Bool -> m ()

elemseq :: Vector Bool -> Bool -> b -> b

Vector Vector Char

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Char -> m (Vector Char)

basicUnsafeThaw :: PrimMonad m => Vector Char -> m (Mutable Vector (PrimState m) Char)

basicLength :: Vector Char -> Int

basicUnsafeSlice :: Int -> Int -> Vector Char -> Vector Char

basicUnsafeIndexM :: Monad m => Vector Char -> Int -> m Char

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Char -> Vector Char -> m ()

elemseq :: Vector Char -> Char -> b -> b

Vector Vector Double

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Double -> m (Vector Double)

basicUnsafeThaw :: PrimMonad m => Vector Double -> m (Mutable Vector (PrimState m) Double)

basicLength :: Vector Double -> Int

basicUnsafeSlice :: Int -> Int -> Vector Double -> Vector Double

basicUnsafeIndexM :: Monad m => Vector Double -> Int -> m Double

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Double -> Vector Double -> m ()

elemseq :: Vector Double -> Double -> b -> b

Vector Vector Float

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Float -> m (Vector Float)

basicUnsafeThaw :: PrimMonad m => Vector Float -> m (Mutable Vector (PrimState m) Float)

basicLength :: Vector Float -> Int

basicUnsafeSlice :: Int -> Int -> Vector Float -> Vector Float

basicUnsafeIndexM :: Monad m => Vector Float -> Int -> m Float

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Float -> Vector Float -> m ()

elemseq :: Vector Float -> Float -> b -> b

Vector Vector Int

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int -> m (Vector Int)

basicUnsafeThaw :: PrimMonad m => Vector Int -> m (Mutable Vector (PrimState m) Int)

basicLength :: Vector Int -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int -> Vector Int

basicUnsafeIndexM :: Monad m => Vector Int -> Int -> m Int

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int -> Vector Int -> m ()

elemseq :: Vector Int -> Int -> b -> b

Vector Vector Int8

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int8 -> m (Vector Int8)

basicUnsafeThaw :: PrimMonad m => Vector Int8 -> m (Mutable Vector (PrimState m) Int8)

basicLength :: Vector Int8 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int8 -> Vector Int8

basicUnsafeIndexM :: Monad m => Vector Int8 -> Int -> m Int8

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int8 -> Vector Int8 -> m ()

elemseq :: Vector Int8 -> Int8 -> b -> b

Vector Vector Int16

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int16 -> m (Vector Int16)

basicUnsafeThaw :: PrimMonad m => Vector Int16 -> m (Mutable Vector (PrimState m) Int16)

basicLength :: Vector Int16 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int16 -> Vector Int16

basicUnsafeIndexM :: Monad m => Vector Int16 -> Int -> m Int16

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int16 -> Vector Int16 -> m ()

elemseq :: Vector Int16 -> Int16 -> b -> b

Vector Vector Int32

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int32 -> m (Vector Int32)

basicUnsafeThaw :: PrimMonad m => Vector Int32 -> m (Mutable Vector (PrimState m) Int32)

basicLength :: Vector Int32 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int32 -> Vector Int32

basicUnsafeIndexM :: Monad m => Vector Int32 -> Int -> m Int32

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int32 -> Vector Int32 -> m ()

elemseq :: Vector Int32 -> Int32 -> b -> b

Vector Vector Int64

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> m (Vector Int64)

basicUnsafeThaw :: PrimMonad m => Vector Int64 -> m (Mutable Vector (PrimState m) Int64)

basicLength :: Vector Int64 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int64 -> Vector Int64

basicUnsafeIndexM :: Monad m => Vector Int64 -> Int -> m Int64

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> Vector Int64 -> m ()

elemseq :: Vector Int64 -> Int64 -> b -> b

Vector Vector Word

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word -> m (Vector Word)

basicUnsafeThaw :: PrimMonad m => Vector Word -> m (Mutable Vector (PrimState m) Word)

basicLength :: Vector Word -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word -> Vector Word

basicUnsafeIndexM :: Monad m => Vector Word -> Int -> m Word

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word -> Vector Word -> m ()

elemseq :: Vector Word -> Word -> b -> b

Vector Vector Word8

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> m (Vector Word8)

basicUnsafeThaw :: PrimMonad m => Vector Word8 -> m (Mutable Vector (PrimState m) Word8)

basicLength :: Vector Word8 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word8 -> Vector Word8

basicUnsafeIndexM :: Monad m => Vector Word8 -> Int -> m Word8

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> Vector Word8 -> m ()

elemseq :: Vector Word8 -> Word8 -> b -> b

Vector Vector Word16

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word16 -> m (Vector Word16)

basicUnsafeThaw :: PrimMonad m => Vector Word16 -> m (Mutable Vector (PrimState m) Word16)

basicLength :: Vector Word16 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word16 -> Vector Word16

basicUnsafeIndexM :: Monad m => Vector Word16 -> Int -> m Word16

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word16 -> Vector Word16 -> m ()

elemseq :: Vector Word16 -> Word16 -> b -> b

Vector Vector Word32

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word32 -> m (Vector Word32)

basicUnsafeThaw :: PrimMonad m => Vector Word32 -> m (Mutable Vector (PrimState m) Word32)

basicLength :: Vector Word32 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word32 -> Vector Word32

basicUnsafeIndexM :: Monad m => Vector Word32 -> Int -> m Word32

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word32 -> Vector Word32 -> m ()

elemseq :: Vector Word32 -> Word32 -> b -> b

Vector Vector Word64

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word64 -> m (Vector Word64)

basicUnsafeThaw :: PrimMonad m => Vector Word64 -> m (Mutable Vector (PrimState m) Word64)

basicLength :: Vector Word64 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word64 -> Vector Word64

basicUnsafeIndexM :: Monad m => Vector Word64 -> Int -> m Word64

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word64 -> Vector Word64 -> m ()

elemseq :: Vector Word64 -> Word64 -> b -> b

Vector Vector ()

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) () -> m (Vector ())

basicUnsafeThaw :: PrimMonad m => Vector () -> m (Mutable Vector (PrimState m) ())

basicLength :: Vector () -> Int

basicUnsafeSlice :: Int -> Int -> Vector () -> Vector ()

basicUnsafeIndexM :: Monad m => Vector () -> Int -> m ()

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) () -> Vector () -> m ()

elemseq :: Vector () -> () -> b -> b

Vector Vector All

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) All -> m (Vector All)

basicUnsafeThaw :: PrimMonad m => Vector All -> m (Mutable Vector (PrimState m) All)

basicLength :: Vector All -> Int

basicUnsafeSlice :: Int -> Int -> Vector All -> Vector All

basicUnsafeIndexM :: Monad m => Vector All -> Int -> m All

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) All -> Vector All -> m ()

elemseq :: Vector All -> All -> b -> b

Vector Vector Any

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Any -> m (Vector Any)

basicUnsafeThaw :: PrimMonad m => Vector Any -> m (Mutable Vector (PrimState m) Any)

basicLength :: Vector Any -> Int

basicUnsafeSlice :: Int -> Int -> Vector Any -> Vector Any

basicUnsafeIndexM :: Monad m => Vector Any -> Int -> m Any

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Any -> Vector Any -> m ()

elemseq :: Vector Any -> Any -> b -> b

Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) CDouble -> m (Vector CDouble)

basicUnsafeThaw :: PrimMonad m => Vector CDouble -> m (Mutable Vector (PrimState m) CDouble)

basicLength :: Vector CDouble -> Int

basicUnsafeSlice :: Int -> Int -> Vector CDouble -> Vector CDouble

basicUnsafeIndexM :: Monad m => Vector CDouble -> Int -> m CDouble

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) CDouble -> Vector CDouble -> m ()

elemseq :: Vector CDouble -> CDouble -> b -> b

Vector Vector CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) CFloat -> m (Vector CFloat)

basicUnsafeThaw :: PrimMonad m => Vector CFloat -> m (Mutable Vector (PrimState m) CFloat)

basicLength :: Vector CFloat -> Int

basicUnsafeSlice :: Int -> Int -> Vector CFloat -> Vector CFloat

basicUnsafeIndexM :: Monad m => Vector CFloat -> Int -> m CFloat

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) CFloat -> Vector CFloat -> m ()

elemseq :: Vector CFloat -> CFloat -> b -> b

Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) CDouble -> m (Vector CDouble)

basicUnsafeThaw :: PrimMonad m => Vector CDouble -> m (Mutable Vector (PrimState m) CDouble)

basicLength :: Vector CDouble -> Int

basicUnsafeSlice :: Int -> Int -> Vector CDouble -> Vector CDouble

basicUnsafeIndexM :: Monad m => Vector CDouble -> Int -> m CDouble

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) CDouble -> Vector CDouble -> m ()

elemseq :: Vector CDouble -> CDouble -> b -> b

RoundedSqrt_Vector Vector Double

Defined in Numeric.Rounded.Hardware.Backend.Default

Methods

map_roundedSqrt :: RoundingMode -> Vector Double -> Vector Double

RoundedSqrt_Vector Vector Float

Defined in Numeric.Rounded.Hardware.Backend.Default

Methods

map_roundedSqrt :: RoundingMode -> Vector Float -> Vector Float

RoundedSqrt_Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

map_roundedSqrt :: RoundingMode -> Vector CDouble -> Vector CDouble

RoundedSqrt_Vector Vector CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

map_roundedSqrt :: RoundingMode -> Vector CFloat -> Vector CFloat

RoundedSqrt_Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

Methods

map_roundedSqrt :: RoundingMode -> Vector CDouble -> Vector CDouble

RoundedFractional_Vector Vector Double

Defined in Numeric.Rounded.Hardware.Backend.Default

Methods

zipWith_roundedDiv :: RoundingMode -> Vector Double -> Vector Double -> Vector Double

RoundedFractional_Vector Vector Float

Defined in Numeric.Rounded.Hardware.Backend.Default

Methods

zipWith_roundedDiv :: RoundingMode -> Vector Float -> Vector Float -> Vector Float

RoundedFractional_Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

zipWith_roundedDiv :: RoundingMode -> Vector CDouble -> Vector CDouble -> Vector CDouble

RoundedFractional_Vector Vector CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

zipWith_roundedDiv :: RoundingMode -> Vector CFloat -> Vector CFloat -> Vector CFloat

RoundedFractional_Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

Methods

zipWith_roundedDiv :: RoundingMode -> Vector CDouble -> Vector CDouble -> Vector CDouble

RoundedRing_Vector Vector Double

Defined in Numeric.Rounded.Hardware.Backend.Default

Methods

roundedSum :: RoundingMode -> Vector Double -> Double

zipWith_roundedAdd :: RoundingMode -> Vector Double -> Vector Double -> Vector Double

zipWith_roundedSub :: RoundingMode -> Vector Double -> Vector Double -> Vector Double

zipWith_roundedMul :: RoundingMode -> Vector Double -> Vector Double -> Vector Double

zipWith3_roundedFusedMultiplyAdd :: RoundingMode -> Vector Double -> Vector Double -> Vector Double -> Vector Double

RoundedRing_Vector Vector Float

Defined in Numeric.Rounded.Hardware.Backend.Default

Methods

roundedSum :: RoundingMode -> Vector Float -> Float

zipWith_roundedAdd :: RoundingMode -> Vector Float -> Vector Float -> Vector Float

zipWith_roundedSub :: RoundingMode -> Vector Float -> Vector Float -> Vector Float

zipWith_roundedMul :: RoundingMode -> Vector Float -> Vector Float -> Vector Float

zipWith3_roundedFusedMultiplyAdd :: RoundingMode -> Vector Float -> Vector Float -> Vector Float -> Vector Float

RoundedRing_Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

roundedSum :: RoundingMode -> Vector CDouble -> CDouble

zipWith_roundedAdd :: RoundingMode -> Vector CDouble -> Vector CDouble -> Vector CDouble

zipWith_roundedSub :: RoundingMode -> Vector CDouble -> Vector CDouble -> Vector CDouble

zipWith_roundedMul :: RoundingMode -> Vector CDouble -> Vector CDouble -> Vector CDouble

zipWith3_roundedFusedMultiplyAdd :: RoundingMode -> Vector CDouble -> Vector CDouble -> Vector CDouble -> Vector CDouble

RoundedRing_Vector Vector CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

roundedSum :: RoundingMode -> Vector CFloat -> CFloat

zipWith_roundedAdd :: RoundingMode -> Vector CFloat -> Vector CFloat -> Vector CFloat

zipWith_roundedSub :: RoundingMode -> Vector CFloat -> Vector CFloat -> Vector CFloat

zipWith_roundedMul :: RoundingMode -> Vector CFloat -> Vector CFloat -> Vector CFloat

zipWith3_roundedFusedMultiplyAdd :: RoundingMode -> Vector CFloat -> Vector CFloat -> Vector CFloat -> Vector CFloat

RoundedRing_Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

Methods

roundedSum :: RoundingMode -> Vector CDouble -> CDouble

zipWith_roundedAdd :: RoundingMode -> Vector CDouble -> Vector CDouble -> Vector CDouble

zipWith_roundedSub :: RoundingMode -> Vector CDouble -> Vector CDouble -> Vector CDouble

zipWith_roundedMul :: RoundingMode -> Vector CDouble -> Vector CDouble -> Vector CDouble

zipWith3_roundedFusedMultiplyAdd :: RoundingMode -> Vector CDouble -> Vector CDouble -> Vector CDouble -> Vector CDouble

Unbox a => Vector Vector (Complex a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Complex a) -> m (Vector (Complex a))

basicUnsafeThaw :: PrimMonad m => Vector (Complex a) -> m (Mutable Vector (PrimState m) (Complex a))

basicLength :: Vector (Complex a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Complex a) -> Vector (Complex a)

basicUnsafeIndexM :: Monad m => Vector (Complex a) -> Int -> m (Complex a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Complex a) -> Vector (Complex a) -> m ()

elemseq :: Vector (Complex a) -> Complex a -> b -> b

Unbox a => Vector Vector (Min a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Min a) -> m (Vector (Min a))

basicUnsafeThaw :: PrimMonad m => Vector (Min a) -> m (Mutable Vector (PrimState m) (Min a))

basicLength :: Vector (Min a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Min a) -> Vector (Min a)

basicUnsafeIndexM :: Monad m => Vector (Min a) -> Int -> m (Min a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Min a) -> Vector (Min a) -> m ()

elemseq :: Vector (Min a) -> Min a -> b -> b

Unbox a => Vector Vector (Max a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Max a) -> m (Vector (Max a))

basicUnsafeThaw :: PrimMonad m => Vector (Max a) -> m (Mutable Vector (PrimState m) (Max a))

basicLength :: Vector (Max a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Max a) -> Vector (Max a)

basicUnsafeIndexM :: Monad m => Vector (Max a) -> Int -> m (Max a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Max a) -> Vector (Max a) -> m ()

elemseq :: Vector (Max a) -> Max a -> b -> b

Unbox a => Vector Vector (First a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (First a) -> m (Vector (First a))

basicUnsafeThaw :: PrimMonad m => Vector (First a) -> m (Mutable Vector (PrimState m) (First a))

basicLength :: Vector (First a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (First a) -> Vector (First a)

basicUnsafeIndexM :: Monad m => Vector (First a) -> Int -> m (First a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (First a) -> Vector (First a) -> m ()

elemseq :: Vector (First a) -> First a -> b -> b

Unbox a => Vector Vector (Last a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Last a) -> m (Vector (Last a))

basicUnsafeThaw :: PrimMonad m => Vector (Last a) -> m (Mutable Vector (PrimState m) (Last a))

basicLength :: Vector (Last a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Last a) -> Vector (Last a)

basicUnsafeIndexM :: Monad m => Vector (Last a) -> Int -> m (Last a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Last a) -> Vector (Last a) -> m ()

elemseq :: Vector (Last a) -> Last a -> b -> b

Unbox a => Vector Vector (WrappedMonoid a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (WrappedMonoid a) -> m (Vector (WrappedMonoid a))

basicUnsafeThaw :: PrimMonad m => Vector (WrappedMonoid a) -> m (Mutable Vector (PrimState m) (WrappedMonoid a))

basicLength :: Vector (WrappedMonoid a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (WrappedMonoid a) -> Vector (WrappedMonoid a)

basicUnsafeIndexM :: Monad m => Vector (WrappedMonoid a) -> Int -> m (WrappedMonoid a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (WrappedMonoid a) -> Vector (WrappedMonoid a) -> m ()

elemseq :: Vector (WrappedMonoid a) -> WrappedMonoid a -> b -> b

Unbox a => Vector Vector (Identity a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Identity a) -> m (Vector (Identity a))

basicUnsafeThaw :: PrimMonad m => Vector (Identity a) -> m (Mutable Vector (PrimState m) (Identity a))

basicLength :: Vector (Identity a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Identity a) -> Vector (Identity a)

basicUnsafeIndexM :: Monad m => Vector (Identity a) -> Int -> m (Identity a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Identity a) -> Vector (Identity a) -> m ()

elemseq :: Vector (Identity a) -> Identity a -> b -> b

Unbox a => Vector Vector (Dual a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Dual a) -> m (Vector (Dual a))

basicUnsafeThaw :: PrimMonad m => Vector (Dual a) -> m (Mutable Vector (PrimState m) (Dual a))

basicLength :: Vector (Dual a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Dual a) -> Vector (Dual a)

basicUnsafeIndexM :: Monad m => Vector (Dual a) -> Int -> m (Dual a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Dual a) -> Vector (Dual a) -> m ()

elemseq :: Vector (Dual a) -> Dual a -> b -> b

Unbox a => Vector Vector (Sum a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Sum a) -> m (Vector (Sum a))

basicUnsafeThaw :: PrimMonad m => Vector (Sum a) -> m (Mutable Vector (PrimState m) (Sum a))

basicLength :: Vector (Sum a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Sum a) -> Vector (Sum a)

basicUnsafeIndexM :: Monad m => Vector (Sum a) -> Int -> m (Sum a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Sum a) -> Vector (Sum a) -> m ()

elemseq :: Vector (Sum a) -> Sum a -> b -> b

Unbox a => Vector Vector (Product a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Product a) -> m (Vector (Product a))

basicUnsafeThaw :: PrimMonad m => Vector (Product a) -> m (Mutable Vector (PrimState m) (Product a))

basicLength :: Vector (Product a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Product a) -> Vector (Product a)

basicUnsafeIndexM :: Monad m => Vector (Product a) -> Int -> m (Product a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Product a) -> Vector (Product a) -> m ()

elemseq :: Vector (Product a) -> Product a -> b -> b

Unbox a => Vector Vector (Down a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Down a) -> m (Vector (Down a))

basicUnsafeThaw :: PrimMonad m => Vector (Down a) -> m (Mutable Vector (PrimState m) (Down a))

basicLength :: Vector (Down a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Down a) -> Vector (Down a)

basicUnsafeIndexM :: Monad m => Vector (Down a) -> Int -> m (Down a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Down a) -> Vector (Down a) -> m ()

elemseq :: Vector (Down a) -> Down a -> b -> b

Unbox a => Vector Vector (ViaRational a)

Defined in Numeric.Rounded.Hardware.Backend.ViaRational

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (ViaRational a) -> m (Vector (ViaRational a))

basicUnsafeThaw :: PrimMonad m => Vector (ViaRational a) -> m (Mutable Vector (PrimState m) (ViaRational a))

basicLength :: Vector (ViaRational a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (ViaRational a) -> Vector (ViaRational a)

basicUnsafeIndexM :: Monad m => Vector (ViaRational a) -> Int -> m (ViaRational a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (ViaRational a) -> Vector (ViaRational a) -> m ()

elemseq :: Vector (ViaRational a) -> ViaRational a -> b -> b

(Unbox a, Ord a, Fractional a) => Vector Vector (Interval a)

Defined in Numeric.Rounded.Hardware.Interval.NonEmpty

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Interval a) -> m (Vector (Interval a))

basicUnsafeThaw :: PrimMonad m => Vector (Interval a) -> m (Mutable Vector (PrimState m) (Interval a))

basicLength :: Vector (Interval a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Interval a) -> Vector (Interval a)

basicUnsafeIndexM :: Monad m => Vector (Interval a) -> Int -> m (Interval a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Interval a) -> Vector (Interval a) -> m ()

elemseq :: Vector (Interval a) -> Interval a -> b -> b

(Unbox a, Ord a, Fractional a) => Vector Vector (Interval a)

Defined in Numeric.Rounded.Hardware.Interval

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Interval a) -> m (Vector (Interval a))

basicUnsafeThaw :: PrimMonad m => Vector (Interval a) -> m (Mutable Vector (PrimState m) (Interval a))

basicLength :: Vector (Interval a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Interval a) -> Vector (Interval a)

basicUnsafeIndexM :: Monad m => Vector (Interval a) -> Int -> m (Interval a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Interval a) -> Vector (Interval a) -> m ()

elemseq :: Vector (Interval a) -> Interval a -> b -> b

(RealFloat a, RealFloatConstants a, Unbox a) => RoundedSqrt_Vector Vector (ViaRational a)

Defined in Numeric.Rounded.Hardware.Backend.ViaRational

Methods

map_roundedSqrt :: RoundingMode -> Vector (ViaRational a) -> Vector (ViaRational a)

(RealFloat a, RealFloatConstants a, Unbox a) => RoundedFractional_Vector Vector (ViaRational a)

Defined in Numeric.Rounded.Hardware.Backend.ViaRational

Methods

zipWith_roundedDiv :: RoundingMode -> Vector (ViaRational a) -> Vector (ViaRational a) -> Vector (ViaRational a)

(RealFloat a, RealFloatConstants a, Unbox a) => RoundedRing_Vector Vector (ViaRational a)

Defined in Numeric.Rounded.Hardware.Backend.ViaRational

Methods

roundedSum :: RoundingMode -> Vector (ViaRational a) -> ViaRational a

zipWith_roundedAdd :: RoundingMode -> Vector (ViaRational a) -> Vector (ViaRational a) -> Vector (ViaRational a)

zipWith_roundedSub :: RoundingMode -> Vector (ViaRational a) -> Vector (ViaRational a) -> Vector (ViaRational a)

zipWith_roundedMul :: RoundingMode -> Vector (ViaRational a) -> Vector (ViaRational a) -> Vector (ViaRational a)

zipWith3_roundedFusedMultiplyAdd :: RoundingMode -> Vector (ViaRational a) -> Vector (ViaRational a) -> Vector (ViaRational a) -> Vector (ViaRational a)

(Unbox a, Unbox b) => Vector Vector (a, b)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b) -> m (Vector (a, b))

basicUnsafeThaw :: PrimMonad m => Vector (a, b) -> m (Mutable Vector (PrimState m) (a, b))

basicLength :: Vector (a, b) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a, b) -> Vector (a, b)

basicUnsafeIndexM :: Monad m => Vector (a, b) -> Int -> m (a, b)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b) -> Vector (a, b) -> m ()

elemseq :: Vector (a, b) -> (a, b) -> b0 -> b0

(Unbox a, Unbox b) => Vector Vector (Arg a b)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Arg a b) -> m (Vector (Arg a b))

basicUnsafeThaw :: PrimMonad m => Vector (Arg a b) -> m (Mutable Vector (PrimState m) (Arg a b))

basicLength :: Vector (Arg a b) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Arg a b) -> Vector (Arg a b)

basicUnsafeIndexM :: Monad m => Vector (Arg a b) -> Int -> m (Arg a b)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Arg a b) -> Vector (Arg a b) -> m ()

elemseq :: Vector (Arg a b) -> Arg a b -> b0 -> b0

Unbox a => Vector Vector (Rounded r a)

Defined in Numeric.Rounded.Hardware.Internal.Rounding

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Rounded r a) -> m (Vector (Rounded r a))

basicUnsafeThaw :: PrimMonad m => Vector (Rounded r a) -> m (Mutable Vector (PrimState m) (Rounded r a))

basicLength :: Vector (Rounded r a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Rounded r a) -> Vector (Rounded r a)

basicUnsafeIndexM :: Monad m => Vector (Rounded r a) -> Int -> m (Rounded r a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Rounded r a) -> Vector (Rounded r a) -> m ()

elemseq :: Vector (Rounded r a) -> Rounded r a -> b -> b

(Unbox a, Unbox b, Unbox c) => Vector Vector (a, b, c)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c) -> m (Vector (a, b, c))

basicUnsafeThaw :: PrimMonad m => Vector (a, b, c) -> m (Mutable Vector (PrimState m) (a, b, c))

basicLength :: Vector (a, b, c) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c) -> Vector (a, b, c)

basicUnsafeIndexM :: Monad m => Vector (a, b, c) -> Int -> m (a, b, c)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c) -> Vector (a, b, c) -> m ()

elemseq :: Vector (a, b, c) -> (a, b, c) -> b0 -> b0

Unbox a => Vector Vector (Const a b)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Const a b) -> m (Vector (Const a b))

basicUnsafeThaw :: PrimMonad m => Vector (Const a b) -> m (Mutable Vector (PrimState m) (Const a b))

basicLength :: Vector (Const a b) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Const a b) -> Vector (Const a b)

basicUnsafeIndexM :: Monad m => Vector (Const a b) -> Int -> m (Const a b)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Const a b) -> Vector (Const a b) -> m ()

elemseq :: Vector (Const a b) -> Const a b -> b0 -> b0

Unbox (f a) => Vector Vector (Alt f a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Alt f a) -> m (Vector (Alt f a))

basicUnsafeThaw :: PrimMonad m => Vector (Alt f a) -> m (Mutable Vector (PrimState m) (Alt f a))

basicLength :: Vector (Alt f a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Alt f a) -> Vector (Alt f a)

basicUnsafeIndexM :: Monad m => Vector (Alt f a) -> Int -> m (Alt f a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Alt f a) -> Vector (Alt f a) -> m ()

elemseq :: Vector (Alt f a) -> Alt f a -> b -> b

(Unbox a, Unbox b, Unbox c, Unbox d) => Vector Vector (a, b, c, d)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d) -> m (Vector (a, b, c, d))

basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d) -> m (Mutable Vector (PrimState m) (a, b, c, d))

basicLength :: Vector (a, b, c, d) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d) -> Vector (a, b, c, d)

basicUnsafeIndexM :: Monad m => Vector (a, b, c, d) -> Int -> m (a, b, c, d)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d) -> Vector (a, b, c, d) -> m ()

elemseq :: Vector (a, b, c, d) -> (a, b, c, d) -> b0 -> b0

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector Vector (a, b, c, d, e)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e) -> m (Vector (a, b, c, d, e))

basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d, e) -> m (Mutable Vector (PrimState m) (a, b, c, d, e))

basicLength :: Vector (a, b, c, d, e) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d, e) -> Vector (a, b, c, d, e)

basicUnsafeIndexM :: Monad m => Vector (a, b, c, d, e) -> Int -> m (a, b, c, d, e)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e) -> Vector (a, b, c, d, e) -> m ()

elemseq :: Vector (a, b, c, d, e) -> (a, b, c, d, e) -> b0 -> b0

Unbox (f (g a)) => Vector Vector (Compose f g a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Compose f g a) -> m (Vector (Compose f g a))

basicUnsafeThaw :: PrimMonad m => Vector (Compose f g a) -> m (Mutable Vector (PrimState m) (Compose f g a))

basicLength :: Vector (Compose f g a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Compose f g a) -> Vector (Compose f g a)

basicUnsafeIndexM :: Monad m => Vector (Compose f g a) -> Int -> m (Compose f g a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Compose f g a) -> Vector (Compose f g a) -> m ()

elemseq :: Vector (Compose f g a) -> Compose f g a -> b -> b

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vector Vector (a, b, c, d, e, f)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e, f) -> m (Vector (a, b, c, d, e, f))

basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d, e, f) -> m (Mutable Vector (PrimState m) (a, b, c, d, e, f))

basicLength :: Vector (a, b, c, d, e, f) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d, e, f) -> Vector (a, b, c, d, e, f)

basicUnsafeIndexM :: Monad m => Vector (a, b, c, d, e, f) -> Int -> m (a, b, c, d, e, f)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e, f) -> Vector (a, b, c, d, e, f) -> m ()

elemseq :: Vector (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> b0 -> b0

(Data a, Unbox a) => Data (Vector a)

Defined in Data.Vector.Unboxed.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Vector a -> c (Vector a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vector a)

toConstr :: Vector a -> Constr

dataTypeOf :: Vector a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Vector a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vector a))

gmapT :: (forall b. Data b => b -> b) -> Vector a -> Vector a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r

gmapQ :: (forall d. Data d => d -> u) -> Vector a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a)

NFData (Vector a)

Defined in Data.Vector.Unboxed.Base

Methods

rnf :: Vector a -> ()

newtype Vector Bool

Defined in Data.Vector.Unboxed.Base

newtype Vector Bool = V_Bool (Vector Word8)

newtype Vector Char

Defined in Data.Vector.Unboxed.Base

newtype Vector Char = V_Char (Vector Char)

newtype Vector Double

Defined in Data.Vector.Unboxed.Base

newtype Vector Double = V_Double (Vector Double)

newtype Vector Float

Defined in Data.Vector.Unboxed.Base

newtype Vector Float = V_Float (Vector Float)

newtype Vector Int

Defined in Data.Vector.Unboxed.Base

newtype Vector Int = V_Int (Vector Int)

newtype Vector Int8

Defined in Data.Vector.Unboxed.Base

newtype Vector Int8 = V_Int8 (Vector Int8)

newtype Vector Int16

Defined in Data.Vector.Unboxed.Base

newtype Vector Int16 = V_Int16 (Vector Int16)

newtype Vector Int32

Defined in Data.Vector.Unboxed.Base

newtype Vector Int32 = V_Int32 (Vector Int32)

newtype Vector Int64

Defined in Data.Vector.Unboxed.Base

newtype Vector Int64 = V_Int64 (Vector Int64)

newtype Vector Word

Defined in Data.Vector.Unboxed.Base

newtype Vector Word = V_Word (Vector Word)

newtype Vector Word8

Defined in Data.Vector.Unboxed.Base

newtype Vector Word8 = V_Word8 (Vector Word8)

newtype Vector Word16

Defined in Data.Vector.Unboxed.Base

newtype Vector Word16 = V_Word16 (Vector Word16)

newtype Vector Word32

Defined in Data.Vector.Unboxed.Base

newtype Vector Word32 = V_Word32 (Vector Word32)

newtype Vector Word64

Defined in Data.Vector.Unboxed.Base

newtype Vector Word64 = V_Word64 (Vector Word64)

newtype Vector ()

Defined in Data.Vector.Unboxed.Base

newtype Vector () = V_Unit Int

newtype Vector All

Defined in Data.Vector.Unboxed.Base

newtype Vector All = V_All (Vector Bool)

newtype Vector Any

Defined in Data.Vector.Unboxed.Base

newtype Vector Any = V_Any (Vector Bool)

newtype Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

newtype Vector CDouble = V_CDouble (Vector Double)

newtype Vector CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

newtype Vector CFloat = V_CFloat (Vector Float)

newtype Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

newtype Vector CDouble = V_CDouble (Vector Double)

type Mutable Vector

Defined in Data.Vector.Unboxed.Base

type Mutable Vector = MVector

type Item (Vector e)

Defined in Data.Vector.Unboxed

type Item (Vector e) = e

newtype Vector (Complex a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (Complex a) = V_Complex (Vector (a, a))

newtype Vector (Min a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (Min a) = V_Min (Vector a)

newtype Vector (Max a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (Max a) = V_Max (Vector a)

newtype Vector (First a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (First a) = V_First (Vector a)

newtype Vector (Last a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (Last a) = V_Last (Vector a)

newtype Vector (WrappedMonoid a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (WrappedMonoid a) = V_WrappedMonoid (Vector a)

newtype Vector (Identity a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (Identity a) = V_Identity (Vector a)

newtype Vector (Dual a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (Dual a) = V_Dual (Vector a)

newtype Vector (Sum a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (Sum a) = V_Sum (Vector a)

newtype Vector (Product a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (Product a) = V_Product (Vector a)

newtype Vector (Down a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (Down a) = V_Down (Vector a)

newtype Vector (ViaRational a)

Defined in Numeric.Rounded.Hardware.Backend.ViaRational

newtype Vector (ViaRational a) = V_ViaRational (Vector a)

newtype Vector (Interval a)

Defined in Numeric.Rounded.Hardware.Interval.NonEmpty

newtype Vector (Interval a) = V_Interval (Vector (a, a))

newtype Vector (Interval a)

Defined in Numeric.Rounded.Hardware.Interval

newtype Vector (Interval a) = V_Interval (Vector (a, a))

data Vector (a, b)

Defined in Data.Vector.Unboxed.Base

data Vector (a, b) = V_2 !Int !(Vector a) !(Vector b)

newtype Vector (Arg a b)

Defined in Data.Vector.Unboxed.Base

newtype Vector (Arg a b) = V_Arg (Vector (a, b))

newtype Vector (Rounded r a)

Defined in Numeric.Rounded.Hardware.Internal.Rounding

newtype Vector (Rounded r a) = V_Rounded (Vector a)

data Vector (a, b, c)

Defined in Data.Vector.Unboxed.Base

data Vector (a, b, c) = V_3 !Int !(Vector a) !(Vector b) !(Vector c)

newtype Vector (Const a b)

Defined in Data.Vector.Unboxed.Base

newtype Vector (Const a b) = V_Const (Vector a)

newtype Vector (Alt f a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (Alt f a) = V_Alt (Vector (f a))

data Vector (a, b, c, d)

Defined in Data.Vector.Unboxed.Base

data Vector (a, b, c, d) = V_4 !Int !(Vector a) !(Vector b) !(Vector c) !(Vector d)

data Vector (a, b, c, d, e)

Defined in Data.Vector.Unboxed.Base

data Vector (a, b, c, d, e) = V_5 !Int !(Vector a) !(Vector b) !(Vector c) !(Vector d) !(Vector e)

newtype Vector (Compose f g a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (Compose f g a) = V_Compose (Vector (f (g a)))

data Vector (a, b, c, d, e, f)

Defined in Data.Vector.Unboxed.Base

data Vector (a, b, c, d, e, f) = V_6 !Int !(Vector a) !(Vector b) !(Vector c) !(Vector d) !(Vector e) !(Vector f)

roundedFloatFromInt64 :: RoundingMode -> Int64 -> Float

roundedFloatFromWord64 :: RoundingMode -> Word64 -> Float

roundedDoubleFromInt64 :: RoundingMode -> Int64 -> Double

roundedDoubleFromWord64 :: RoundingMode -> Word64 -> Double