HORIZON HASKELLDocslts/ghc-10.0.x8c2f8e82026-10-19Search names, modules, packages, or :: a typeCtrl K

GHC 10.0.0.20260917 · lts/ghc-10.0.x · 8c2f8e8 · 2026-10-19

Modulemassiv-1.0.5.0Haskell2010

Data.Massiv.Array.Stencil

  • 2 types
  • 23 values
  • Packagemassiv-1.0.5.0
  • Exports25
  • LanguageHaskell2010
  • LicenceBSD-3-Clause
  • SourceInternal.hs

Stencil

4 declarations
datadata Stencil ix e a
#

Stencil is abstract description of how to handle elements in the neighborhood of every array cell in order to compute a value for the cells in the new array. Use Data.Massiv.Array.makeStencil and Data.Massiv.Array.makeConvolutionStencil in order to create a stencil.

Instances6Functor, Applicative, Floating, Fractional, Num, NFData
valuemakeStencil
  1. :: Index ix
  2. => Sz ix

    Size of the stencil

  3. -> ix

    Center of the stencil

  4. -> ((ix -> e) -> a)

    Stencil function that receives a "get" function as it's argument that can retrieve values of cells in the source array with respect to the center of the stencil. Stencil function must return a value that will be assigned to the cell in the result array. Offset supplied to the "get" function cannot go outside the boundaries of the stencil, otherwise an error will be raised during stencil creation.

  5. -> Stencil ix e a
#

Construct a stencil from a function, which describes how to calculate the value at a point while having access to neighboring elements with a function that accepts idices relative to the center of stencil. Trying to index outside the stencil box will result in a runtime error upon stencil creation.

Note - Once correctness of stencil is verified then switching to makeUnsafeStencil is recommended in order to get the most performance out of the Stencil

Example

Below is an example of creating a Stencil, which, when mapped over a 2-dimensional array, will compute an average of all elements in a 3x3 square for each element in that array.

Note - Make sure to add an INLINE pragma, otherwise performance will be terrible.

average3x3Stencil :: Fractional a => Stencil Ix2 a a
average3x3Stencil = makeStencil (Sz (3 :. 3)) (1 :. 1) $  get ->
  (  get (-1 :. -1) + get (-1 :. 0) + get (-1 :. 1) +
     get ( 0 :. -1) + get ( 0 :. 0) + get ( 0 :. 1) +
     get ( 1 :. -1) + get ( 1 :. 0) + get ( 1 :. 1)   ) / 9
{-# INLINE average3x3Stencil #-}

Padding

datadata Padding ix e
#

Padding of the source array before stencil application.

Examples

In order to see the affect of padding we can simply apply an identity stencil to an array:

Example4 expressions
import Data.Massiv.Array as Aa = computeAs P $ resize' (Sz2 2 3) (Ix1 1 ... 6)applyStencil noPadding idStencil aArray DW Seq (Sz (2 :. 3))  [ [ 1, 2, 3 ]  , [ 4, 5, 6 ]  ]applyStencil (Padding (Sz2 1 2) (Sz2 3 4) (Fill 0)) idStencil aArray DW Seq (Sz (6 :. 9))  [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ]  , [ 0, 0, 1, 2, 3, 0, 0, 0, 0 ]  , [ 0, 0, 4, 5, 6, 0, 0, 0, 0 ]  , [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ]  , [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ]  , [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ]  ]

It is also a nice technique to see the border resolution strategy in action:

Example4 expressions
applyStencil (Padding (Sz2 2 3) (Sz2 2 3) Wrap) idStencil aArray DW Seq (Sz (6 :. 9))  [ [ 1, 2, 3, 1, 2, 3, 1, 2, 3 ]  , [ 4, 5, 6, 4, 5, 6, 4, 5, 6 ]  , [ 1, 2, 3, 1, 2, 3, 1, 2, 3 ]  , [ 4, 5, 6, 4, 5, 6, 4, 5, 6 ]  , [ 1, 2, 3, 1, 2, 3, 1, 2, 3 ]  , [ 4, 5, 6, 4, 5, 6, 4, 5, 6 ]  ]applyStencil (Padding (Sz2 2 3) (Sz2 2 3) Edge) idStencil aArray DW Seq (Sz (6 :. 9))  [ [ 1, 1, 1, 1, 2, 3, 3, 3, 3 ]  , [ 1, 1, 1, 1, 2, 3, 3, 3, 3 ]  , [ 1, 1, 1, 1, 2, 3, 3, 3, 3 ]  , [ 4, 4, 4, 4, 5, 6, 6, 6, 6 ]  , [ 4, 4, 4, 4, 5, 6, 6, 6, 6 ]  , [ 4, 4, 4, 4, 5, 6, 6, 6, 6 ]  ]applyStencil (Padding (Sz2 2 3) (Sz2 2 3) Reflect) idStencil aArray DW Seq (Sz (6 :. 9))  [ [ 6, 5, 4, 4, 5, 6, 6, 5, 4 ]  , [ 3, 2, 1, 1, 2, 3, 3, 2, 1 ]  , [ 3, 2, 1, 1, 2, 3, 3, 2, 1 ]  , [ 6, 5, 4, 4, 5, 6, 6, 5, 4 ]  , [ 6, 5, 4, 4, 5, 6, 6, 5, 4 ]  , [ 3, 2, 1, 1, 2, 3, 3, 2, 1 ]  ]applyStencil (Padding (Sz2 2 3) (Sz2 2 3) Continue) idStencil aArray DW Seq (Sz (6 :. 9))  [ [ 1, 3, 2, 1, 2, 3, 2, 1, 3 ]  , [ 4, 6, 5, 4, 5, 6, 5, 4, 6 ]  , [ 1, 3, 2, 1, 2, 3, 2, 1, 3 ]  , [ 4, 6, 5, 4, 5, 6, 5, 4, 6 ]  , [ 1, 3, 2, 1, 2, 3, 2, 1, 3 ]  , [ 4, 6, 5, 4, 5, 6, 5, 4, 6 ]  ]

Constructors

Instances2Eq, Show
  • (Eq ix, Eq e) => Eq (Padding ix e)Defined in massiv-1.0.5.0 · Data.Massiv.Array.Stencil
  • (Index ix, Show e) => Show (Padding ix e)Defined in massiv-1.0.5.0 · Data.Massiv.Array.Stencil
valuenoPadding :: Index ix => Padding ix e
#

Also known as "valid" padding. When stencil is applied to an array, that array will shrink, unless the stencil is of size 1.

valuesamePadding :: Index ix => Stencil ix e a -> Border e -> Padding ix e
#

Padding that matches the size of the stencil, which is known as "same" padding, because when a stencil is applied to an array with such matching padding, the resulting array will be of the same size as the source array. This is exactly the behavior of mapStencil

Application

valuemapStencil
  1. :: (Index ix, Manifest r e)
  2. => Border e

    Border resolution technique

  3. -> Stencil ix e a

    Stencil to map over the array

  4. -> Array r ix e

    Source array

  5. -> Array DW ix a
#

Map a constructed stencil over an array. Resulting array must be Data.Massiv.Array.computed in order to be useful.

valueapplyStencil
  1. :: (Index ix, Manifest r e)
  2. => Padding ix e

    Padding to be applied to the source array. This will dictate the resulting size of the array. No padding will cause it to shrink by the size of the stencil

  3. -> Stencil ix e a

    Stencil to apply to the array

  4. -> Array r ix e

    Source array

  5. -> Array DW ix a
#

Apply a constructed stencil over an array. Resulting array must be Data.Massiv.Array.computed in order to be useful. Unlike mapStencil, the size of the resulting array will not necesserally be the same as the source array, which will depend on the padding.

Common stencils

valueidStencil :: Index ix => Stencil ix e e
#

Identity stencil that does not change the elements of the source array.

valuesumStencil :: (Num e, Index ix) => Sz ix -> Stencil ix e e
#

Sum all elements in the stencil region

Examples
Example5 expressions
import Data.Massiv.Array as Aa = computeAs P $ iterateN (Sz2 2 5) (* 2) (1 :: Int)aArray P Seq (Sz (2 :. 5))  [ [ 2, 4, 8, 16, 32 ]  , [ 64, 128, 256, 512, 1024 ]  ]applyStencil noPadding (sumStencil (Sz2 1 2)) aArray DW Seq (Sz (2 :. 4))  [ [ 6, 12, 24, 48 ]  , [ 192, 384, 768, 1536 ]  ][2 + 4, 4 + 8, 8 + 16, 16 + 32] :: [Int][6,12,24,48]
valueproductStencil :: (Num e, Index ix) => Sz ix -> Stencil ix e e
#

Multiply all elements in the stencil region

Examples
Example5 expressions
import Data.Massiv.Array as Aa = computeAs P $ iterateN (Sz2 2 2) (+1) (0 :: Int)aArray P Seq (Sz (2 :. 2))  [ [ 1, 2 ]  , [ 3, 4 ]  ]applyStencil (Padding 0 2 (Fill 0)) (productStencil 2) aArray DW Seq (Sz (3 :. 3))  [ [ 24, 0, 0 ]  , [ 0, 0, 0 ]  , [ 0, 0, 0 ]  ]applyStencil (Padding 0 2 Reflect) (productStencil 2) aArray DW Seq (Sz (3 :. 3))  [ [ 24, 64, 24 ]  , [ 144, 256, 144 ]  , [ 24, 64, 24 ]  ]
valueavgStencil :: (Fractional e, Index ix) => Sz ix -> Stencil ix e e
#

Find the average value of all elements in the stencil region

Example
Example5 expressions
import Data.Massiv.Array as Aa = computeAs P $ iterateN (Sz2 3 4) (+1) (10 :: Double)aArray P Seq (Sz (3 :. 4))  [ [ 11.0, 12.0, 13.0, 14.0 ]  , [ 15.0, 16.0, 17.0, 18.0 ]  , [ 19.0, 20.0, 21.0, 22.0 ]  ]applyStencil noPadding (avgStencil (Sz2 2 3)) aArray DW Seq (Sz (2 :. 2))  [ [ 14.0, 15.0 ]  , [ 18.0, 19.0 ]  ]Prelude.sum [11.0, 12.0, 13.0, 15.0, 16.0, 17.0] / 6 :: Double14.0
valuemaxStencil :: (Bounded e, Ord e, Index ix) => Sz ix -> Stencil ix e e
#

Create a stencil centered at 0 that will extract the maximum value in the region of supplied size.

Example

Here is a sample implementation of max pooling.

Example4 expressions
import Data.Massiv.Array as Aa <- computeAs P <$> resizeM (Sz2 9 9) (Ix1 10 ..: 91)aArray P Seq (Sz (9 :. 9))  [ [ 10, 11, 12, 13, 14, 15, 16, 17, 18 ]  , [ 19, 20, 21, 22, 23, 24, 25, 26, 27 ]  , [ 28, 29, 30, 31, 32, 33, 34, 35, 36 ]  , [ 37, 38, 39, 40, 41, 42, 43, 44, 45 ]  , [ 46, 47, 48, 49, 50, 51, 52, 53, 54 ]  , [ 55, 56, 57, 58, 59, 60, 61, 62, 63 ]  , [ 64, 65, 66, 67, 68, 69, 70, 71, 72 ]  , [ 73, 74, 75, 76, 77, 78, 79, 80, 81 ]  , [ 82, 83, 84, 85, 86, 87, 88, 89, 90 ]  ]computeWithStrideAs P (Stride 3) $ mapStencil Edge (maxStencil (Sz 3)) aArray P Seq (Sz (3 :. 3))  [ [ 30, 33, 36 ]  , [ 57, 60, 63 ]  , [ 84, 87, 90 ]  ]
valueminStencil :: (Bounded e, Ord e, Index ix) => Sz ix -> Stencil ix e e
#

Create a stencil centered at 0 that will extract the maximum value in the region of supplied size.

Example

Here is a sample implementation of min pooling.

Example4 expressions
import Data.Massiv.Array as Aa <- computeAs P <$> resizeM (Sz2 9 9) (Ix1 10 ..: 91)aArray P Seq (Sz (9 :. 9))  [ [ 10, 11, 12, 13, 14, 15, 16, 17, 18 ]  , [ 19, 20, 21, 22, 23, 24, 25, 26, 27 ]  , [ 28, 29, 30, 31, 32, 33, 34, 35, 36 ]  , [ 37, 38, 39, 40, 41, 42, 43, 44, 45 ]  , [ 46, 47, 48, 49, 50, 51, 52, 53, 54 ]  , [ 55, 56, 57, 58, 59, 60, 61, 62, 63 ]  , [ 64, 65, 66, 67, 68, 69, 70, 71, 72 ]  , [ 73, 74, 75, 76, 77, 78, 79, 80, 81 ]  , [ 82, 83, 84, 85, 86, 87, 88, 89, 90 ]  ]computeWithStrideAs P (Stride 3) $ mapStencil Edge (minStencil (Sz 3)) aArray P Seq (Sz (3 :. 3))  [ [ 10, 13, 16 ]  , [ 37, 40, 43 ]  , [ 64, 67, 70 ]  ]
valuefoldlStencil :: Index ix => (a -> e -> a) -> a -> Sz ix -> Stencil ix e a
#

Stencil that does a left fold in a row-major order. Regardless of the supplied size resulting stencil will be centered at zero, although by using Padding it is possible to overcome this limitation.

Examples
Example5 expressions
import Data.Massiv.Array as Aa = computeAs P $ iterateN (Sz2 3 4) (+1) (10 :: Int)aArray P Seq (Sz (3 :. 4))  [ [ 11, 12, 13, 14 ]  , [ 15, 16, 17, 18 ]  , [ 19, 20, 21, 22 ]  ]applyStencil noPadding (foldlStencil (flip (:)) [] (Sz2 3 2)) aArray DW Seq (Sz (1 :. 3))  [ [ [20,19,16,15,12,11], [21,20,17,16,13,12], [22,21,18,17,14,13] ]  ]applyStencil (Padding (Sz2 1 0) 0 (Fill 10)) (foldlStencil (flip (:)) [] (Sz2 3 2)) aArray DW Seq (Sz (2 :. 3))  [ [ [16,15,12,11,10,10], [17,16,13,12,10,10], [18,17,14,13,10,10] ]  , [ [20,19,16,15,12,11], [21,20,17,16,13,12], [22,21,18,17,14,13] ]  ]
valuefoldrStencil :: Index ix => (e -> a -> a) -> a -> Sz ix -> Stencil ix e a
#

Stencil that does a right fold in a row-major order. Regardless of the supplied size resulting stencil will be centered at zero, although by using Padding it is possible to overcome this limitation.

Examples
Example4 expressions
import Data.Massiv.Array as Aa = computeAs P $ iterateN (Sz2 3 4) (+1) (10 :: Int)aArray P Seq (Sz (3 :. 4))  [ [ 11, 12, 13, 14 ]  , [ 15, 16, 17, 18 ]  , [ 19, 20, 21, 22 ]  ]applyStencil noPadding (foldrStencil (:) [] (Sz2 2 3)) aArray DW Seq (Sz (2 :. 2))  [ [ [11,12,13,15,16,17], [12,13,14,16,17,18] ]  , [ [15,16,17,19,20,21], [16,17,18,20,21,22] ]  ]

Profunctor

valuelmapStencil :: (c -> d) -> Stencil ix d a -> Stencil ix c a
#

A contravariant map of a second type parameter. In other words map a function over each element of the array, that the stencil will be applied to.

Note: This map can be very inefficient, since for stencils larger than 1 element in size, the supllied function will be repeatedly applied to the same element. It is better to simply map that function over the source array instead.

Convolution

4 declarations
valuemakeConvolutionStencil
  1. :: (Index ix, Num e)
  2. => Sz ix
  3. -> ix
  4. -> (ix -> e -> e -> e) -> e -> e
  5. -> Stencil ix e e
#

Create a convolution stencil by specifying border resolution technique and an accumulator function.

Note - Using makeUnsafeConvolutionStencil will be slightly faster, therefore it is recommended to switch from this function, after manual verification that the created stencil behaves as expected.

Examples

Here is how to create a 2D horizontal Sobel Stencil:

sobelX :: Num e => Stencil Ix2 e e
sobelX = makeConvolutionStencil (Sz2 3 3) (1 :. 1)
         $ f -> f (-1 :. -1) (-1) . f (-1 :. 1) 1 .
                 f ( 0 :. -1) (-2) . f ( 0 :. 1) 2 .
                 f ( 1 :. -1) (-1) . f ( 1 :. 1) 1
{-# INLINE sobelX #-}