Camfort.Specification.Stencils.InferenceBackend

Documentation

type Span a = (a, a)

mkTrivialSpan :: t -> (t, t)

inferFromIndices :: VecList Int -> Specification

inferFromIndicesWithoutLinearity :: VecList Int -> Specification

inferCore :: (IsNatural n, Permutable n) => [Vec n Int] -> Approximation Spatial

simplify :: Approximation Spatial -> Approximation Spatial

simplifySpatial :: Spatial -> Spatial

reducor :: [a] -> ([a] -> [a]) -> ([a] -> Int) -> [a]

fromRegionsToSpec :: IsNatural n => [Span (Vec n Int)] -> Approximation Spatial

toSpecND :: Span (Vec n Int) -> Approximation Spatial

toSpec1D :: Dimension -> Int -> Int -> Approximation Spatial

normaliseSpan :: Span (Vec n Int) -> Span (Vec n Int)

spanBoundingBox :: Span (Vec n Int) -> Span (Vec n Int) -> Span (Vec n Int)

composeConsecutiveSpans :: Span (Vec n Int) -> Span (Vec n Int) -> [Span (Vec n Int)]

Given two spans, if they are consecutive (i.e., (lower1, upper1) (lower2, upper2) where lower2 = upper1 + 1) then compose together returning Just of the new span. Otherwise Nothing

inferMinimalVectorRegions :: Permutable n => [Vec n Int] -> [Span (Vec n Int)]

|inferMinimalVectorRegions| a key part of the algorithm, from a list of n-dimensional relative indices it infers a list of (possibly overlapping) 1-dimensional spans (vectors) within the n-dimensional space. Built from |minimalise| and |allRegionPermutations|

allRegionPermutations :: Permutable n => [Span (Vec n Int)] -> [Span (Vec n Int)]

Map from a lists of n-dimensional spans of relative indices into all possible contiguous spans within the n-dimensional space (individual pass)

foldL :: (a -> a -> [a]) -> [a] -> [a]

minimaliseRegions :: [Span (Vec n Int)] -> [Span (Vec n Int)]

Collapses the regions into a small set by looking for potential overlaps and eliminating those that overlap

containedWithin :: Span (Vec n Int) -> Span (Vec n Int) -> Bool

Binary predicate on whether the first region containedWithin the second

class Permutable n where

Defines the (total) class of vector sizes which are permutable, along with the permutation function which pairs permutations with the unpermute operation

Minimal complete definition

selectionsV, permutationsV

Methods

selectionsV :: Vec n a -> [Selection n a]

permutationsV :: Vec n a -> [(Vec n a, Vec n a -> Vec n a)]

Instances

Permutable Z

Methods

selectionsV :: Vec Z a -> [Selection Z a]

permutationsV :: Vec Z a -> [(Vec Z a, Vec Z a -> Vec Z a)]

Permutable (S Z)

Methods

selectionsV :: Vec (S Z) a -> [Selection (S Z) a]

permutationsV :: Vec (S Z) a -> [(Vec (S Z) a, Vec (S Z) a -> Vec (S Z) a)]

Permutable (S n) => Permutable (S (S n))

Methods

selectionsV :: Vec (S (S n)) a -> [Selection (S (S n)) a]

permutationsV :: Vec (S (S n)) a -> [(Vec (S (S n)) a, Vec (S (S n)) a -> Vec (S (S n)) a)]

type family Selection n a where ...

Equations

Selection Z a = a

Selection (S n) a = (a, Vec n a, a -> Vec n a -> Vec (S n) a)

data VecList a where

Constructors

VL :: (IsNatural n, Permutable n) => [Vec n a] -> VecList a

data List a where

Constructors

List :: (IsNatural n, Permutable n) => Vec n a -> List a

lnil :: List a

lcons :: a -> List a -> List a

fromList :: [a] -> List a

fromLists :: [[Int]] -> VecList Int

data EqT a b where

Constructors

ReflEq :: EqT a a