Hoogle Search

Within LTS Haskell 24.64 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

  1. pattern LUA_RIDX_GLOBALS :: Integer

    lua Lua

    The registry index that holds the global environment.

  2. pattern LUA_OPIDIV :: ArithOPCode

    lua Lua.Constants

    Performs floor division (//)

  3. pattern LUA_RIDX_GLOBALS :: Integer

    lua Lua.Constants

    The registry index that holds the global environment.

  4. computeWithStride :: forall r ix e r' . (Manifest r e, StrideLoad r' ix e) => Stride ix -> Array r' ix e -> Array r ix e

    massiv Data.Massiv.Array

    Same as compute, but with Stride. O(n div k) - Where n is number of elements in the source array and k is number of elements in the stride.

  5. computeWithStrideAs :: (Manifest r e, StrideLoad r' ix e) => r -> Stride ix -> Array r' ix e -> Array r ix e

    massiv Data.Massiv.Array

    Same as computeWithStride, but with ability to specify resulting array representation.

  6. iterArrayLinearWithStrideM_ :: forall r ix e m s . (StrideLoad r ix e, MonadPrimBase s m) => Scheduler s () -> Stride ix -> Sz ix -> Array r ix e -> (Int -> e -> m ()) -> m ()

    massiv Data.Massiv.Array

    No documentation available.

  7. zoomWithGrid :: forall r ix e . (Index ix, Source r e) => e -> Stride ix -> Array r ix e -> Array DL ix e

    massiv Data.Massiv.Array

    Replicate each element of the array by a factor in stride along each dimension and surround each such group with a box of supplied grid value. It will essentially zoom up an array and create a grid around each element from the original array. Very useful for zooming up images to inspect individual pixels.

    Example

    >>> import Data.Massiv.Array as A

>>> arr = resize' (Sz2 3 2) (Ix1 1 ... 6)

>>> arr
Array D Seq (Sz (3 :. 2))
[ [ 1, 2 ]
, [ 3, 4 ]
, [ 5, 6 ]
]

>>> zoomWithGrid 0 (Stride (2 :. 3)) arr
Array DL Seq (Sz (10 :. 9))
[ [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
, [ 0, 1, 1, 1, 0, 2, 2, 2, 0 ]
, [ 0, 1, 1, 1, 0, 2, 2, 2, 0 ]
, [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
, [ 0, 3, 3, 3, 0, 4, 4, 4, 0 ]
, [ 0, 3, 3, 3, 0, 4, 4, 4, 0 ]
, [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
, [ 0, 5, 5, 5, 0, 6, 6, 6, 0 ]
, [ 0, 5, 5, 5, 0, 6, 6, 6, 0 ]
, [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
]

  8. fromStrideLoad :: StrideLoad r ix e => Stride ix -> Array r ix e -> Array DL ix e

    massiv Data.Massiv.Array.Delayed

    Convert an array that can be loaded with stride into DL representation.

  9. fromFunctionMidpoint :: (Index ix, Fractional a) => Comp -> ((Int -> a) -> ix -> e) -> a -> a -> Sz ix -> Int -> Array D ix e

    massiv Data.Massiv.Array.Numeric.Integral

    Similar to fromFunction, but will create an array from a function with sample points in the middle of cells. 

    >>> fromFunctionMidpoint Seq (\ scale (i :. j) -> scale i + scale j :: Double) (-2) 1 (Sz 4) 2
Array D Seq (Sz (8 :. 8))
[ [ -3.5, -3.0, -2.5, -2.0, -1.5, -1.0, -0.5, 0.0 ]
, [ -3.0, -2.5, -2.0, -1.5, -1.0, -0.5, 0.0, 0.5 ]
, [ -2.5, -2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0 ]
, [ -2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5 ]
, [ -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0 ]
, [ -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, 2.5 ]
, [ -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0 ]
, [ 0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5 ]
]

  10. midpointRule :: (Fractional e, StrideLoad DW ix e, Manifest r e) => Comp -> r -> ((Int -> e) -> ix -> e) -> e -> e -> Sz ix -> Int -> Array D ix e

    massiv Data.Massiv.Array.Numeric.Integral

    Use midpoint rule to approximate an integral.

Page 619 of many | Previous | Next