Numeric.Rounded.Hardware.Backend.FastFFI

The types in this module implements interval addition and subtraction in assembly.

Currently, the only platform supported is x86_64.

One of the following technology will be used to control rounding mode:

• SSE2 MXCSR
• AVX512 EVEX encoding

You should not need to import this module directly.

This module may not be available depending on the platform or package flags.

Documentation

newtype CDouble

Constructors

CDouble Double

Instances

Storable CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

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 ()

Generic CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

Associated Types

type Rep CDouble :: Type -> Type

Methods

from :: CDouble -> Rep CDouble x

to :: Rep CDouble x -> CDouble

Num CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

Methods

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

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

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

negate :: CDouble -> CDouble

abs :: CDouble -> CDouble

signum :: CDouble -> CDouble

fromInteger :: Integer -> CDouble

Show CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

Methods

showsPrec :: Int -> CDouble -> ShowS

show :: CDouble -> String

showList :: [CDouble] -> ShowS

NFData CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

Methods

rnf :: CDouble -> ()

Eq CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

Methods

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

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

Ord CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

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

RoundedFractional CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

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.FastFFI

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

RoundedSqrt CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

Methods

roundedSqrt :: RoundingMode -> CDouble -> CDouble

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

Unbox CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

RoundedFractional_Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

Methods

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

RoundedFractional_Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

Methods

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

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

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

RoundedSqrt_Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

Methods

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

RoundedSqrt_Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

Methods

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

Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

Methods

basicUnsafeFreeze :: Mutable Vector s CDouble -> ST s (Vector CDouble)

basicUnsafeThaw :: Vector CDouble -> ST s (Mutable Vector s CDouble)

basicLength :: Vector CDouble -> Int

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

basicUnsafeIndexM :: Vector CDouble -> Int -> Box CDouble

basicUnsafeCopy :: Mutable Vector s CDouble -> Vector CDouble -> ST s ()

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

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 :: Int -> ST s (MVector s CDouble)

basicInitialize :: MVector s CDouble -> ST s ()

basicUnsafeReplicate :: Int -> CDouble -> ST s (MVector s CDouble)

basicUnsafeRead :: MVector s CDouble -> Int -> ST s CDouble

basicUnsafeWrite :: MVector s CDouble -> Int -> CDouble -> ST s ()

basicClear :: MVector s CDouble -> ST s ()

basicSet :: MVector s CDouble -> CDouble -> ST s ()

basicUnsafeCopy :: MVector s CDouble -> MVector s CDouble -> ST s ()

basicUnsafeMove :: MVector s CDouble -> MVector s CDouble -> ST s ()

basicUnsafeGrow :: MVector s CDouble -> Int -> ST s (MVector s CDouble)

type Rep CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

type Rep CDouble = D1 ('MetaData "CDouble" "Numeric.Rounded.Hardware.Backend.FastFFI" "rounded-hw-0.4.0-3WAAI20vt2HBtLAkTAeX6n" '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.FastFFI

newtype Vector CDouble = V_CDouble (Vector Double)

newtype MVector s CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

newtype MVector s CDouble = MV_CDouble (MVector s Double)

fastIntervalAdd :: Double -> Double -> Double -> Double -> (Double, Double)

fastIntervalSub :: Double -> Double -> Double -> Double -> (Double, Double)

fastIntervalRecip :: Double -> Double -> (Double, Double)

data family MVector s a

Instances

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 :: Int -> ST s (MVector s All)

basicInitialize :: MVector s All -> ST s ()

basicUnsafeReplicate :: Int -> All -> ST s (MVector s All)

basicUnsafeRead :: MVector s All -> Int -> ST s All

basicUnsafeWrite :: MVector s All -> Int -> All -> ST s ()

basicClear :: MVector s All -> ST s ()

basicSet :: MVector s All -> All -> ST s ()

basicUnsafeCopy :: MVector s All -> MVector s All -> ST s ()

basicUnsafeMove :: MVector s All -> MVector s All -> ST s ()

basicUnsafeGrow :: MVector s All -> Int -> ST s (MVector s 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 :: Int -> ST s (MVector s Any)

basicInitialize :: MVector s Any -> ST s ()

basicUnsafeReplicate :: Int -> Any -> ST s (MVector s Any)

basicUnsafeRead :: MVector s Any -> Int -> ST s Any

basicUnsafeWrite :: MVector s Any -> Int -> Any -> ST s ()

basicClear :: MVector s Any -> ST s ()

basicSet :: MVector s Any -> Any -> ST s ()

basicUnsafeCopy :: MVector s Any -> MVector s Any -> ST s ()

basicUnsafeMove :: MVector s Any -> MVector s Any -> ST s ()

basicUnsafeGrow :: MVector s Any -> Int -> ST s (MVector s Any)

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 :: Int -> ST s (MVector s Int16)

basicInitialize :: MVector s Int16 -> ST s ()

basicUnsafeReplicate :: Int -> Int16 -> ST s (MVector s Int16)

basicUnsafeRead :: MVector s Int16 -> Int -> ST s Int16

basicUnsafeWrite :: MVector s Int16 -> Int -> Int16 -> ST s ()

basicClear :: MVector s Int16 -> ST s ()

basicSet :: MVector s Int16 -> Int16 -> ST s ()

basicUnsafeCopy :: MVector s Int16 -> MVector s Int16 -> ST s ()

basicUnsafeMove :: MVector s Int16 -> MVector s Int16 -> ST s ()

basicUnsafeGrow :: MVector s Int16 -> Int -> ST s (MVector s 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 :: Int -> ST s (MVector s Int32)

basicInitialize :: MVector s Int32 -> ST s ()

basicUnsafeReplicate :: Int -> Int32 -> ST s (MVector s Int32)

basicUnsafeRead :: MVector s Int32 -> Int -> ST s Int32

basicUnsafeWrite :: MVector s Int32 -> Int -> Int32 -> ST s ()

basicClear :: MVector s Int32 -> ST s ()

basicSet :: MVector s Int32 -> Int32 -> ST s ()

basicUnsafeCopy :: MVector s Int32 -> MVector s Int32 -> ST s ()

basicUnsafeMove :: MVector s Int32 -> MVector s Int32 -> ST s ()

basicUnsafeGrow :: MVector s Int32 -> Int -> ST s (MVector s 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 :: Int -> ST s (MVector s Int64)

basicInitialize :: MVector s Int64 -> ST s ()

basicUnsafeReplicate :: Int -> Int64 -> ST s (MVector s Int64)

basicUnsafeRead :: MVector s Int64 -> Int -> ST s Int64

basicUnsafeWrite :: MVector s Int64 -> Int -> Int64 -> ST s ()

basicClear :: MVector s Int64 -> ST s ()

basicSet :: MVector s Int64 -> Int64 -> ST s ()

basicUnsafeCopy :: MVector s Int64 -> MVector s Int64 -> ST s ()

basicUnsafeMove :: MVector s Int64 -> MVector s Int64 -> ST s ()

basicUnsafeGrow :: MVector s Int64 -> Int -> ST s (MVector s Int64)

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 :: Int -> ST s (MVector s Int8)

basicInitialize :: MVector s Int8 -> ST s ()

basicUnsafeReplicate :: Int -> Int8 -> ST s (MVector s Int8)

basicUnsafeRead :: MVector s Int8 -> Int -> ST s Int8

basicUnsafeWrite :: MVector s Int8 -> Int -> Int8 -> ST s ()

basicClear :: MVector s Int8 -> ST s ()

basicSet :: MVector s Int8 -> Int8 -> ST s ()

basicUnsafeCopy :: MVector s Int8 -> MVector s Int8 -> ST s ()

basicUnsafeMove :: MVector s Int8 -> MVector s Int8 -> ST s ()

basicUnsafeGrow :: MVector s Int8 -> Int -> ST s (MVector s Int8)

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 :: Int -> ST s (MVector s Word16)

basicInitialize :: MVector s Word16 -> ST s ()

basicUnsafeReplicate :: Int -> Word16 -> ST s (MVector s Word16)

basicUnsafeRead :: MVector s Word16 -> Int -> ST s Word16

basicUnsafeWrite :: MVector s Word16 -> Int -> Word16 -> ST s ()

basicClear :: MVector s Word16 -> ST s ()

basicSet :: MVector s Word16 -> Word16 -> ST s ()

basicUnsafeCopy :: MVector s Word16 -> MVector s Word16 -> ST s ()

basicUnsafeMove :: MVector s Word16 -> MVector s Word16 -> ST s ()

basicUnsafeGrow :: MVector s Word16 -> Int -> ST s (MVector s 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 :: Int -> ST s (MVector s Word32)

basicInitialize :: MVector s Word32 -> ST s ()

basicUnsafeReplicate :: Int -> Word32 -> ST s (MVector s Word32)

basicUnsafeRead :: MVector s Word32 -> Int -> ST s Word32

basicUnsafeWrite :: MVector s Word32 -> Int -> Word32 -> ST s ()

basicClear :: MVector s Word32 -> ST s ()

basicSet :: MVector s Word32 -> Word32 -> ST s ()

basicUnsafeCopy :: MVector s Word32 -> MVector s Word32 -> ST s ()

basicUnsafeMove :: MVector s Word32 -> MVector s Word32 -> ST s ()

basicUnsafeGrow :: MVector s Word32 -> Int -> ST s (MVector s 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 :: Int -> ST s (MVector s Word64)

basicInitialize :: MVector s Word64 -> ST s ()

basicUnsafeReplicate :: Int -> Word64 -> ST s (MVector s Word64)

basicUnsafeRead :: MVector s Word64 -> Int -> ST s Word64

basicUnsafeWrite :: MVector s Word64 -> Int -> Word64 -> ST s ()

basicClear :: MVector s Word64 -> ST s ()

basicSet :: MVector s Word64 -> Word64 -> ST s ()

basicUnsafeCopy :: MVector s Word64 -> MVector s Word64 -> ST s ()

basicUnsafeMove :: MVector s Word64 -> MVector s Word64 -> ST s ()

basicUnsafeGrow :: MVector s Word64 -> Int -> ST s (MVector s Word64)

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 :: Int -> ST s (MVector s Word8)

basicInitialize :: MVector s Word8 -> ST s ()

basicUnsafeReplicate :: Int -> Word8 -> ST s (MVector s Word8)

basicUnsafeRead :: MVector s Word8 -> Int -> ST s Word8

basicUnsafeWrite :: MVector s Word8 -> Int -> Word8 -> ST s ()

basicClear :: MVector s Word8 -> ST s ()

basicSet :: MVector s Word8 -> Word8 -> ST s ()

basicUnsafeCopy :: MVector s Word8 -> MVector s Word8 -> ST s ()

basicUnsafeMove :: MVector s Word8 -> MVector s Word8 -> ST s ()

basicUnsafeGrow :: MVector s Word8 -> Int -> ST s (MVector s Word8)

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 :: Int -> ST s (MVector s CDouble)

basicInitialize :: MVector s CDouble -> ST s ()

basicUnsafeReplicate :: Int -> CDouble -> ST s (MVector s CDouble)

basicUnsafeRead :: MVector s CDouble -> Int -> ST s CDouble

basicUnsafeWrite :: MVector s CDouble -> Int -> CDouble -> ST s ()

basicClear :: MVector s CDouble -> ST s ()

basicSet :: MVector s CDouble -> CDouble -> ST s ()

basicUnsafeCopy :: MVector s CDouble -> MVector s CDouble -> ST s ()

basicUnsafeMove :: MVector s CDouble -> MVector s CDouble -> ST s ()

basicUnsafeGrow :: MVector s CDouble -> Int -> ST s (MVector s 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 :: Int -> ST s (MVector s CFloat)

basicInitialize :: MVector s CFloat -> ST s ()

basicUnsafeReplicate :: Int -> CFloat -> ST s (MVector s CFloat)

basicUnsafeRead :: MVector s CFloat -> Int -> ST s CFloat

basicUnsafeWrite :: MVector s CFloat -> Int -> CFloat -> ST s ()

basicClear :: MVector s CFloat -> ST s ()

basicSet :: MVector s CFloat -> CFloat -> ST s ()

basicUnsafeCopy :: MVector s CFloat -> MVector s CFloat -> ST s ()

basicUnsafeMove :: MVector s CFloat -> MVector s CFloat -> ST s ()

basicUnsafeGrow :: MVector s CFloat -> Int -> ST s (MVector s 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 :: Int -> ST s (MVector s CDouble)

basicInitialize :: MVector s CDouble -> ST s ()

basicUnsafeReplicate :: Int -> CDouble -> ST s (MVector s CDouble)

basicUnsafeRead :: MVector s CDouble -> Int -> ST s CDouble

basicUnsafeWrite :: MVector s CDouble -> Int -> CDouble -> ST s ()

basicClear :: MVector s CDouble -> ST s ()

basicSet :: MVector s CDouble -> CDouble -> ST s ()

basicUnsafeCopy :: MVector s CDouble -> MVector s CDouble -> ST s ()

basicUnsafeMove :: MVector s CDouble -> MVector s CDouble -> ST s ()

basicUnsafeGrow :: MVector s CDouble -> Int -> ST s (MVector s CDouble)

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 :: Int -> ST s (MVector s ())

basicInitialize :: MVector s () -> ST s ()

basicUnsafeReplicate :: Int -> () -> ST s (MVector s ())

basicUnsafeRead :: MVector s () -> Int -> ST s ()

basicUnsafeWrite :: MVector s () -> Int -> () -> ST s ()

basicClear :: MVector s () -> ST s ()

basicSet :: MVector s () -> () -> ST s ()

basicUnsafeCopy :: MVector s () -> MVector s () -> ST s ()

basicUnsafeMove :: MVector s () -> MVector s () -> ST s ()

basicUnsafeGrow :: MVector s () -> Int -> ST s (MVector s ())

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 :: Int -> ST s (MVector s Bool)

basicInitialize :: MVector s Bool -> ST s ()

basicUnsafeReplicate :: Int -> Bool -> ST s (MVector s Bool)

basicUnsafeRead :: MVector s Bool -> Int -> ST s Bool

basicUnsafeWrite :: MVector s Bool -> Int -> Bool -> ST s ()

basicClear :: MVector s Bool -> ST s ()

basicSet :: MVector s Bool -> Bool -> ST s ()

basicUnsafeCopy :: MVector s Bool -> MVector s Bool -> ST s ()

basicUnsafeMove :: MVector s Bool -> MVector s Bool -> ST s ()

basicUnsafeGrow :: MVector s Bool -> Int -> ST s (MVector s 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 :: Int -> ST s (MVector s Char)

basicInitialize :: MVector s Char -> ST s ()

basicUnsafeReplicate :: Int -> Char -> ST s (MVector s Char)

basicUnsafeRead :: MVector s Char -> Int -> ST s Char

basicUnsafeWrite :: MVector s Char -> Int -> Char -> ST s ()

basicClear :: MVector s Char -> ST s ()

basicSet :: MVector s Char -> Char -> ST s ()

basicUnsafeCopy :: MVector s Char -> MVector s Char -> ST s ()

basicUnsafeMove :: MVector s Char -> MVector s Char -> ST s ()

basicUnsafeGrow :: MVector s Char -> Int -> ST s (MVector s 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 :: Int -> ST s (MVector s Double)

basicInitialize :: MVector s Double -> ST s ()

basicUnsafeReplicate :: Int -> Double -> ST s (MVector s Double)

basicUnsafeRead :: MVector s Double -> Int -> ST s Double

basicUnsafeWrite :: MVector s Double -> Int -> Double -> ST s ()

basicClear :: MVector s Double -> ST s ()

basicSet :: MVector s Double -> Double -> ST s ()

basicUnsafeCopy :: MVector s Double -> MVector s Double -> ST s ()

basicUnsafeMove :: MVector s Double -> MVector s Double -> ST s ()

basicUnsafeGrow :: MVector s Double -> Int -> ST s (MVector s 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 :: Int -> ST s (MVector s Float)

basicInitialize :: MVector s Float -> ST s ()

basicUnsafeReplicate :: Int -> Float -> ST s (MVector s Float)

basicUnsafeRead :: MVector s Float -> Int -> ST s Float

basicUnsafeWrite :: MVector s Float -> Int -> Float -> ST s ()

basicClear :: MVector s Float -> ST s ()

basicSet :: MVector s Float -> Float -> ST s ()

basicUnsafeCopy :: MVector s Float -> MVector s Float -> ST s ()

basicUnsafeMove :: MVector s Float -> MVector s Float -> ST s ()

basicUnsafeGrow :: MVector s Float -> Int -> ST s (MVector s 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 :: Int -> ST s (MVector s Int)

basicInitialize :: MVector s Int -> ST s ()

basicUnsafeReplicate :: Int -> Int -> ST s (MVector s Int)

basicUnsafeRead :: MVector s Int -> Int -> ST s Int

basicUnsafeWrite :: MVector s Int -> Int -> Int -> ST s ()

basicClear :: MVector s Int -> ST s ()

basicSet :: MVector s Int -> Int -> ST s ()

basicUnsafeCopy :: MVector s Int -> MVector s Int -> ST s ()

basicUnsafeMove :: MVector s Int -> MVector s Int -> ST s ()

basicUnsafeGrow :: MVector s Int -> Int -> ST s (MVector s Int)

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 :: Int -> ST s (MVector s Word)

basicInitialize :: MVector s Word -> ST s ()

basicUnsafeReplicate :: Int -> Word -> ST s (MVector s Word)

basicUnsafeRead :: MVector s Word -> Int -> ST s Word

basicUnsafeWrite :: MVector s Word -> Int -> Word -> ST s ()

basicClear :: MVector s Word -> ST s ()

basicSet :: MVector s Word -> Word -> ST s ()

basicUnsafeCopy :: MVector s Word -> MVector s Word -> ST s ()

basicUnsafeMove :: MVector s Word -> MVector s Word -> ST s ()

basicUnsafeGrow :: MVector s Word -> Int -> ST s (MVector s Word)

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 :: Int -> ST s (MVector s (Complex a))

basicInitialize :: MVector s (Complex a) -> ST s ()

basicUnsafeReplicate :: Int -> Complex a -> ST s (MVector s (Complex a))

basicUnsafeRead :: MVector s (Complex a) -> Int -> ST s (Complex a)

basicUnsafeWrite :: MVector s (Complex a) -> Int -> Complex a -> ST s ()

basicClear :: MVector s (Complex a) -> ST s ()

basicSet :: MVector s (Complex a) -> Complex a -> ST s ()

basicUnsafeCopy :: MVector s (Complex a) -> MVector s (Complex a) -> ST s ()

basicUnsafeMove :: MVector s (Complex a) -> MVector s (Complex a) -> ST s ()

basicUnsafeGrow :: MVector s (Complex a) -> Int -> ST s (MVector s (Complex 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 :: Int -> ST s (MVector s (Identity a))

basicInitialize :: MVector s (Identity a) -> ST s ()

basicUnsafeReplicate :: Int -> Identity a -> ST s (MVector s (Identity a))

basicUnsafeRead :: MVector s (Identity a) -> Int -> ST s (Identity a)

basicUnsafeWrite :: MVector s (Identity a) -> Int -> Identity a -> ST s ()

basicClear :: MVector s (Identity a) -> ST s ()

basicSet :: MVector s (Identity a) -> Identity a -> ST s ()

basicUnsafeCopy :: MVector s (Identity a) -> MVector s (Identity a) -> ST s ()

basicUnsafeMove :: MVector s (Identity a) -> MVector s (Identity a) -> ST s ()

basicUnsafeGrow :: MVector s (Identity a) -> Int -> ST s (MVector s (Identity 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 :: Int -> ST s (MVector s (Down a))

basicInitialize :: MVector s (Down a) -> ST s ()

basicUnsafeReplicate :: Int -> Down a -> ST s (MVector s (Down a))

basicUnsafeRead :: MVector s (Down a) -> Int -> ST s (Down a)

basicUnsafeWrite :: MVector s (Down a) -> Int -> Down a -> ST s ()

basicClear :: MVector s (Down a) -> ST s ()

basicSet :: MVector s (Down a) -> Down a -> ST s ()

basicUnsafeCopy :: MVector s (Down a) -> MVector s (Down a) -> ST s ()

basicUnsafeMove :: MVector s (Down a) -> MVector s (Down a) -> ST s ()

basicUnsafeGrow :: MVector s (Down a) -> Int -> ST s (MVector s (Down 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 :: Int -> ST s (MVector s (First a))

basicInitialize :: MVector s (First a) -> ST s ()

basicUnsafeReplicate :: Int -> First a -> ST s (MVector s (First a))

basicUnsafeRead :: MVector s (First a) -> Int -> ST s (First a)

basicUnsafeWrite :: MVector s (First a) -> Int -> First a -> ST s ()

basicClear :: MVector s (First a) -> ST s ()

basicSet :: MVector s (First a) -> First a -> ST s ()

basicUnsafeCopy :: MVector s (First a) -> MVector s (First a) -> ST s ()

basicUnsafeMove :: MVector s (First a) -> MVector s (First a) -> ST s ()

basicUnsafeGrow :: MVector s (First a) -> Int -> ST s (MVector s (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 :: Int -> ST s (MVector s (Last a))

basicInitialize :: MVector s (Last a) -> ST s ()

basicUnsafeReplicate :: Int -> Last a -> ST s (MVector s (Last a))

basicUnsafeRead :: MVector s (Last a) -> Int -> ST s (Last a)

basicUnsafeWrite :: MVector s (Last a) -> Int -> Last a -> ST s ()

basicClear :: MVector s (Last a) -> ST s ()

basicSet :: MVector s (Last a) -> Last a -> ST s ()

basicUnsafeCopy :: MVector s (Last a) -> MVector s (Last a) -> ST s ()

basicUnsafeMove :: MVector s (Last a) -> MVector s (Last a) -> ST s ()

basicUnsafeGrow :: MVector s (Last a) -> Int -> ST s (MVector s (Last 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 :: Int -> ST s (MVector s (Max a))

basicInitialize :: MVector s (Max a) -> ST s ()

basicUnsafeReplicate :: Int -> Max a -> ST s (MVector s (Max a))

basicUnsafeRead :: MVector s (Max a) -> Int -> ST s (Max a)

basicUnsafeWrite :: MVector s (Max a) -> Int -> Max a -> ST s ()

basicClear :: MVector s (Max a) -> ST s ()

basicSet :: MVector s (Max a) -> Max a -> ST s ()

basicUnsafeCopy :: MVector s (Max a) -> MVector s (Max a) -> ST s ()

basicUnsafeMove :: MVector s (Max a) -> MVector s (Max a) -> ST s ()

basicUnsafeGrow :: MVector s (Max a) -> Int -> ST s (MVector s (Max 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 :: Int -> ST s (MVector s (Min a))

basicInitialize :: MVector s (Min a) -> ST s ()

basicUnsafeReplicate :: Int -> Min a -> ST s (MVector s (Min a))

basicUnsafeRead :: MVector s (Min a) -> Int -> ST s (Min a)

basicUnsafeWrite :: MVector s (Min a) -> Int -> Min a -> ST s ()

basicClear :: MVector s (Min a) -> ST s ()

basicSet :: MVector s (Min a) -> Min a -> ST s ()

basicUnsafeCopy :: MVector s (Min a) -> MVector s (Min a) -> ST s ()

basicUnsafeMove :: MVector s (Min a) -> MVector s (Min a) -> ST s ()

basicUnsafeGrow :: MVector s (Min a) -> Int -> ST s (MVector s (Min 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 :: Int -> ST s (MVector s (WrappedMonoid a))

basicInitialize :: MVector s (WrappedMonoid a) -> ST s ()

basicUnsafeReplicate :: Int -> WrappedMonoid a -> ST s (MVector s (WrappedMonoid a))

basicUnsafeRead :: MVector s (WrappedMonoid a) -> Int -> ST s (WrappedMonoid a)

basicUnsafeWrite :: MVector s (WrappedMonoid a) -> Int -> WrappedMonoid a -> ST s ()

basicClear :: MVector s (WrappedMonoid a) -> ST s ()

basicSet :: MVector s (WrappedMonoid a) -> WrappedMonoid a -> ST s ()

basicUnsafeCopy :: MVector s (WrappedMonoid a) -> MVector s (WrappedMonoid a) -> ST s ()

basicUnsafeMove :: MVector s (WrappedMonoid a) -> MVector s (WrappedMonoid a) -> ST s ()

basicUnsafeGrow :: MVector s (WrappedMonoid a) -> Int -> ST s (MVector s (WrappedMonoid 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 :: Int -> ST s (MVector s (Dual a))

basicInitialize :: MVector s (Dual a) -> ST s ()

basicUnsafeReplicate :: Int -> Dual a -> ST s (MVector s (Dual a))

basicUnsafeRead :: MVector s (Dual a) -> Int -> ST s (Dual a)

basicUnsafeWrite :: MVector s (Dual a) -> Int -> Dual a -> ST s ()

basicClear :: MVector s (Dual a) -> ST s ()

basicSet :: MVector s (Dual a) -> Dual a -> ST s ()

basicUnsafeCopy :: MVector s (Dual a) -> MVector s (Dual a) -> ST s ()

basicUnsafeMove :: MVector s (Dual a) -> MVector s (Dual a) -> ST s ()

basicUnsafeGrow :: MVector s (Dual a) -> Int -> ST s (MVector s (Dual 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 :: Int -> ST s (MVector s (Product a))

basicInitialize :: MVector s (Product a) -> ST s ()

basicUnsafeReplicate :: Int -> Product a -> ST s (MVector s (Product a))

basicUnsafeRead :: MVector s (Product a) -> Int -> ST s (Product a)

basicUnsafeWrite :: MVector s (Product a) -> Int -> Product a -> ST s ()

basicClear :: MVector s (Product a) -> ST s ()

basicSet :: MVector s (Product a) -> Product a -> ST s ()

basicUnsafeCopy :: MVector s (Product a) -> MVector s (Product a) -> ST s ()

basicUnsafeMove :: MVector s (Product a) -> MVector s (Product a) -> ST s ()

basicUnsafeGrow :: MVector s (Product a) -> Int -> ST s (MVector s (Product 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 :: Int -> ST s (MVector s (Sum a))

basicInitialize :: MVector s (Sum a) -> ST s ()

basicUnsafeReplicate :: Int -> Sum a -> ST s (MVector s (Sum a))

basicUnsafeRead :: MVector s (Sum a) -> Int -> ST s (Sum a)

basicUnsafeWrite :: MVector s (Sum a) -> Int -> Sum a -> ST s ()

basicClear :: MVector s (Sum a) -> ST s ()

basicSet :: MVector s (Sum a) -> Sum a -> ST s ()

basicUnsafeCopy :: MVector s (Sum a) -> MVector s (Sum a) -> ST s ()

basicUnsafeMove :: MVector s (Sum a) -> MVector s (Sum a) -> ST s ()

basicUnsafeGrow :: MVector s (Sum a) -> Int -> ST s (MVector s (Sum 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 :: Int -> ST s (MVector s (ViaRational a))

basicInitialize :: MVector s (ViaRational a) -> ST s ()

basicUnsafeReplicate :: Int -> ViaRational a -> ST s (MVector s (ViaRational a))

basicUnsafeRead :: MVector s (ViaRational a) -> Int -> ST s (ViaRational a)

basicUnsafeWrite :: MVector s (ViaRational a) -> Int -> ViaRational a -> ST s ()

basicClear :: MVector s (ViaRational a) -> ST s ()

basicSet :: MVector s (ViaRational a) -> ViaRational a -> ST s ()

basicUnsafeCopy :: MVector s (ViaRational a) -> MVector s (ViaRational a) -> ST s ()

basicUnsafeMove :: MVector s (ViaRational a) -> MVector s (ViaRational a) -> ST s ()

basicUnsafeGrow :: MVector s (ViaRational a) -> Int -> ST s (MVector s (ViaRational 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 :: Int -> ST s (MVector s (Interval a))

basicInitialize :: MVector s (Interval a) -> ST s ()

basicUnsafeReplicate :: Int -> Interval a -> ST s (MVector s (Interval a))

basicUnsafeRead :: MVector s (Interval a) -> Int -> ST s (Interval a)

basicUnsafeWrite :: MVector s (Interval a) -> Int -> Interval a -> ST s ()

basicClear :: MVector s (Interval a) -> ST s ()

basicSet :: MVector s (Interval a) -> Interval a -> ST s ()

basicUnsafeCopy :: MVector s (Interval a) -> MVector s (Interval a) -> ST s ()

basicUnsafeMove :: MVector s (Interval a) -> MVector s (Interval a) -> ST s ()

basicUnsafeGrow :: MVector s (Interval a) -> Int -> ST s (MVector s (Interval 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 :: Int -> ST s (MVector s (Interval a))

basicInitialize :: MVector s (Interval a) -> ST s ()

basicUnsafeReplicate :: Int -> Interval a -> ST s (MVector s (Interval a))

basicUnsafeRead :: MVector s (Interval a) -> Int -> ST s (Interval a)

basicUnsafeWrite :: MVector s (Interval a) -> Int -> Interval a -> ST s ()

basicClear :: MVector s (Interval a) -> ST s ()

basicSet :: MVector s (Interval a) -> Interval a -> ST s ()

basicUnsafeCopy :: MVector s (Interval a) -> MVector s (Interval a) -> ST s ()

basicUnsafeMove :: MVector s (Interval a) -> MVector s (Interval a) -> ST s ()

basicUnsafeGrow :: MVector s (Interval a) -> Int -> ST s (MVector s (Interval a))

Prim a => MVector MVector (UnboxViaPrim a)

Defined in Data.Vector.Unboxed.Base

Methods

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

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

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

basicUnsafeNew :: Int -> ST s (MVector s (UnboxViaPrim a))

basicInitialize :: MVector s (UnboxViaPrim a) -> ST s ()

basicUnsafeReplicate :: Int -> UnboxViaPrim a -> ST s (MVector s (UnboxViaPrim a))

basicUnsafeRead :: MVector s (UnboxViaPrim a) -> Int -> ST s (UnboxViaPrim a)

basicUnsafeWrite :: MVector s (UnboxViaPrim a) -> Int -> UnboxViaPrim a -> ST s ()

basicClear :: MVector s (UnboxViaPrim a) -> ST s ()

basicSet :: MVector s (UnboxViaPrim a) -> UnboxViaPrim a -> ST s ()

basicUnsafeCopy :: MVector s (UnboxViaPrim a) -> MVector s (UnboxViaPrim a) -> ST s ()

basicUnsafeMove :: MVector s (UnboxViaPrim a) -> MVector s (UnboxViaPrim a) -> ST s ()

basicUnsafeGrow :: MVector s (UnboxViaPrim a) -> Int -> ST s (MVector s (UnboxViaPrim a))

(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 :: Int -> ST s (MVector s (Arg a b))

basicInitialize :: MVector s (Arg a b) -> ST s ()

basicUnsafeReplicate :: Int -> Arg a b -> ST s (MVector s (Arg a b))

basicUnsafeRead :: MVector s (Arg a b) -> Int -> ST s (Arg a b)

basicUnsafeWrite :: MVector s (Arg a b) -> Int -> Arg a b -> ST s ()

basicClear :: MVector s (Arg a b) -> ST s ()

basicSet :: MVector s (Arg a b) -> Arg a b -> ST s ()

basicUnsafeCopy :: MVector s (Arg a b) -> MVector s (Arg a b) -> ST s ()

basicUnsafeMove :: MVector s (Arg a b) -> MVector s (Arg a b) -> ST s ()

basicUnsafeGrow :: MVector s (Arg a b) -> Int -> ST s (MVector s (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 :: Int -> ST s (MVector s (Rounded r a))

basicInitialize :: MVector s (Rounded r a) -> ST s ()

basicUnsafeReplicate :: Int -> Rounded r a -> ST s (MVector s (Rounded r a))

basicUnsafeRead :: MVector s (Rounded r a) -> Int -> ST s (Rounded r a)

basicUnsafeWrite :: MVector s (Rounded r a) -> Int -> Rounded r a -> ST s ()

basicClear :: MVector s (Rounded r a) -> ST s ()

basicSet :: MVector s (Rounded r a) -> Rounded r a -> ST s ()

basicUnsafeCopy :: MVector s (Rounded r a) -> MVector s (Rounded r a) -> ST s ()

basicUnsafeMove :: MVector s (Rounded r a) -> MVector s (Rounded r a) -> ST s ()

basicUnsafeGrow :: MVector s (Rounded r a) -> Int -> ST s (MVector s (Rounded r a))

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

Defined in Data.Vector.Unboxed.Base

Methods

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

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

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

basicUnsafeNew :: Int -> ST s (MVector s (As a b))

basicInitialize :: MVector s (As a b) -> ST s ()

basicUnsafeReplicate :: Int -> As a b -> ST s (MVector s (As a b))

basicUnsafeRead :: MVector s (As a b) -> Int -> ST s (As a b)

basicUnsafeWrite :: MVector s (As a b) -> Int -> As a b -> ST s ()

basicClear :: MVector s (As a b) -> ST s ()

basicSet :: MVector s (As a b) -> As a b -> ST s ()

basicUnsafeCopy :: MVector s (As a b) -> MVector s (As a b) -> ST s ()

basicUnsafeMove :: MVector s (As a b) -> MVector s (As a b) -> ST s ()

basicUnsafeGrow :: MVector s (As a b) -> Int -> ST s (MVector s (As a b))

(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 :: Int -> ST s (MVector s (a, b))

basicInitialize :: MVector s (a, b) -> ST s ()

basicUnsafeReplicate :: Int -> (a, b) -> ST s (MVector s (a, b))

basicUnsafeRead :: MVector s (a, b) -> Int -> ST s (a, b)

basicUnsafeWrite :: MVector s (a, b) -> Int -> (a, b) -> ST s ()

basicClear :: MVector s (a, b) -> ST s ()

basicSet :: MVector s (a, b) -> (a, b) -> ST s ()

basicUnsafeCopy :: MVector s (a, b) -> MVector s (a, b) -> ST s ()

basicUnsafeMove :: MVector s (a, b) -> MVector s (a, b) -> ST s ()

basicUnsafeGrow :: MVector s (a, b) -> Int -> ST s (MVector s (a, b))

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 :: Int -> ST s (MVector s (Const a b))

basicInitialize :: MVector s (Const a b) -> ST s ()

basicUnsafeReplicate :: Int -> Const a b -> ST s (MVector s (Const a b))

basicUnsafeRead :: MVector s (Const a b) -> Int -> ST s (Const a b)

basicUnsafeWrite :: MVector s (Const a b) -> Int -> Const a b -> ST s ()

basicClear :: MVector s (Const a b) -> ST s ()

basicSet :: MVector s (Const a b) -> Const a b -> ST s ()

basicUnsafeCopy :: MVector s (Const a b) -> MVector s (Const a b) -> ST s ()

basicUnsafeMove :: MVector s (Const a b) -> MVector s (Const a b) -> ST s ()

basicUnsafeGrow :: MVector s (Const a b) -> Int -> ST s (MVector s (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 :: Int -> ST s (MVector s (Alt f a))

basicInitialize :: MVector s (Alt f a) -> ST s ()

basicUnsafeReplicate :: Int -> Alt f a -> ST s (MVector s (Alt f a))

basicUnsafeRead :: MVector s (Alt f a) -> Int -> ST s (Alt f a)

basicUnsafeWrite :: MVector s (Alt f a) -> Int -> Alt f a -> ST s ()

basicClear :: MVector s (Alt f a) -> ST s ()

basicSet :: MVector s (Alt f a) -> Alt f a -> ST s ()

basicUnsafeCopy :: MVector s (Alt f a) -> MVector s (Alt f a) -> ST s ()

basicUnsafeMove :: MVector s (Alt f a) -> MVector s (Alt f a) -> ST s ()

basicUnsafeGrow :: MVector s (Alt f a) -> Int -> ST s (MVector s (Alt f 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 :: Int -> ST s (MVector s (a, b, c))

basicInitialize :: MVector s (a, b, c) -> ST s ()

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

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

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

basicClear :: MVector s (a, b, c) -> ST s ()

basicSet :: MVector s (a, b, c) -> (a, b, c) -> ST s ()

basicUnsafeCopy :: MVector s (a, b, c) -> MVector s (a, b, c) -> ST s ()

basicUnsafeMove :: MVector s (a, b, c) -> MVector s (a, b, c) -> ST s ()

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

(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 :: Int -> ST s (MVector s (a, b, c, d))

basicInitialize :: MVector s (a, b, c, d) -> ST s ()

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

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

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

basicClear :: MVector s (a, b, c, d) -> ST s ()

basicSet :: MVector s (a, b, c, d) -> (a, b, c, d) -> ST s ()

basicUnsafeCopy :: MVector s (a, b, c, d) -> MVector s (a, b, c, d) -> ST s ()

basicUnsafeMove :: MVector s (a, b, c, d) -> MVector s (a, b, c, d) -> ST s ()

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

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 :: Int -> ST s (MVector s (Compose f g a))

basicInitialize :: MVector s (Compose f g a) -> ST s ()

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

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

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

basicClear :: MVector s (Compose f g a) -> ST s ()

basicSet :: MVector s (Compose f g a) -> Compose f g a -> ST s ()

basicUnsafeCopy :: MVector s (Compose f g a) -> MVector s (Compose f g a) -> ST s ()

basicUnsafeMove :: MVector s (Compose f g a) -> MVector s (Compose f g a) -> ST s ()

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

(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 :: Int -> ST s (MVector s (a, b, c, d, e))

basicInitialize :: MVector s (a, b, c, d, e) -> ST s ()

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

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

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

basicClear :: MVector s (a, b, c, d, e) -> ST s ()

basicSet :: MVector s (a, b, c, d, e) -> (a, b, c, d, e) -> ST s ()

basicUnsafeCopy :: MVector s (a, b, c, d, e) -> MVector s (a, b, c, d, e) -> ST s ()

basicUnsafeMove :: MVector s (a, b, c, d, e) -> MVector s (a, b, c, d, e) -> ST s ()

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

(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 :: Int -> ST s (MVector s (a, b, c, d, e, f))

basicInitialize :: MVector s (a, b, c, d, e, f) -> ST s ()

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

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

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

basicClear :: MVector s (a, b, c, d, e, f) -> ST s ()

basicSet :: MVector s (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> ST s ()

basicUnsafeCopy :: MVector s (a, b, c, d, e, f) -> MVector s (a, b, c, d, e, f) -> ST s ()

basicUnsafeMove :: MVector s (a, b, c, d, e, f) -> MVector s (a, b, c, d, e, f) -> ST s ()

basicUnsafeGrow :: MVector s (a, b, c, d, e, f) -> Int -> ST s (MVector s (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 Int16

Defined in Data.Vector.Unboxed.Base

newtype MVector s Int16 = MV_Int16 (MVector s Int16)

newtype MVector s Int32

Defined in Data.Vector.Unboxed.Base

newtype MVector s Int32 = MV_Int32 (MVector s Int32)

newtype MVector s Int64

Defined in Data.Vector.Unboxed.Base

newtype MVector s Int64 = MV_Int64 (MVector s Int64)

newtype MVector s Int8

Defined in Data.Vector.Unboxed.Base

newtype MVector s Int8 = MV_Int8 (MVector s Int8)

newtype MVector s Word16

Defined in Data.Vector.Unboxed.Base

newtype MVector s Word16 = MV_Word16 (MVector s Word16)

newtype MVector s Word32

Defined in Data.Vector.Unboxed.Base

newtype MVector s Word32 = MV_Word32 (MVector s Word32)

newtype MVector s Word64

Defined in Data.Vector.Unboxed.Base

newtype MVector s Word64 = MV_Word64 (MVector s Word64)

newtype MVector s Word8

Defined in Data.Vector.Unboxed.Base

newtype MVector s Word8 = MV_Word8 (MVector s Word8)

newtype MVector s CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

newtype MVector s CDouble = MV_CDouble (MVector s Double)

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.FastFFI

newtype MVector s CDouble = MV_CDouble (MVector s Double)

newtype MVector s ()

Defined in Data.Vector.Unboxed.Base

newtype MVector s () = MV_Unit Int

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 Int

Defined in Data.Vector.Unboxed.Base

newtype MVector s Int = MV_Int (MVector s Int)

newtype MVector s Word

Defined in Data.Vector.Unboxed.Base

newtype MVector s Word = MV_Word (MVector s Word)

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 (Identity a)

Defined in Data.Vector.Unboxed.Base

newtype MVector s (Identity a) = MV_Identity (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 (First a)

Defined in Data.Vector.Unboxed.Base

newtype MVector s (First a) = MV_First (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 (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 (WrappedMonoid a)

Defined in Data.Vector.Unboxed.Base

newtype MVector s (WrappedMonoid a) = MV_WrappedMonoid (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 (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 (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

newtype MVector s (Interval a) = MV_Interval (MVector s (a, 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 (UnboxViaPrim a)

Defined in Data.Vector.Unboxed.Base

newtype MVector s (UnboxViaPrim a) = MV_UnboxViaPrim (MVector s a)

newtype MVector s (Arg a b)

Defined in Data.Vector.Unboxed.Base

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

newtype MVector s (Rounded r a)

Defined in Numeric.Rounded.Hardware.Internal.Rounding

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

newtype MVector s (As a b)

Defined in Data.Vector.Unboxed.Base

newtype MVector s (As a b) = MV_UnboxAs (MVector s b)

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 (Const a b)

Defined in Data.Vector.Unboxed.Base

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

newtype MVector s (Alt f a)

Defined in Data.Vector.Unboxed.Base

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

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)

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)

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)

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)

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 -> ()

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

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

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

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

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

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

Vector Vector All

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s All -> ST s (Vector All)

basicUnsafeThaw :: Vector All -> ST s (Mutable Vector s All)

basicLength :: Vector All -> Int

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

basicUnsafeIndexM :: Vector All -> Int -> Box All

basicUnsafeCopy :: Mutable Vector s All -> Vector All -> ST s ()

elemseq :: Vector All -> All -> b -> b

Vector Vector Any

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Any -> ST s (Vector Any)

basicUnsafeThaw :: Vector Any -> ST s (Mutable Vector s Any)

basicLength :: Vector Any -> Int

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

basicUnsafeIndexM :: Vector Any -> Int -> Box Any

basicUnsafeCopy :: Mutable Vector s Any -> Vector Any -> ST s ()

elemseq :: Vector Any -> Any -> b -> b

Vector Vector Int16

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Int16 -> ST s (Vector Int16)

basicUnsafeThaw :: Vector Int16 -> ST s (Mutable Vector s Int16)

basicLength :: Vector Int16 -> Int

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

basicUnsafeIndexM :: Vector Int16 -> Int -> Box Int16

basicUnsafeCopy :: Mutable Vector s Int16 -> Vector Int16 -> ST s ()

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

Vector Vector Int32

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Int32 -> ST s (Vector Int32)

basicUnsafeThaw :: Vector Int32 -> ST s (Mutable Vector s Int32)

basicLength :: Vector Int32 -> Int

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

basicUnsafeIndexM :: Vector Int32 -> Int -> Box Int32

basicUnsafeCopy :: Mutable Vector s Int32 -> Vector Int32 -> ST s ()

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

Vector Vector Int64

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Int64 -> ST s (Vector Int64)

basicUnsafeThaw :: Vector Int64 -> ST s (Mutable Vector s Int64)

basicLength :: Vector Int64 -> Int

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

basicUnsafeIndexM :: Vector Int64 -> Int -> Box Int64

basicUnsafeCopy :: Mutable Vector s Int64 -> Vector Int64 -> ST s ()

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

Vector Vector Int8

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Int8 -> ST s (Vector Int8)

basicUnsafeThaw :: Vector Int8 -> ST s (Mutable Vector s Int8)

basicLength :: Vector Int8 -> Int

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

basicUnsafeIndexM :: Vector Int8 -> Int -> Box Int8

basicUnsafeCopy :: Mutable Vector s Int8 -> Vector Int8 -> ST s ()

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

Vector Vector Word16

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Word16 -> ST s (Vector Word16)

basicUnsafeThaw :: Vector Word16 -> ST s (Mutable Vector s Word16)

basicLength :: Vector Word16 -> Int

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

basicUnsafeIndexM :: Vector Word16 -> Int -> Box Word16

basicUnsafeCopy :: Mutable Vector s Word16 -> Vector Word16 -> ST s ()

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

Vector Vector Word32

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Word32 -> ST s (Vector Word32)

basicUnsafeThaw :: Vector Word32 -> ST s (Mutable Vector s Word32)

basicLength :: Vector Word32 -> Int

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

basicUnsafeIndexM :: Vector Word32 -> Int -> Box Word32

basicUnsafeCopy :: Mutable Vector s Word32 -> Vector Word32 -> ST s ()

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

Vector Vector Word64

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Word64 -> ST s (Vector Word64)

basicUnsafeThaw :: Vector Word64 -> ST s (Mutable Vector s Word64)

basicLength :: Vector Word64 -> Int

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

basicUnsafeIndexM :: Vector Word64 -> Int -> Box Word64

basicUnsafeCopy :: Mutable Vector s Word64 -> Vector Word64 -> ST s ()

elemseq :: Vector Word64 -> Word64 -> b -> b

Vector Vector Word8

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Word8 -> ST s (Vector Word8)

basicUnsafeThaw :: Vector Word8 -> ST s (Mutable Vector s Word8)

basicLength :: Vector Word8 -> Int

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

basicUnsafeIndexM :: Vector Word8 -> Int -> Box Word8

basicUnsafeCopy :: Mutable Vector s Word8 -> Vector Word8 -> ST s ()

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

Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

basicUnsafeFreeze :: Mutable Vector s CDouble -> ST s (Vector CDouble)

basicUnsafeThaw :: Vector CDouble -> ST s (Mutable Vector s CDouble)

basicLength :: Vector CDouble -> Int

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

basicUnsafeIndexM :: Vector CDouble -> Int -> Box CDouble

basicUnsafeCopy :: Mutable Vector s CDouble -> Vector CDouble -> ST s ()

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

Vector Vector CFloat

Defined in Numeric.Rounded.Hardware.Backend.C

Methods

basicUnsafeFreeze :: Mutable Vector s CFloat -> ST s (Vector CFloat)

basicUnsafeThaw :: Vector CFloat -> ST s (Mutable Vector s CFloat)

basicLength :: Vector CFloat -> Int

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

basicUnsafeIndexM :: Vector CFloat -> Int -> Box CFloat

basicUnsafeCopy :: Mutable Vector s CFloat -> Vector CFloat -> ST s ()

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

Vector Vector CDouble

Defined in Numeric.Rounded.Hardware.Backend.FastFFI

Methods

basicUnsafeFreeze :: Mutable Vector s CDouble -> ST s (Vector CDouble)

basicUnsafeThaw :: Vector CDouble -> ST s (Mutable Vector s CDouble)

basicLength :: Vector CDouble -> Int

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

basicUnsafeIndexM :: Vector CDouble -> Int -> Box CDouble

basicUnsafeCopy :: Mutable Vector s CDouble -> Vector CDouble -> ST s ()

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

Vector Vector ()

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s () -> ST s (Vector ())

basicUnsafeThaw :: Vector () -> ST s (Mutable Vector s ())

basicLength :: Vector () -> Int

basicUnsafeSlice :: Int -> Int -> Vector () -> Vector ()

basicUnsafeIndexM :: Vector () -> Int -> Box ()

basicUnsafeCopy :: Mutable Vector s () -> Vector () -> ST s ()

elemseq :: Vector () -> () -> b -> b

Vector Vector Bool

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Bool -> ST s (Vector Bool)

basicUnsafeThaw :: Vector Bool -> ST s (Mutable Vector s Bool)

basicLength :: Vector Bool -> Int

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

basicUnsafeIndexM :: Vector Bool -> Int -> Box Bool

basicUnsafeCopy :: Mutable Vector s Bool -> Vector Bool -> ST s ()

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

Vector Vector Char

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Char -> ST s (Vector Char)

basicUnsafeThaw :: Vector Char -> ST s (Mutable Vector s Char)

basicLength :: Vector Char -> Int

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

basicUnsafeIndexM :: Vector Char -> Int -> Box Char

basicUnsafeCopy :: Mutable Vector s Char -> Vector Char -> ST s ()

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

Vector Vector Double

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Double -> ST s (Vector Double)

basicUnsafeThaw :: Vector Double -> ST s (Mutable Vector s Double)

basicLength :: Vector Double -> Int

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

basicUnsafeIndexM :: Vector Double -> Int -> Box Double

basicUnsafeCopy :: Mutable Vector s Double -> Vector Double -> ST s ()

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

Vector Vector Float

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Float -> ST s (Vector Float)

basicUnsafeThaw :: Vector Float -> ST s (Mutable Vector s Float)

basicLength :: Vector Float -> Int

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

basicUnsafeIndexM :: Vector Float -> Int -> Box Float

basicUnsafeCopy :: Mutable Vector s Float -> Vector Float -> ST s ()

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

Vector Vector Int

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Int -> ST s (Vector Int)

basicUnsafeThaw :: Vector Int -> ST s (Mutable Vector s Int)

basicLength :: Vector Int -> Int

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

basicUnsafeIndexM :: Vector Int -> Int -> Box Int

basicUnsafeCopy :: Mutable Vector s Int -> Vector Int -> ST s ()

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

Vector Vector Word

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Word -> ST s (Vector Word)

basicUnsafeThaw :: Vector Word -> ST s (Mutable Vector s Word)

basicLength :: Vector Word -> Int

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

basicUnsafeIndexM :: Vector Word -> Int -> Box Word

basicUnsafeCopy :: Mutable Vector s Word -> Vector Word -> ST s ()

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

(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)

(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)

Unbox a => Vector Vector (Complex a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (Complex a) -> ST s (Vector (Complex a))

basicUnsafeThaw :: Vector (Complex a) -> ST s (Mutable Vector s (Complex a))

basicLength :: Vector (Complex a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Complex a) -> Vector (Complex a)

basicUnsafeIndexM :: Vector (Complex a) -> Int -> Box (Complex a)

basicUnsafeCopy :: Mutable Vector s (Complex a) -> Vector (Complex a) -> ST s ()

elemseq :: Vector (Complex a) -> Complex a -> b -> b

Unbox a => Vector Vector (Identity a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (Identity a) -> ST s (Vector (Identity a))

basicUnsafeThaw :: Vector (Identity a) -> ST s (Mutable Vector s (Identity a))

basicLength :: Vector (Identity a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Identity a) -> Vector (Identity a)

basicUnsafeIndexM :: Vector (Identity a) -> Int -> Box (Identity a)

basicUnsafeCopy :: Mutable Vector s (Identity a) -> Vector (Identity a) -> ST s ()

elemseq :: Vector (Identity a) -> Identity a -> b -> b

Unbox a => Vector Vector (Down a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (Down a) -> ST s (Vector (Down a))

basicUnsafeThaw :: Vector (Down a) -> ST s (Mutable Vector s (Down a))

basicLength :: Vector (Down a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Down a) -> Vector (Down a)

basicUnsafeIndexM :: Vector (Down a) -> Int -> Box (Down a)

basicUnsafeCopy :: Mutable Vector s (Down a) -> Vector (Down a) -> ST s ()

elemseq :: Vector (Down a) -> Down a -> b -> b

Unbox a => Vector Vector (First a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (First a) -> ST s (Vector (First a))

basicUnsafeThaw :: Vector (First a) -> ST s (Mutable Vector s (First a))

basicLength :: Vector (First a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (First a) -> Vector (First a)

basicUnsafeIndexM :: Vector (First a) -> Int -> Box (First a)

basicUnsafeCopy :: Mutable Vector s (First a) -> Vector (First a) -> ST s ()

elemseq :: Vector (First a) -> First a -> b -> b

Unbox a => Vector Vector (Last a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (Last a) -> ST s (Vector (Last a))

basicUnsafeThaw :: Vector (Last a) -> ST s (Mutable Vector s (Last a))

basicLength :: Vector (Last a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Last a) -> Vector (Last a)

basicUnsafeIndexM :: Vector (Last a) -> Int -> Box (Last a)

basicUnsafeCopy :: Mutable Vector s (Last a) -> Vector (Last a) -> ST s ()

elemseq :: Vector (Last a) -> Last a -> b -> b

Unbox a => Vector Vector (Max a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (Max a) -> ST s (Vector (Max a))

basicUnsafeThaw :: Vector (Max a) -> ST s (Mutable Vector s (Max a))

basicLength :: Vector (Max a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Max a) -> Vector (Max a)

basicUnsafeIndexM :: Vector (Max a) -> Int -> Box (Max a)

basicUnsafeCopy :: Mutable Vector s (Max a) -> Vector (Max a) -> ST s ()

elemseq :: Vector (Max a) -> Max a -> b -> b

Unbox a => Vector Vector (Min a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (Min a) -> ST s (Vector (Min a))

basicUnsafeThaw :: Vector (Min a) -> ST s (Mutable Vector s (Min a))

basicLength :: Vector (Min a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Min a) -> Vector (Min a)

basicUnsafeIndexM :: Vector (Min a) -> Int -> Box (Min a)

basicUnsafeCopy :: Mutable Vector s (Min a) -> Vector (Min a) -> ST s ()

elemseq :: Vector (Min a) -> Min a -> b -> b

Unbox a => Vector Vector (WrappedMonoid a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (WrappedMonoid a) -> ST s (Vector (WrappedMonoid a))

basicUnsafeThaw :: Vector (WrappedMonoid a) -> ST s (Mutable Vector s (WrappedMonoid a))

basicLength :: Vector (WrappedMonoid a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (WrappedMonoid a) -> Vector (WrappedMonoid a)

basicUnsafeIndexM :: Vector (WrappedMonoid a) -> Int -> Box (WrappedMonoid a)

basicUnsafeCopy :: Mutable Vector s (WrappedMonoid a) -> Vector (WrappedMonoid a) -> ST s ()

elemseq :: Vector (WrappedMonoid a) -> WrappedMonoid a -> b -> b

Unbox a => Vector Vector (Dual a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (Dual a) -> ST s (Vector (Dual a))

basicUnsafeThaw :: Vector (Dual a) -> ST s (Mutable Vector s (Dual a))

basicLength :: Vector (Dual a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Dual a) -> Vector (Dual a)

basicUnsafeIndexM :: Vector (Dual a) -> Int -> Box (Dual a)

basicUnsafeCopy :: Mutable Vector s (Dual a) -> Vector (Dual a) -> ST s ()

elemseq :: Vector (Dual a) -> Dual a -> b -> b

Unbox a => Vector Vector (Product a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (Product a) -> ST s (Vector (Product a))

basicUnsafeThaw :: Vector (Product a) -> ST s (Mutable Vector s (Product a))

basicLength :: Vector (Product a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Product a) -> Vector (Product a)

basicUnsafeIndexM :: Vector (Product a) -> Int -> Box (Product a)

basicUnsafeCopy :: Mutable Vector s (Product a) -> Vector (Product a) -> ST s ()

elemseq :: Vector (Product a) -> Product a -> b -> b

Unbox a => Vector Vector (Sum a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (Sum a) -> ST s (Vector (Sum a))

basicUnsafeThaw :: Vector (Sum a) -> ST s (Mutable Vector s (Sum a))

basicLength :: Vector (Sum a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Sum a) -> Vector (Sum a)

basicUnsafeIndexM :: Vector (Sum a) -> Int -> Box (Sum a)

basicUnsafeCopy :: Mutable Vector s (Sum a) -> Vector (Sum a) -> ST s ()

elemseq :: Vector (Sum a) -> Sum a -> b -> b

Unbox a => Vector Vector (ViaRational a)

Defined in Numeric.Rounded.Hardware.Backend.ViaRational

Methods

basicUnsafeFreeze :: Mutable Vector s (ViaRational a) -> ST s (Vector (ViaRational a))

basicUnsafeThaw :: Vector (ViaRational a) -> ST s (Mutable Vector s (ViaRational a))

basicLength :: Vector (ViaRational a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (ViaRational a) -> Vector (ViaRational a)

basicUnsafeIndexM :: Vector (ViaRational a) -> Int -> Box (ViaRational a)

basicUnsafeCopy :: Mutable Vector s (ViaRational a) -> Vector (ViaRational a) -> ST s ()

elemseq :: Vector (ViaRational a) -> ViaRational a -> b -> b

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

Defined in Numeric.Rounded.Hardware.Interval

Methods

basicUnsafeFreeze :: Mutable Vector s (Interval a) -> ST s (Vector (Interval a))

basicUnsafeThaw :: Vector (Interval a) -> ST s (Mutable Vector s (Interval a))

basicLength :: Vector (Interval a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Interval a) -> Vector (Interval a)

basicUnsafeIndexM :: Vector (Interval a) -> Int -> Box (Interval a)

basicUnsafeCopy :: Mutable Vector s (Interval a) -> Vector (Interval a) -> ST s ()

elemseq :: Vector (Interval a) -> Interval a -> b -> b

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

Defined in Numeric.Rounded.Hardware.Interval.NonEmpty

Methods

basicUnsafeFreeze :: Mutable Vector s (Interval a) -> ST s (Vector (Interval a))

basicUnsafeThaw :: Vector (Interval a) -> ST s (Mutable Vector s (Interval a))

basicLength :: Vector (Interval a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Interval a) -> Vector (Interval a)

basicUnsafeIndexM :: Vector (Interval a) -> Int -> Box (Interval a)

basicUnsafeCopy :: Mutable Vector s (Interval a) -> Vector (Interval a) -> ST s ()

elemseq :: Vector (Interval a) -> Interval a -> b -> b

Prim a => Vector Vector (UnboxViaPrim a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (UnboxViaPrim a) -> ST s (Vector (UnboxViaPrim a))

basicUnsafeThaw :: Vector (UnboxViaPrim a) -> ST s (Mutable Vector s (UnboxViaPrim a))

basicLength :: Vector (UnboxViaPrim a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (UnboxViaPrim a) -> Vector (UnboxViaPrim a)

basicUnsafeIndexM :: Vector (UnboxViaPrim a) -> Int -> Box (UnboxViaPrim a)

basicUnsafeCopy :: Mutable Vector s (UnboxViaPrim a) -> Vector (UnboxViaPrim a) -> ST s ()

elemseq :: Vector (UnboxViaPrim a) -> UnboxViaPrim a -> b -> b

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

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (Arg a b) -> ST s (Vector (Arg a b))

basicUnsafeThaw :: Vector (Arg a b) -> ST s (Mutable Vector s (Arg a b))

basicLength :: Vector (Arg a b) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Arg a b) -> Vector (Arg a b)

basicUnsafeIndexM :: Vector (Arg a b) -> Int -> Box (Arg a b)

basicUnsafeCopy :: Mutable Vector s (Arg a b) -> Vector (Arg a b) -> ST s ()

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 :: Mutable Vector s (Rounded r a) -> ST s (Vector (Rounded r a))

basicUnsafeThaw :: Vector (Rounded r a) -> ST s (Mutable Vector s (Rounded r a))

basicLength :: Vector (Rounded r a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Rounded r a) -> Vector (Rounded r a)

basicUnsafeIndexM :: Vector (Rounded r a) -> Int -> Box (Rounded r a)

basicUnsafeCopy :: Mutable Vector s (Rounded r a) -> Vector (Rounded r a) -> ST s ()

elemseq :: Vector (Rounded r a) -> Rounded r a -> b -> b

(IsoUnbox a b, Unbox b) => Vector Vector (As a b)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (As a b) -> ST s (Vector (As a b))

basicUnsafeThaw :: Vector (As a b) -> ST s (Mutable Vector s (As a b))

basicLength :: Vector (As a b) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (As a b) -> Vector (As a b)

basicUnsafeIndexM :: Vector (As a b) -> Int -> Box (As a b)

basicUnsafeCopy :: Mutable Vector s (As a b) -> Vector (As a b) -> ST s ()

elemseq :: Vector (As a b) -> As a b -> b0 -> b0

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

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (a, b) -> ST s (Vector (a, b))

basicUnsafeThaw :: Vector (a, b) -> ST s (Mutable Vector s (a, b))

basicLength :: Vector (a, b) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a, b) -> Vector (a, b)

basicUnsafeIndexM :: Vector (a, b) -> Int -> Box (a, b)

basicUnsafeCopy :: Mutable Vector s (a, b) -> Vector (a, b) -> ST s ()

elemseq :: Vector (a, b) -> (a, b) -> b0 -> b0

Unbox a => Vector Vector (Const a b)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (Const a b) -> ST s (Vector (Const a b))

basicUnsafeThaw :: Vector (Const a b) -> ST s (Mutable Vector s (Const a b))

basicLength :: Vector (Const a b) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Const a b) -> Vector (Const a b)

basicUnsafeIndexM :: Vector (Const a b) -> Int -> Box (Const a b)

basicUnsafeCopy :: Mutable Vector s (Const a b) -> Vector (Const a b) -> ST s ()

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 :: Mutable Vector s (Alt f a) -> ST s (Vector (Alt f a))

basicUnsafeThaw :: Vector (Alt f a) -> ST s (Mutable Vector s (Alt f a))

basicLength :: Vector (Alt f a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Alt f a) -> Vector (Alt f a)

basicUnsafeIndexM :: Vector (Alt f a) -> Int -> Box (Alt f a)

basicUnsafeCopy :: Mutable Vector s (Alt f a) -> Vector (Alt f a) -> ST s ()

elemseq :: Vector (Alt f a) -> Alt f a -> b -> b

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

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (a, b, c) -> ST s (Vector (a, b, c))

basicUnsafeThaw :: Vector (a, b, c) -> ST s (Mutable Vector s (a, b, c))

basicLength :: Vector (a, b, c) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c) -> Vector (a, b, c)

basicUnsafeIndexM :: Vector (a, b, c) -> Int -> Box (a, b, c)

basicUnsafeCopy :: Mutable Vector s (a, b, c) -> Vector (a, b, c) -> ST s ()

elemseq :: Vector (a, b, c) -> (a, b, c) -> b0 -> b0

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

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (a, b, c, d) -> ST s (Vector (a, b, c, d))

basicUnsafeThaw :: Vector (a, b, c, d) -> ST s (Mutable Vector s (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 :: Vector (a, b, c, d) -> Int -> Box (a, b, c, d)

basicUnsafeCopy :: Mutable Vector s (a, b, c, d) -> Vector (a, b, c, d) -> ST s ()

elemseq :: Vector (a, b, c, d) -> (a, b, c, d) -> b0 -> b0

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

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (Compose f g a) -> ST s (Vector (Compose f g a))

basicUnsafeThaw :: Vector (Compose f g a) -> ST s (Mutable Vector s (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 :: Vector (Compose f g a) -> Int -> Box (Compose f g a)

basicUnsafeCopy :: Mutable Vector s (Compose f g a) -> Vector (Compose f g a) -> ST s ()

elemseq :: Vector (Compose f g a) -> Compose f g a -> b -> b

(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 :: Mutable Vector s (a, b, c, d, e) -> ST s (Vector (a, b, c, d, e))

basicUnsafeThaw :: Vector (a, b, c, d, e) -> ST s (Mutable Vector s (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 :: Vector (a, b, c, d, e) -> Int -> Box (a, b, c, d, e)

basicUnsafeCopy :: Mutable Vector s (a, b, c, d, e) -> Vector (a, b, c, d, e) -> ST s ()

elemseq :: Vector (a, b, c, d, e) -> (a, b, c, d, e) -> b0 -> b0

(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 :: Mutable Vector s (a, b, c, d, e, f) -> ST s (Vector (a, b, c, d, e, f))

basicUnsafeThaw :: Vector (a, b, c, d, e, f) -> ST s (Mutable Vector s (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 :: Vector (a, b, c, d, e, f) -> Int -> Box (a, b, c, d, e, f)

basicUnsafeCopy :: Mutable Vector s (a, b, c, d, e, f) -> Vector (a, b, c, d, e, f) -> ST s ()

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 -> ()

type Mutable Vector

Defined in Data.Vector.Unboxed.Base

type Mutable Vector = MVector

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 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 Int8

Defined in Data.Vector.Unboxed.Base

newtype Vector Int8 = V_Int8 (Vector Int8)

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 Word8

Defined in Data.Vector.Unboxed.Base

newtype Vector Word8 = V_Word8 (Vector Word8)

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)

newtype Vector ()

Defined in Data.Vector.Unboxed.Base

newtype Vector () = V_Unit Int

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 Word

Defined in Data.Vector.Unboxed.Base

newtype Vector Word = V_Word (Vector Word)

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 (Identity a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (Identity a) = V_Identity (Vector a)

newtype Vector (Down a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (Down a) = V_Down (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 (Max a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (Max a) = V_Max (Vector a)

newtype Vector (Min a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (Min a) = V_Min (Vector a)

newtype Vector (WrappedMonoid a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (WrappedMonoid a) = V_WrappedMonoid (Vector a)

newtype Vector (Dual a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (Dual a) = V_Dual (Vector a)

newtype Vector (Product a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (Product a) = V_Product (Vector a)

newtype Vector (Sum a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (Sum a) = V_Sum (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

newtype Vector (Interval a) = V_Interval (Vector (a, a))

newtype Vector (Interval a)

Defined in Numeric.Rounded.Hardware.Interval.NonEmpty

newtype Vector (Interval a) = V_Interval (Vector (a, a))

newtype Vector (UnboxViaPrim a)

Defined in Data.Vector.Unboxed.Base

newtype Vector (UnboxViaPrim a) = V_UnboxViaPrim (Vector a)

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)

newtype Vector (As a b)

Defined in Data.Vector.Unboxed.Base

newtype Vector (As a b) = V_UnboxAs (Vector b)

data Vector (a, b)

Defined in Data.Vector.Unboxed.Base

data Vector (a, b) = V_2 !Int !(Vector a) !(Vector b)

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)

Defined in Data.Vector.Unboxed.Base

data Vector (a, b, c) = V_3 !Int !(Vector a) !(Vector b) !(Vector c)

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)

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)

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)

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)