Example #1
0
        /// <summary>
        /// Finds the offset for a single item assignment to the array.
        /// </summary>
        /// <param name="arr">The array we are assigning to.</param>
        /// <returns>The offset or -1 if this is not a single assignment.</returns>
        internal npy_intp SingleAssignOffset(ndarray arr)
        {
            // Check to see that there are just newaxis, ellipsis, intp or bool indexes
            for (int i = 0; i < num_indexes; i++)
            {
                switch (IndexType(i))
                {
                case NpyIndexType.NPY_INDEX_NEWAXIS:
                case NpyIndexType.NPY_INDEX_ELLIPSIS:
                case NpyIndexType.NPY_INDEX_INTP:
                case NpyIndexType.NPY_INDEX_BOOL:
                    break;

                default:
                    return(-1);
                }
            }

            // Bind to the array and calculate the offset.
            NpyIndexes bound = Bind(arr);
            {
                npy_intp offset = 0;
                int      nd     = 0;

                for (int i = 0; i < bound.num_indexes; i++)
                {
                    switch (bound.IndexType(i))
                    {
                    case NpyIndexType.NPY_INDEX_NEWAXIS:
                        break;

                    case NpyIndexType.NPY_INDEX_INTP:
                        offset += arr.Stride(nd++) * bound.GetIntP(i);
                        break;

                    case NpyIndexType.NPY_INDEX_SLICE:
                        // An ellipsis became a slice on binding.
                        // This is not a single item assignment.
                        return(-1);

                    default:
                        // This should never happen
                        return(-1);
                    }
                }
                if (nd != arr.ndim)
                {
                    // Not enough indexes. This is not a single item.
                    return(-1);
                }
                return(offset);
            }
        }
Example #2
0
        public Object this[params object[] args]
        {
            get
            {
                ndarray result;

                NpyIndexes indexes = new NpyIndexes();
                {
                    NpyUtil_IndexProcessing.IndexConverter(this.arr.ravel(), args, indexes);
                    result = NpyCoreApi.IterSubscript(this, indexes);
                }
                if (result.ndim == 0)
                {
                    return(result.GetItem(0));
                }
                else
                {
                    return(result);
                }
            }

            set
            {
                NpyIndexes indexes = new NpyIndexes();
                {
                    NpyUtil_IndexProcessing.IndexConverter(this.arr.ravel(), args, indexes);

                    if (indexes.NumIndexes == 1)
                    {
                        // Special cases for single assigment.
                        switch (indexes.IndexType(0))
                        {
                        case NpyIndexType.NPY_INDEX_INTP:
                            SingleAssign(indexes.GetIntP(0), value);
                            return;

                        case NpyIndexType.NPY_INDEX_BOOL:
                            if (indexes.GetBool(0))
                            {
                                SingleAssign(0, value);
                            }
                            return;

                        default:
                            break;
                        }
                    }

                    ndarray array_val = np.FromAny(value, arr.Dtype, 0, 0, 0, null);
                    NpyCoreApi.IterSubscriptAssign(this, indexes, array_val);
                }
            }
        }
Example #3
0
        internal NpyIndexes Bind(ndarray arr)
        {
            NpyIndexes result = new NpyIndexes();
            int        n      = NpyCoreApi.BindIndex(arr, this, result);

            if (n < 0)
            {
                NpyCoreApi.CheckError();
            }
            else
            {
                result.num_indexes = n;
            }
            return(result);
        }
Example #4
0
        public static void IndexConverter(ndarray arr, Object[] indexArgs, NpyIndexes indexes)
        {
            int index = 0;

            if (indexArgs.Length != 1)
            {
                // This is the simple case. Just convert each arg.
                if (indexArgs.Length > NpyDefs.NPY_MAXDIMS)
                {
                    throw new IndexOutOfRangeException("Too many indices");
                }
                foreach (object arg in indexArgs)
                {
                    ConvertSingleIndex(arr, arg, indexes, index++);
                }
            }
            else
            {
                // Single index.
                object arg = indexArgs[0];
                if (arg is ndarray)
                {
                    ConvertSingleIndex(arr, arg, indexes, index++);
                }
                else if (arg is string)
                {
                    ConvertSingleIndex(arr, arg, indexes, index++);
                }
                else if (arg is IEnumerable <object> && SequenceTuple((IEnumerable <object>)arg))
                {
                    foreach (object sub in (IEnumerable <object>)arg)
                    {
                        ConvertSingleIndex(arr, sub, indexes, index++);
                    }
                }
                else
                {
                    ConvertSingleIndex(arr, arg, indexes, index++);
                }
            }
        }
Example #5
0
        private static void ConvertSingleIndex(ndarray arr, Object arg, NpyIndexes indexes, int index)
        {
            if (arg == null)
            {
                indexes.AddNewAxis();
            }
            else if (arg is string && (string)arg == "...")
            {
                indexes.AddEllipsis();
            }
            else if (arg is Ellipsis)
            {
                indexes.AddEllipsis();
            }
            else if (arg is CSharpTuple)
            {
                indexes.AddCSharpTuple((CSharpTuple)arg);
            }
            else if (arg is bool)
            {
                indexes.AddIndex((bool)arg);
            }
            else if (arg is int)
            {
                indexes.AddIndex((int)arg);
            }
            else if (arg is BigInteger)
            {
                BigInteger bi   = (BigInteger)arg;
                npy_intp   lval = (npy_intp)bi;
                indexes.AddIndex(lval);
            }
            else if (arg is ISlice)
            {
                indexes.AddIndex((ISlice)arg);
            }
            else if (arg is string)
            {
                indexes.AddIndex(arr, (string)arg, index);
            }
            else
            {
                ndarray array_arg = null;

                if (arg.GetType().IsArray)
                {
                    dynamic arr1 = arg;
                    if (arr1[0] is ndarray)
                    {
                    }
                    else
                    {
                        array_arg = np.array(new VoidPtr(arr1), null);
                    }
                }
                else
                {
                    array_arg = arg as ndarray;
                }


                if (array_arg == null && arg is IEnumerable <object> )
                {
                    array_arg = np.FromIEnumerable((IEnumerable <object>)arg, null, false, 0, 0);
                }
                if (array_arg == null && arg is IEnumerable <npy_intp> )
                {
                    var arr1 = arg as IEnumerable <npy_intp>;
                    array_arg = np.array(arr1.ToArray(), null);
                }

                // Boolean scalars
                if (array_arg != null &&
                    array_arg.ndim == 0 &&
                    NpyDefs.IsBool(array_arg.TypeNum))
                {
                    indexes.AddIndex(Convert.ToBoolean(array_arg[0]));
                }
                // Integer scalars
                else if (array_arg != null &&
                         array_arg.ndim == 0 &&
                         NpyDefs.IsInteger(array_arg.TypeNum))
                {
                    try
                    {
                        indexes.AddIndex((npy_intp)Convert.ToInt64(array_arg[0]));
                    }
                    catch (Exception e)
                    {
                        throw new IndexOutOfRangeException(e.Message);
                    }
                }
                else if (array_arg != null)
                {
                    // Arrays must be either boolean or integer.
                    if (NpyDefs.IsInteger(array_arg.TypeNum))
                    {
                        indexes.AddIntpArray(array_arg);
                    }
                    else if (NpyDefs.IsBool(array_arg.TypeNum))
                    {
                        indexes.AddBoolArray(array_arg);
                    }
                    else
                    {
                        throw new IndexOutOfRangeException("arrays used as indices must be of integer (or boolean) type.");
                    }
                }
                else if (arg is IEnumerable <Object> )
                {
                    // Other sequences we convert to an intp array
                    indexes.AddIntpArray(arg);
                }
                else if (arg is IConvertible)
                {
#if NPY_INTP_64
                    indexes.AddIndex((npy_intp)Convert.ToInt64(arg));
#else
                    indexes.AddIndex((npy_intp)Convert.ToInt32(arg));
#endif
                }
                else
                {
                    throw new ArgumentException(String.Format("Argument '{0}' is not a valid index.", arg));
                }
            }
        }