Beispiel #1
0
        internal static void NpyArray_CopySwapFunc(VoidPtr dest, VoidPtr Source, bool swap, NpyArray arr)
        {
            if (arr == null)
            {
                return;
            }

            if (NpyArray_HASFIELDS(arr))
            {
                NpyDict_KVPair KVPair = new NpyDict_KVPair();
                NpyArray_Descr descr;
                NpyDict_Iter   pos = new NpyDict_Iter();

                descr = arr.descr;
                NpyDict_IterInit(pos);


                while (NpyDict_IterNext(descr.fields, pos, KVPair))
                {
                    NpyArray_DescrField value = KVPair.value as NpyArray_DescrField;
                    string key = KVPair.key as string;

                    if (null != value.title && key.CompareTo(value.title) != 0)
                    {
                        continue;
                    }
                    arr.descr = value.descr;
                    MemCopy.GetMemcopyHelper(dest).copyswap(dest + value.offset, Source + value.offset, swap);
                }
                arr.descr = descr;
                return;
            }
            if (swap && arr.descr.subarray != null)
            {
                NpyArray_Descr descr    = new NpyArray_Descr(NPY_TYPES.NPY_OBJECT);
                NpyArray_Descr newDescr = null;
                npy_intp       num;
                int            itemsize;

                descr     = arr.descr;
                newDescr  = descr.subarray._base;
                arr.descr = newDescr;
                itemsize  = newDescr.elsize;
                num       = descr.elsize / itemsize;

                _default_copyswap(dest, itemsize, Source, itemsize, num, swap, arr);
                arr.descr = descr;
                return;
            }
            if (Source != null)
            {
                memcpy(dest, Source, NpyArray_ITEMSIZE(arr));
            }

            if (swap)
            {
                swapvalue(dest, NpyArray_ITEMSIZE(arr));
            }
            return;
        }
Beispiel #2
0
        internal static bool npy_arraydescr_isnative(NpyArray_Descr self)
        {
            if (self.names == null)
            {
                return(NpyArray_ISNBO(self));
            }
            else
            {
                NpyDict_Iter   pos    = new NpyDict_Iter();
                NpyDict_KVPair KVPair = new NpyDict_KVPair();
                KVPair.key   = null;
                KVPair.value = null;

                NpyDict_IterInit(pos);
                while (NpyDict_IterNext(self.fields, pos, KVPair))
                {
                    string key = (string)KVPair.key;
                    NpyArray_DescrField value = (NpyArray_DescrField)KVPair.value;
                    if (null != value.title && value.title.CompareTo(key) != 0)
                    {
                        continue;
                    }
                    if (false == npy_arraydescr_isnative(value.descr))
                    {
                        return(false);
                    }
                }
            }
            return(true);
        }
Beispiel #3
0
        internal static NpyDict_Iter NpyArrayAccess_DictAllocIter()
        {
            NpyDict_Iter iter = new NpyDict_Iter();

            NpyDict_IterInit(iter);
            return(iter);
        }
Beispiel #4
0
        internal static NpyArray_Descr_Flags npy_descr_find_object_flag(NpyArray_Descr self)
        {
            if (self.flags != 0 || self.type_num == NPY_TYPES.NPY_OBJECT || self.kind == 'O')
            {
                return(NpyArray_Descr_Flags.NPY_OBJECT_DTYPE_FLAGS);
            }

            if (self.names != null)
            {
                NpyDict_Iter   pos    = new NpyDict_Iter();
                NpyDict_KVPair KVPair = new NpyDict_KVPair();
                KVPair.key   = null;
                KVPair.value = null;

                NpyDict_IterInit(pos);
                while (NpyDict_IterNext(self.fields, pos, KVPair))
                {
                    string key = (string)KVPair.key;
                    NpyArray_DescrField value = (NpyArray_DescrField)KVPair.value;

                    if (null != value.title && value.title.CompareTo(key) != 0)
                    {
                        continue;
                    }
                    if (npy_descr_find_object_flag(value.descr) != 0)
                    {
                        value.descr.flags = NpyArray_Descr_Flags.NPY_OBJECT_DTYPE_FLAGS;
                        return(NpyArray_Descr_Flags.NPY_OBJECT_DTYPE_FLAGS);
                    }
                }
            }
            return(0);
        }
Beispiel #5
0
        static bool _equivalent_fields(NpyDict field1, NpyDict field2)
        {
            NpyDict_Iter        pos    = new NpyDict_Iter();
            NpyArray_DescrField value1 = null;
            NpyArray_DescrField value2 = null;
            object         key         = null;
            bool           same        = true;
            NpyDict_KVPair KVPair      = new NpyDict_KVPair();

            if (field1 == field2)
            {
                return(true);
            }
            if (field1 == null || field2 == null)
            {
                return(false);
            }
            if (NpyDict_Size(field1) != NpyDict_Size(field2))
            {
                same = false;
            }

            NpyDict_IterInit(pos);
            while (same && NpyDict_IterNext(field1, pos, KVPair))
            {
                value2 = (NpyArray_DescrField)NpyDict_Get(field2, key);
                if (null == value2 || value1.offset != value2.offset ||
                    ((null == value1.title && null != value2.title) ||
                     (null != value1.title && null == value2.title) ||
                     (null != value1.title && null != value2.title &&
                      value1.title == value2.title)))
                {
                    same = false;
                }
                else if (!NpyArray_EquivTypes(value1.descr, value2.descr))
                {
                    same = false;
                }
            }
            return(same);
        }
Beispiel #6
0
        /*--------------------------------------------------------------------------*\
        *  NAME:
        *      NpyDict_IterNext() - advances to the next element and returns it
        *  DESCRIPTION:
        *      Advances to the next element and returns that key/value pair. If
        *      the end is reached false is returned and key/value are set to null.
        *      Once the iterator is at the end, calling next will continue to
        *      result in 'false' until the iterator is re-initialized.
        *
        *      Switching hash tables or modifying the hash table without re-
        *      initializing the iterator is a bad idea.
        *
        *  EFFICIENCY:
        *      O(1)
        *  ARGUMENTS:
        *      hashTable    - the HashTable to check
        *      iter         - prior iterator position
        *      &key         - out: next key
        *      &value       - out: next value
        *  RETURNS:
        *      bool         - true if a key/value pair is returned, false if the
        *                     end has been reached.
        \*--------------------------------------------------------------------------*/
        internal static bool NpyDict_IterNext(NpyDict hashTable, NpyDict_Iter iter, NpyDict_KVPair KVPair)
        {
            /* Advance to the next element in this bucket if there is one. Otherwise
             * find another bucket. */
            if (null != iter.element)
            {
                iter.element = iter.element.next;
            }
            while (null == iter.element && iter.bucket < hashTable.numOfBuckets - 1)
            {
                iter.element = (NpyDict_KVPair)hashTable.bucketArray[++iter.bucket];
            }

            if (null == iter.element)
            {
                KVPair.key   = null;
                KVPair.value = null;
                return(false);
            }
            KVPair.key   = iter.element.key;
            KVPair.value = iter.element.value;
            return(true);
        }
Beispiel #7
0
        internal static NpyArray_Descr NpyArray_DescrNewByteorder(NpyArray_Descr self, char newendian)
        {
            NpyArray_Descr _new;
            char           endian;

            _new   = NpyArray_DescrNew(self);
            endian = _new.byteorder;
            if (endian != NPY_IGNORE)
            {
                if (newendian == NPY_SWAP)
                {
                    /* swap byteorder */
                    if (NpyArray_ISNBO(endian))
                    {
                        endian = NPY_OPPBYTE;
                    }
                    else
                    {
                        endian = NPY_NATBYTE;
                    }
                    _new.byteorder = endian;
                }
                else if (newendian != NPY_IGNORE)
                {
                    _new.byteorder = newendian;
                }
            }
            if (null != _new.names)
            {
                NpyDict_KVPair KVPair = new NpyDict_KVPair();
                NpyArray_Descr newdescr;
                NpyDict_Iter   pos = new NpyDict_Iter();

                NpyDict_IterInit(pos);
                while (NpyDict_IterNext(_new.fields, pos, KVPair))
                {
                    NpyArray_DescrField value = KVPair.value as NpyArray_DescrField;
                    string key = KVPair.key as string;

                    if (null != value.title && key.CompareTo(value.title) != 0)
                    {
                        continue;
                    }
                    newdescr = NpyArray_DescrNewByteorder(value.descr, newendian);
                    if (newdescr == null)
                    {
                        Npy_DECREF(_new);
                        return(null);
                    }
                    Npy_DECREF(value.descr);
                    value.descr = newdescr;
                }
            }
            if (null != _new.subarray)
            {
                NpyArray_Descr old = _new.subarray._base;
                _new.subarray._base = NpyArray_DescrNewByteorder(self.subarray._base, newendian);
                Npy_DECREF(old);
            }
            return(_new);
        }
Beispiel #8
0
 internal static void NpyArrayAccess_DictFreeIter(NpyDict_Iter iter)
 {
     npy_free(iter);
 }
Beispiel #9
0
 internal static bool NpyArrayAccess_DictNext(NpyDict dict, NpyDict_Iter iter, NpyDict_KVPair KVPair)
 {
     return(NpyDict_IterNext(dict, iter, KVPair));
 }
Beispiel #10
0
 internal static void NpyDict_IterInit(NpyDict_Iter iter)
 {
     iter.bucket  = -1;     /* -1 because first Next() increments to 0 */
     iter.element = null;
 }
Beispiel #11
0
 internal static void NpyArrayAccess_DictFreeIter(NpyDict_Iter iter)
 {
     numpyinternal.NpyArrayAccess_DictFreeIter(iter);
 }
Beispiel #12
0
 public static bool NpyArrayAccess_DictNext(NpyDict dict, NpyDict_Iter iter, NpyDict_KVPair KVPair)
 {
     return(numpyinternal.NpyArrayAccess_DictNext(dict, iter, KVPair));
 }