SimpleDomain

Usage

use SimpleDomain;

or

import SimpleDomain;

proc isDomain(d: ?dt) param : bool

proc isRegularDomain(d: ?dt) param : bool

proc zeroTup(param rank: int) : rank*int

proc simpleTupleType(param rank: int, type eltType = int) type

type tuple = _tuple(?)

proc tuple.first ref

proc tuple.last ref

proc tuple.eltType type

proc tuple.uncons ref : (head.type, tail.type)

proc tuple.head ref

proc tuple.tail

proc isTupleOfOrder(type leafType, param order: int, tup: ?tupType) param : bool

proc computeStrides(shape: ?rank*int) : simpleTupleType(rank)

proc computeSize(shape: ?rank*int) : int

proc computeAtIndex(const idx: int) : int

proc computeAtIndex(const shape: ?rank*int, const idx: rank*int) : int

record rect : serializable

param rank : int

var shape : rank*int

var offset : rank*int

var size : int

var strides : rank*int

proc init(const shape: ?rank*int, const offset: rank*int, const size: int, const strides: rank*int = computeStrides(shape))

proc init(const shape: ?rank*int, const offset: rank*int = zeroTup(rank))

proc init(const shape: int ...?rnk)

proc init(const ranges: ?rank*range)

proc init(const ranges: range(?) ...?rank)

proc init(const dom: domain(?))  where isDomain(dom) && dom.isRectangular()

proc init(const other: rect(?rank))

proc init=(const other: rect(?rank))

proc init=(const shape: ?rank*int)

Copy initializes a rect of rank rank from a tuple shape of int``s where ``shape.size == rank.

operator :(const shape: ?rank*int, type toType: rect(rank)) : rect(rank)

proc init=(const shapeOffset: 2*(tuple(?)))  where isTupleOfOrder(int, 2, shapeOffset)

operator :(const shapeOffset: 2*(tuple(?)), type toType: rect(?))  where isTupleOfOrder(int, 2, shapeOffset)

proc init=(const ref dom: domain(?))  where isDomain(dom) && dom.isRectangular()

operator :(const ref dom: domain(?), type toType: rect(?))  where isDomain(dom) && dom.isRectangular()

proc low : rank*int

proc high : rank*int

proc coords : 2*rank*int

proc shiftedShape : rank*int

proc dims() : rank*range

proc indexAt(const order: int) : simpleTupleType(rank)

proc atIndex(const idx: int) : int

proc atIndex(const idx: rank*int) : int

iter serialIter() : simpleTupleType(rank)

iter these() : simpleTupleType(rank)

iter these(param tag: iterKind) : simpleTupleType(rank)  where tag == iterKind.standalone

iter eachOrder() : (int, simpleTupleType(rank))

iter eachOrder(param tag: iterKind) : (int, simpleTupleType(rank))  where tag == iterKind.standalone

proc originate(const origin: rank*int)

proc translate(const change: rank*int)

proc contains(const rct: rect(rank)) : bool

proc contains(const idx: rank*int) : bool

proc toString()

proc serialize(writer: IO.stdout.type, ref serializer)

proc serialize(writer: IO.fileWriter(?), ref serializer)

operator =(ref me: rect(?rank), const other: rect(rank))

operator +(const d: rect(?rank), const offset: rank*int) : rect(rank)

operator -(const d: rect(?rank), const offset: rank*int) : rect(rank)

operator &(const a: rect(?rank), const b: rect(rank)) : rect(rank)

proc computeBlocks(shape: ?rank*int) : rank*int

proc wrap(x: int) : 1*(int)

proc wrap(tup: ?rank*int) : rank*int

proc unwrap(tup: ?rank*int)

proc isTupleOfOrder(param order: int, tup: ?tupType) param : bool