iframe-proxy | Sunbelt Computer Software

251 lines (197 loc) · 6.08 KB
#######################################################
# Copyright (c) 2015, ArrayFire
# All rights reserved.
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################
Index and Seq classes used in indexing operations.
from .library import *
from .util import *
from .util import _is_number
from .base import *
from .bcast import _bcast_var
import math
class Seq(ct.Structure):
    arrayfire equivalent of slice
    Attributes
    ----------
    begin: number
           Start of the sequence.
    end  : number
           End of sequence.
    step : number
           Step size.
    Parameters
    ----------
    S: slice or number.
    _fields_ = [("begin", c_double_t),
                ("end"  , c_double_t),
                ("step" , c_double_t)]
    def __init__ (self, S):
        self.begin = c_double_t( 0)
        self.end   = c_double_t(-1)
        self.step  = c_double_t( 1)
        if _is_number(S):
            self.begin = c_double_t(S)
            self.end   = c_double_t(S)
        elif isinstance(S, slice):
            if (S.step is not None):
                self.step  = c_double_t(S.step)
                if(S.step < 0):
                    self.begin, self.end = self.end, self.begin
            if (S.start is not None):
                self.begin = c_double_t(S.start)
            if (S.stop is not None):
                self.end = c_double_t(S.stop)
            # handle special cases
            if self.begin >= 0 and self.end >=0 and self.end <= self.begin and self.step >= 0:
                self.begin = 1
                self.end   = 1
                self.step  = 1
            elif self.begin < 0 and self.end < 0 and self.end >= self.begin and self.step <= 0:
                self.begin = -2
                self.end   = -2
                self.step  = -1
            if (S.stop is not None):
                self.end = self.end - math.copysign(1, self.step)
        else:
            raise IndexError("Invalid type while indexing arrayfire.array")
class ParallelRange(Seq):
    Class used to parallelize for loop.
    Inherits from Seq.
    Attributes
    ----------
    S: slice
    Parameters
    ----------
    start: number
           Beginning of parallel range.
    stop : number
           End of parallel range.
    step : number
           Step size for parallel range.
    Examples
    --------
    >>> import arrayfire as af
    >>> a = af.randu(3, 3)
    >>> b = af.randu(3, 1)
    >>> c = af.constant(0, 3, 3)
    >>> for ii in af.ParallelRange(3):
    ...     c[:, ii] = a[:, ii] + b
    >>> af.display(a)
    >>> af.display(b)
    >>> af.display(c)
    def __init__(self, start, stop=None, step=None):
        if (stop is None):
            stop = start
            start = 0
        self.S = slice(start, stop, step)
        super(ParallelRange, self).__init__(self.S)
    def __iter__(self):
        return self
    def next(self):
        """
        Function called by the iterator in Python 2
        """
        if _bcast_var.get() is True:
            _bcast_var.toggle()
            raise StopIteration
        else:
            _bcast_var.toggle()
            return self
    def __next__(self):
        """
        Function called by the iterator in Python 3
        """
        return self.next()
class _uidx(ct.Union):
    _fields_ = [("arr", c_void_ptr_t),
                ("seq", Seq)]
class Index(ct.Structure):
    _fields_ = [("idx", _uidx),
                ("isSeq", c_bool_t),
                ("isBatch", c_bool_t)]
    Container for the index class in arrayfire C library
    Attributes
    ----------
    idx.arr: ctypes.c_void_p
             - Default 0
    idx.seq: af.Seq
             - Default af.Seq(0, -1, 1)
    isSeq   : bool
            - Default True
    isBatch : bool
            - Default False
    Parameters
    -----------
    idx: key
         - If of type af.Array, self.idx.arr = idx, self.isSeq = False
         - If of type af.ParallelRange, self.idx.seq = idx, self.isBatch = True
         - Default:, self.idx.seq = af.Seq(idx)
    Implemented for internal use only. Use with extreme caution.
    def __init__ (self, idx):
        self.idx     = _uidx()
        self.isBatch = False
        self.isSeq   = True
        if isinstance(idx, BaseArray):
            arr = c_void_ptr_t(0)
            if (idx.type() == Dtype.b8.value):
                safe_call(backend.get().af_where(c_pointer(arr), idx.arr))
            else:
                safe_call(backend.get().af_retain_array(c_pointer(arr), idx.arr))
            self.idx.arr = arr
            self.isSeq   = False
        elif isinstance(idx, ParallelRange):
            self.idx.seq = idx
            self.isBatch = True
        else:
            self.idx.seq = Seq(idx)
    def __del__(self):
        if not self.isSeq:
            # ctypes field variables are automatically
            # converted to basic C types so we have to
            # build the void_p from the value again.
            arr = c_void_ptr_t(self.idx.arr)
            backend.get().af_release_array(arr)
_span = Index(slice(None))
class _Index4(object):
    def __init__(self):
        index_vec = Index * 4
        self.array = index_vec(_span, _span, _span, _span)
        # Do not lose those idx as self.array keeps
        # no reference to them. Otherwise the destructor
        # is prematurely called
        self.idxs = [_span, _span, _span, _span]
    @property
    def pointer(self):
        return c_pointer(self.array)
    def __getitem__(self, idx):
        return self.array[idx]
    def __setitem__(self, idx, value):
        self.array[idx] = value
        self.idxs[idx] = value
Sunbelt Computer Software

PL/B Language Development and Support

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Sunbelt Computer Software

PL/B Language Development and Support

FilesExpand file tree

index.py

Latest commit

History

index.py

File metadata and controls
