Documentation

>>> Array.fromList (shapeInt 5) ['a'..]
StorableArray.fromList (ZeroBased {zeroBasedSize = 5}) "abcde"

>>> Array.fromTuple ('a',('b','c')) :: Array (Shape.NestedTuple Shape.TupleIndex (X,(X,X))) Char
StorableArray.fromList (NestedTuple {getNestedTuple = (Element 0,(Element 1,Element 2))}) "abc"

>>> :{
   let arr :: Array (Shape.NestedTuple Shape.TupleAccessor (X,(X,X))) Char
       arr = Array.fromTuple ('a',('b','c'))
   in (arr ! fst, arr ! (fst.snd))
:}
('a','b')

>>> :{
   let arr = Array.fromRecord ('a' :+ 'b') in
   let (real:+imag) = Shape.indexRecordFromShape $ Array.shape arr in
   (arr ! real, arr ! imag)
:}
('a','b')

>>> :{
   Array.fromBlockArray1 $ BoxedArray.fromList Set.empty [] :: Array (Map Char ShapeInt) Word16
:}
StorableArray.fromList (fromList []) []

>>> :{
   let block n a = Array.replicate (shapeInt n) (a::Word16) in
   Array.fromBlockArray1 $
   BoxedArray.fromList (Set.fromList "ABC") [block 2 0, block 3 1, block 5 2]
:}
StorableArray.fromList (fromList [('A',ZeroBased {... 2}),('B',ZeroBased {... 3}),('C',ZeroBased {... 5})]) [0,0,1,1,1,2,2,2,2,2]

Explicit parameters for the shape of the result matrix allow for working with arrays of zero rows or columns.

>>> :{
   (id :: Id (array (height, Map Char ShapeInt) Word16)) $
   Array.fromBlockArray2
      (Map.singleton 'A' (shapeInt 2) <> Map.singleton 'B' (shapeInt 3))
      Map.empty $
   BoxedArray.fromList (Set.fromList "AB", Set.empty) []
:}
StorableArray.fromList (fromList [('A',ZeroBased {... 2}),('B',ZeroBased {... 3})],fromList []) []

:{

QC.forAll genArray2 $ block -> let height = Map.singleton A $ fst $ Array.shape block in let width = Map.singleton '1' $ snd $ Array.shape block in

Array.reshape (height,width) block QC.=== Array.fromBlockArray2 height width (BoxedArray.replicate (Set.singleton A, Set.singleton '1') block) :}

Only the outer BoxedArray need to be non-empty.

>>> :{
   let shapeR0 = shapeInt 2; shapeR1 = shapeInt 3 in
   let shapeC0 = shapeInt 3; shapeC1 = shapeInt 2 in
   let block sh a = Array.replicate sh (a::Word16) in
   Array.fromBlockArray2
      (Map.singleton 'A' shapeR0 <> Map.singleton 'B' shapeR1)
      (Map.singleton '1' shapeC0 <> Map.singleton '2' shapeC1) $
   BoxedArray.fromList (Set.fromList "AB", Set.fromList "12")
      [block (shapeR0,shapeC0) 0, block (shapeR0,shapeC1) 1,
       block (shapeR1,shapeC0) 2, block (shapeR1,shapeC1) 3]
:}
StorableArray.fromList (fromList [('A',ZeroBased {... 2}),('B',ZeroBased {... 3})],fromList [('1',ZeroBased {... 3}),('2',ZeroBased {... 2})]) [0,0,0,1,1,0,0,0,1,1,2,2,2,3,3,2,2,2,3,3,2,2,2,3,3]

:{

QC.forAll genArray2 $ blockA1 -> QC.forAll genArray2 $ blockB2 -> let shapeR0 = fst $ Array.shape blockA1 in let shapeC0 = snd $ Array.shape blockA1 in let shapeR1 = fst $ Array.shape blockB2 in let shapeC1 = snd $ Array.shape blockB2 in QC.forAll (genArrayForShape (shapeR0, shapeC1)) $ blockA2 -> QC.forAll (genArrayForShape (shapeR1, shapeC0)) $ blockB1 -> let blocked = BoxedArray.fromList (Set.fromList AB, Set.fromList "12") [blockA1, blockA2, blockB1, blockB2] in

transpose (Array.fromNonEmptyBlockArray2 blocked) QC.=== Array.fromNonEmptyBlockArray2 (TestBoxedArray.transpose (fmap transpose blocked)) :}

:{

QC.forAll genArray2 $ blockA1 -> QC.forAll genArray2 $ blockB2 -> QC.forAll genArray2 $ blockC3 -> let shapeR0 = fst $ Array.shape blockA1 in let shapeC0 = snd $ Array.shape blockA1 in let shapeR1 = fst $ Array.shape blockB2 in let shapeC1 = snd $ Array.shape blockB2 in let shapeR2 = fst $ Array.shape blockC3 in let shapeC2 = snd $ Array.shape blockC3 in QC.forAll (genArrayForShape (shapeR0, shapeC1)) $ blockA2 -> QC.forAll (genArrayForShape (shapeR0, shapeC2)) $ blockA3 -> QC.forAll (genArrayForShape (shapeR1, shapeC0)) $ blockB1 -> QC.forAll (genArrayForShape (shapeR1, shapeC2)) $ blockB3 -> QC.forAll (genArrayForShape (shapeR2, shapeC0)) $ blockC1 -> QC.forAll (genArrayForShape (shapeR2, shapeC1)) $ blockC2 -> let blocked = BoxedArray.fromList (Set.fromList ABC, Set.fromList "123") [blockA1, blockA2, blockA3, blockB1, blockB2, blockB3, blockC1, blockC2, blockC3] in

transpose (Array.fromNonEmptyBlockArray2 blocked) QC.=== Array.fromNonEmptyBlockArray2 (TestBoxedArray.transpose (fmap transpose blocked)) :}

QC.forAll genNonEmptyArray2 $ \xs -> QC.forAll (QC.elements $ Shape.indices $ Array.shape xs) $ \(ix0,ix1) -> Array.pick xs ix0 ! ix1 == xs!(ix0,ix1)

It is a checked error if a row width differs from the result array width.

QC.forAll genArray2 $ \xs -> xs == Array.fromRowArray (snd $ Array.shape xs) (Array.toRowArray xs)

\x  ->  Array.singleton x ! () == (x::Word16)

\(QC.NonNegative n) (Array16 x)  ->  x == Array.mapShape (Shape.ZeroBased . Shape.size) (Array.append (Array.take n x) (Array.drop n x))

\(QC.NonNegative n) (Array16 x)  ->  x == Array.mapShape (Shape.ZeroBased . Shape.size) (Array.append (Array.take n x) (Array.drop n x))

\(Array16 x) (Array16 y) -> let xy = Array.append x y in x == Array.takeLeft xy  &&  y == Array.takeRight xy

\(Array16 x) (Array16 y) (Array16 z) -> let xyz = Array.append x $ Array.append y z in y == Array.takeCenter xyz

\(Array16 xs)  ->  Array.sum xs == sum (Array.toList xs)

\(Array16 xs)  ->  Array.product xs == product (Array.toList xs)

It is a checked error if the vector is empty.

forAllNonEmpty $ \xs -> Array.minimum xs ==? minimum (Array.toList xs)

It is a checked error if the vector is empty.

forAllNonEmpty $ \xs -> Array.maximum xs ==? maximum (Array.toList xs)

forAllNonEmpty $ \xs -> Array.limits xs ==? (Array.minimum xs, Array.maximum xs)