Numeric.BLAS.Slice

Documentation

>>> :set -XTypeOperators
>>> 
>>> import qualified Numeric.BLAS.Slice as Slice
>>> import Test.Slice (shapeInt)
>>> 
>>> import qualified Data.Array.Comfort.Boxed as Array
>>> import qualified Data.Array.Comfort.Shape as Shape
>>> import qualified Data.Map as Map
>>> import Data.Array.Comfort.Shape ((::+)((::+)))
>>> import Data.Array.Comfort.Boxed ((!))
>>> 
>>> import Control.Applicative (liftA2, liftA3, pure)
>>> 
>>> import qualified Test.QuickCheck as QC
>>> 
>>> genShape :: QC.Gen (Shape.Range Int)
>>> genShape =
>>> liftA2
>>> (\m n -> Shape.Range (min m n) (max m n))
>>> QC.arbitrary QC.arbitrary
>>> 
>>> genAppend :: QC.Gen (Shape.Range Int ::+ Shape.Range Int)
>>> genAppend = liftA2 (::+) genShape genShape
>>> 
>>> genSlice :: sh -> QC.Gen (Slice.T sh)
>>> genSlice sh =
>>> liftA3 Slice.Cons (QC.choose (0,100)) (QC.choose (1,100)) (pure sh)
>>> 
>>> genSlice2 :: shA -> shB -> QC.Gen (Slice.T shA, Slice.T shB)
>>> genSlice2 shA shB = do
>>> s <- QC.choose (0,100)
>>> k <- QC.choose (1,100)
>>> return (Slice.Cons s k shA, Slice.Cons s k shB)
>>> 
>>> type ShapeInt = Shape.ZeroBased Int
>>> 
>>> mapShape :: (shA -> shB) -> Slice.T shA -> Slice.T shB
>>> mapShape f (Slice.Cons s k sh) = Slice.Cons s k (f sh)
>>> 
>>> toShapeInt :: (Shape.C sh) => Slice.T sh -> Slice.T ShapeInt
>>> toShapeInt = mapShape (shapeInt . Shape.size)

data T sh

Constructors

Cons

Fields

• start, skip :: Int
• shape :: sh

Instances

Show sh => Show (T sh)

Defined in Numeric.BLAS.Slice

Methods

showsPrec :: Int -> T sh -> ShowS

show :: T sh -> String

showList :: [T sh] -> ShowS

Eq sh => Eq (T sh)

Defined in Numeric.BLAS.Slice

Methods

(==) :: T sh -> T sh -> Bool

(/=) :: T sh -> T sh -> Bool

fromShape :: C sh => sh -> T sh

row :: (Indexed sh0, C sh1) => Index sh0 -> T (sh0, sh1) -> T sh1

column :: (C sh0, Indexed sh1) => Index sh1 -> T (sh0, sh1) -> T sh0

rowArray :: (Indexed sh0, C sh1) => T (sh0, sh1) -> Array sh0 (T sh1)

QC.forAll (QC.choose (1,100)) $ \numRows -> QC.forAll (QC.choose (0,100)) $ \numColumns -> QC.forAll (genSlice (shapeInt numRows, shapeInt numColumns)) $ \slice -> QC.forAll (QC.elements $ Shape.indices $ shapeInt numRows) $ \ix -> Slice.row ix slice == Slice.rowArray slice ! ix

columnArray :: (C sh0, Indexed sh1) => T (sh0, sh1) -> Array sh1 (T sh0)

QC.forAll (QC.choose (0,100)) $ \numRows -> QC.forAll (QC.choose (1,100)) $ \numColumns -> QC.forAll (genSlice (shapeInt numRows, shapeInt numColumns)) $ \slice -> QC.forAll (QC.elements $ Shape.indices $ shapeInt numColumns) $ \ix -> Slice.column ix slice == Slice.columnArray slice ! ix

topSubmatrix :: (C sh, C sh0, C sh1) => T (sh0 ::+ sh1, sh) -> T (sh0, sh)

bottomSubmatrix :: (C sh, C sh0, C sh1) => T (sh0 ::+ sh1, sh) -> T (sh1, sh)

diagonal :: C sh => T (Square sh) -> T sh

cartesianFromSquare :: T (Square sh) -> T (sh, sh)

squareRow :: Indexed sh => Index sh -> T (Square sh) -> T sh

squareColumn :: Indexed sh => Index sh -> T (Square sh) -> T sh

plane12 :: (Indexed sh0, C sh1, C sh2) => Index sh0 -> T (sh0, sh1, sh2) -> T (sh1, sh2)

plane01 :: (C sh0, C sh1, Indexed sh2) => Index sh2 -> T (sh0, sh1, sh2) -> T (sh0, sh1)

column2of3 :: (Indexed sh0, Indexed sh1, C sh2) => Index sh0 -> Index sh1 -> T (sh0, sh1, sh2) -> T sh2

column1of3 :: (Indexed sh0, C sh1, Indexed sh2) => Index sh0 -> Index sh2 -> T (sh0, sh1, sh2) -> T sh1

column0of3 :: (C sh0, Indexed sh1, Indexed sh2) => Index sh1 -> Index sh2 -> T (sh0, sh1, sh2) -> T sh0

left :: (C sh0, C sh1) => T (sh0 ::+ sh1) -> T sh0

right :: (C sh0, C sh1) => T (sh0 ::+ sh1) -> T sh1

type ShapeInt = ZeroBased Int

take :: Int -> T ShapeInt -> T ShapeInt

QC.forAll (genSlice =<< genAppend) $ \slice -> Slice.take (case Slice.shape slice of (sh::+_) -> Shape.size sh) (toShapeInt slice) == toShapeInt (Slice.left slice)

drop :: Int -> T ShapeInt -> T ShapeInt

QC.forAll (genSlice =<< genAppend) $ \slice -> Slice.drop (case Slice.shape slice of (sh::+_) -> Shape.size sh) (toShapeInt slice) == toShapeInt (Slice.right slice)

sub :: Int -> Int -> T ShapeInt -> T ShapeInt

Slice.sub start size

\(QC.NonNegative n) -> QC.forAll (genSlice $ shapeInt n) $ \slice (QC.NonNegative start) (QC.NonNegative size) -> Slice.sub start size slice == Slice.take size (Slice.drop start slice)

map :: C sh => T (Map k sh) -> Map k (T sh)

QC.forAll (fmap shapeInt $ QC.choose (0,100)) $ \shapeA -> QC.forAll (fmap shapeInt $ QC.choose (0,100)) $ \shapeB -> QC.forAll (fmap shapeInt $ QC.choose (0,100)) $ \shapeC -> QC.forAll (genSlice2 (Map.fromList $ ('a', shapeA) : ('b', shapeB) : ('c', shapeC) : []) (shapeA ::+ shapeB ::+ shapeC)) $ \(sliceMap, sliceParted) -> Slice.map sliceMap Map.! 'b' == Slice.left (Slice.right sliceParted)

QC.forAll (QC.choose (0,100)) $ \numRows -> QC.forAll (QC.choose (0,100)) $ \numColumns -> let rowShape = shapeInt numRows; columnShape = shapeInt numColumns; mapShape_ = Map.fromList $ map (\k -> (k, columnShape)) (Shape.indices rowShape) in QC.forAll (genSlice2 mapShape_ (rowShape, columnShape)) $ \(sliceMap, sliceMatrix) -> Map.toAscList (Slice.map sliceMap) == Array.toAssociations (Slice.rowArray sliceMatrix)