Esempio n. 1
0
        private static void AssignFromSeq(IEnumerable <Object> seq, ndarray result,
                                          int dim, long offset)
        {
            if (dim >= result.ndim)
            {
                throw new RuntimeException(String.Format("Source dimensions ({0}) exceeded target array dimensions ({1}).", dim, result.ndim));
            }

            if (seq is ndarray && seq.GetType() != typeof(ndarray))
            {
                // Convert to an array to ensure the dimensionality reduction
                // assumption works.
                ndarray array = NpyCoreApi.FromArray((ndarray)seq, null, NPYARRAYFLAGS.NPY_ENSUREARRAY);
                seq = (IEnumerable <object>)array;
            }

            if (seq.Count() != result.Dim(dim))
            {
                throw new RuntimeException("AssignFromSeq: sequence/array shape mismatch.");
            }

            long stride = result.Stride(dim);

            if (dim < result.ndim - 1)
            {
                // Sequence elements should be additional sequences
                seq.Iteri((o, i) =>
                          AssignFromSeq((IEnumerable <Object>)o, result, dim + 1, offset + stride * i));
            }
            else
            {
                seq.Iteri((o, i) => result.Dtype.f.setitem(offset + i * stride, o, result.Array));
            }
        }
Esempio n. 2
0
        private static ndarray _broadcast_to(object oarray, object oshape, bool subok, bool _readonly)
        {
            shape newshape = NumpyExtensions.ConvertTupleToShape(oshape);

            if (newshape == null)
            {
                throw new Exception("Unable to convert shape object");
            }

            if (newshape.iDims == null || newshape.iDims.Length == 0)
            {
                newshape = new shape(asanyarray(oarray).shape);
            }

            ndarray array = np.array(asanyarray(oarray), copy: false, subok: subok);

            if (array.dims == null)
            {
                throw new ValueError("cannot broadcast a non-scalar to a scalar array");
            }

            if (np.anyb(np.array(newshape.iDims) < 0))
            {
                throw new ValueError("all elements of broadcast shape must be non-negative");
            }

            var toshape = NpyCoreApi.BroadcastToShape(array, newshape.iDims, newshape.iDims.Length);

            var newStrides = new npy_intp[toshape.nd_m1 + 1];

            Array.Copy(toshape.strides, 0, newStrides, 0, newStrides.Length);
            var result = np.as_strided(array, shape: newshape.iDims, strides: newStrides);

            return(result);
        }
Esempio n. 3
0
        /// <summary>
        /// Performs a generic reduce or accumulate operation on an input array.
        /// A reduce operation reduces the number of dimensions of the input array
        /// by one where accumulate does not.  Accumulate stores in incremental
        /// accumulated values in the extra dimension.
        /// </summary>
        /// <param name="arr">Input array</param>
        /// <param name="indices">Used only for reduceat</param>
        /// <param name="axis">Axis to reduce</param>
        /// <param name="otype">Output type of the array</param>
        /// <param name="outArr">Optional output array</param>
        /// <param name="operation">Reduce/accumulate operation to perform</param>
        /// <returns>Resulting array, either outArr or a new array</returns>
        private Object GenericReduce(ndarray arr, ndarray indices, int axis,
                                     dtype otype, ndarray outArr, GenericReductionOp operation)
        {
            if (signature() != null)
            {
                throw new RuntimeException("Reduction is not defined on ufunc's with signatures");
            }
            if (nin != 2)
            {
                throw new ArgumentException("Reduce/accumulate only supported for binary functions");
            }
            if (nout != 1)
            {
                throw new ArgumentException("Reduce/accumulate only supported for functions returning a single value");
            }

            if (arr.ndim == 0)
            {
                throw new ArgumentTypeException("Cannot reduce/accumulate a scalar");
            }

            if (arr.IsFlexible || (otype != null && NpyDefs.IsFlexible(otype.TypeNum)))
            {
                throw new ArgumentTypeException("Cannot perform reduce/accumulate with flexible type");
            }

            return(NpyCoreApi.GenericReduction(this, arr, indices,
                                               outArr, axis, otype, operation));
        }
Esempio n. 4
0
        public static dtype result_type(NPY_TYPES type_num)
        {
            var   return_type  = DefaultArrayHandlers.GetArrayHandler(type_num).MathOpFloatingType(UFuncOperation.divide);
            dtype result_dtype = NpyCoreApi.DescrFromType(return_type);

            return(result_dtype);
        }
Esempio n. 5
0
            public static ndarray outer(NpyArray_Ops ops, dtype dtype, object a, object b, ndarray @out = null, int?axis = null)
            {
                var a1 = np.asanyarray(a);
                var b1 = np.asanyarray(b);


                List <npy_intp> destdims = new List <npy_intp>();

                foreach (var dim in a1.shape.iDims)
                {
                    destdims.Add(dim);
                }
                foreach (var dim in b1.shape.iDims)
                {
                    destdims.Add(dim);
                }



                ndarray dest = @out;

                if (dest == null)
                {
                    dest = np.empty(new shape(destdims), dtype: dtype != null ? dtype : a1.Dtype);
                }

                return(NpyCoreApi.PerformOuterOp(a1, b1, dest, ops));
            }
Esempio n. 6
0
        internal static void SetField(ndarray dest, NpyArray_Descr descr, int offset, object src)
        {
            // For char arrays pad the input string.
            if (dest.Dtype.Type == NPY_TYPECHAR.NPY_CHARLTR &&
                dest.ndim > 0 && src is String)
            {
                int ndimNew = (int)dest.Dim(dest.ndim - 1);
                int ndimOld = ((String)src).Length;

                if (ndimNew > ndimOld)
                {
                    src = ((String)src).PadRight(ndimNew, ' ');
                }
            }
            ndarray srcArray;

            if (src is ndarray)
            {
                srcArray = (ndarray)src;
            }
            else if (false)
            {
                // TODO: Not handling scalars.  See arrayobject.c:111
            }
            else
            {
                dtype src_dtype = new dtype(descr);
                srcArray = np.FromAny(src, src_dtype, 0, dest.ndim, NPYARRAYFLAGS.NPY_CARRAY, null);
            }
            NpyCoreApi.Incref(descr);
            if (numpyAPI.NpyArray_SetField(dest.core, descr, offset, srcArray.core) < 0)
            {
                NpyCoreApi.CheckError();
            }
        }
Esempio n. 7
0
        private static bool can_cast(object from_, dtype to, string casting = "safe")
        {
            dtype from = null;

            if (from_ is dtype)
            {
                from = from_ as dtype;
            }
            else
            {
                try
                {
                    var arr = asanyarray(from_);
                    if (arr != null)
                    {
                        from = arr.Dtype;
                    }
                }
                catch (Exception ex)
                {
                    return(false);
                }
            }

            return(NpyCoreApi.CanCastTo(from, to));
        }
Esempio n. 8
0
        /// <summary>
        /// Copies the source object into the destination array.  src can be
        /// any type so long as the number of elements matches dest.  In the
        /// case of strings, they will be padded with spaces if needed but
        /// can not be longer than the number of elements in dest.
        /// </summary>
        /// <param name="dest">Destination array</param>
        /// <param name="src">Source object</param>
        public static void CopyObject(ndarray dest, Object src)
        {
            // For char arrays pad the input string.
            if (dest.Dtype.Type == NPY_TYPECHAR.NPY_CHARLTR &&
                dest.ndim > 0 && src is String)
            {
                int ndimNew = (int)dest.Dim(dest.ndim - 1);
                int ndimOld = ((String)src).Length;

                if (ndimNew > ndimOld)
                {
                    src = ((String)src).PadRight(ndimNew, ' ');
                }
            }

            ndarray srcArray;

            if (src is ndarray)
            {
                srcArray = (ndarray)src;
            }
            else if (false)
            {
                // TODO: Not handling scalars.  See arrayobject.c:111
            }
            else
            {
                srcArray = np.FromAny(src, dest.Dtype, 0, dest.ndim, 0, null);
            }
            NpyCoreApi.MoveInto(dest, srcArray);
        }
Esempio n. 9
0
        internal static ndarray FromPythonScalar(object src, dtype descr)
        {
            int       itemsize = descr.ElementSize;
            NPY_TYPES type     = descr.TypeNum;

            if (itemsize == 0 && NpyDefs.IsExtended(type))
            {
                int n = PythonOps.Length(src);
                if (type == NPY_TYPES.NPY_UNICODE)
                {
                    n *= 4;
                }
                descr             = new dtype(descr);
                descr.ElementSize = n;
            }

            ndarray result = NpyCoreApi.AllocArray(descr, 0, null, false);

            if (result.ndim > 0)
            {
                throw new ArgumentException("shape-mismatch on array construction");
            }

            result.Dtype.f.setitem(0, src, result.Array);
            return(result);
        }
Esempio n. 10
0
 public bool Equals(dtype other)
 {
     if (other == null)
     {
         return(false);
     }
     return(this.core == other.core || NpyCoreApi.EquivTypes(this, other));
 }
Esempio n. 11
0
        internal byte[] ToString(NPY_ORDER order = NPY_ORDER.NPY_ANYORDER)
        {
            long nbytes = Size * Dtype.ElementSize;

            byte[] data = new byte[nbytes];
            NpyCoreApi.GetBytes(this, data, order);
            return(data);
        }
Esempio n. 12
0
        internal object Get(npy_intp index)
        {
            VoidPtr pos = NpyCoreApi.IterGoto1D(this, index);

            if (pos == null)
            {
                NpyCoreApi.CheckError();
            }
            return(arr.GetItem(index));
        }
Esempio n. 13
0
        internal void SingleAssign(npy_intp index, object value)
        {
            VoidPtr pos = NpyCoreApi.IterGoto1D(this, index);

            if (pos == null)
            {
                NpyCoreApi.CheckError();
            }
            arr.SetItem(value, index);
        }
Esempio n. 14
0
        /// <summary>
        /// Returns the descriptor for a given native type or null if src is
        /// not a scalar type
        /// </summary>
        /// <param name="src">Object to type</param>
        /// <returns>Descriptor for type of 'src' or null if not scalar</returns>
        internal static dtype FindScalarType(Object src)
        {
            NPY_TYPES type = DefaultArrayHandlers.GetArrayType(src);

            if (type != NPY_TYPES.NPY_NOTSET)
            {
                return(NpyCoreApi.DescrFromType(type));
            }
            return(null);
        }
Esempio n. 15
0
        internal static ndarray FromScalar(ScalarGeneric scalar, dtype descr = null)
        {
            ndarray arr = scalar.ToArray();

            if (descr != null && !NpyCoreApi.EquivTypes((dtype)scalar.dtype, descr))
            {
                arr = NpyCoreApi.CastToType(arr, descr, arr.IsFortran);
            }
            return(arr);
        }
Esempio n. 16
0
        private static dtype FindArrayReturn(dtype chktype, dtype minitype)
        {
            dtype result = NpyCoreApi.SmallType(chktype, minitype);

            if (result.TypeNum == NPY_TYPES.NPY_VOID &&
                minitype.TypeNum != NPY_TYPES.NPY_VOID)
            {
                result = NpyCoreApi.DescrFromType(NPY_TYPES.NPY_OBJECT);
            }
            return(result);
        }
Esempio n. 17
0
        public static ndarray dot(object o1, object o2)
        {
            dtype d = FindArrayType(asanyarray(o1), null);

            d = FindArrayType(asanyarray(o2), d);

            ndarray a1 = np.FromAny(o1, d, flags: NPYARRAYFLAGS.NPY_ALIGNED);
            ndarray a2 = np.FromAny(o2, d, flags: NPYARRAYFLAGS.NPY_ALIGNED);

            return(NpyCoreApi.MatrixProduct(a1, a2, d.TypeNum));
        }
Esempio n. 18
0
        /// <summary>
        /// Dot product of two arrays.
        /// </summary>
        /// <param name="a">input array</param>
        /// <param name="b">input array</param>
        /// <returns></returns>
        public static ndarray dot(object a, object b)
        {
            dtype d = FindArrayType(asanyarray(a), null);

            d = FindArrayType(asanyarray(b), d);

            ndarray arr1 = np.FromAny(a, d, flags: NPYARRAYFLAGS.NPY_ALIGNED);
            ndarray arr2 = np.FromAny(b, d, flags: NPYARRAYFLAGS.NPY_ALIGNED);

            return(NpyCoreApi.MatrixProduct(arr1, arr2, d.TypeNum));
        }
Esempio n. 19
0
 public bool MoveNext()
 {
     if (current == null)
     {
         current = core.dataptr;
     }
     else
     {
         current = NpyCoreApi.IterNext(core);
     }
     return(current != null);
 }
Esempio n. 20
0
 public bool MoveNext()
 {
     if (current == null)
     {
         current = core;
     }
     else
     {
         NpyCoreApi.MultiIterNext(core);
     }
     return(NpyCoreApi.MultiIterDone(core));
 }
Esempio n. 21
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);
                }
            }
        }
Esempio n. 22
0
        private static ndarray ndArrayFromMD(Array ssrc, NPY_TYPES type_num, int ndim)
        {
            npy_intp [] newshape = new npy_intp[ndim];
            for (int i = 0; i < ndim; i++)
            {
                newshape[i] = ssrc.GetLength(i);
            }

            dtype WantedDType = NpyCoreApi.DescrFromType(type_num);

            return(np.array(new VoidPtr(ArrayFromMD(ssrc, type_num), type_num), dtype: WantedDType).reshape(newshape));
        }
Esempio n. 23
0
 internal void FillWithScalar(object scalar)
 {
     if (Dtype.IsObject)
     {
         NpyCoreApi.FillWithObject(this, scalar);
     }
     else
     {
         ndarray zero_d_array = np.FromAny(scalar, Dtype, flags: NPYARRAYFLAGS.NPY_ALIGNED);
         NpyCoreApi.FillWithScalar(this, zero_d_array);
     }
 }
Esempio n. 24
0
            internal static ndarray reduce(NpyArray_Ops ops, object a, int axis = 0, dtype dtype = null, ndarray @out = null, bool keepdims = false)
            {
                ndarray arr = asanyarray(a);

                if (arr == null)
                {
                    throw new ValueError("unable to convert a to ndarray");
                }

                NPY_TYPES rtype = dtype != null ? dtype.TypeNum : arr.Dtype.TypeNum;

                return(NpyCoreApi.PerformReduceOp(arr, axis, ops, rtype, @out, keepdims));
            }
Esempio n. 25
0
        internal void AddIntpArray(Object arg)
        {
            // Convert to an intp array
            ndarray arr = np.FromAny(arg, NpyCoreApi.DescrFromType(NPY_TYPES.NPY_INTP), 0, 0, NPYARRAYFLAGS.NPY_FORCECAST, null);

            // Write the type
            indexes[num_indexes].type = NpyIndexType.NPY_INDEX_INTP_ARRAY;

            // Write the array
            indexes[num_indexes].intp_array = arr.Array;

            ++num_indexes;
        }
Esempio n. 26
0
        internal void AddBoolArray(Object arg)
        {
            // Convert to an intp array
            ndarray arr = np.FromAny(arg, NpyCoreApi.DescrFromType(NPY_TYPES.NPY_BOOL), 0, 0, 0, null);

            // Write the type
            indexes[num_indexes].type = NpyIndexType.NPY_INDEX_BOOL_ARRAY;

            // Write the array
            indexes[num_indexes].bool_array = arr.Array;

            ++num_indexes;
        }
Esempio n. 27
0
            internal static ndarray accumulate(UFuncOperation ops, object a, int axis = 0, dtype dtype = null, ndarray @out = null)
            {
                ndarray arr = asanyarray(a);

                if (arr == null)
                {
                    throw new ValueError("unable to convert a to ndarray");
                }


                NPY_TYPES rtype = dtype != null ? dtype.TypeNum : arr.TypeNum;

                return(NpyCoreApi.PerformAccumulateOp(arr, axis, ops, rtype, @out));
            }
Esempio n. 28
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);
        }
Esempio n. 29
0
        private static ndarray FromScalar(object src, dtype descr, object context)
        {
            npy_intp[] dims = new npy_intp[1] {
                1
            };
            ndarray result = NpyCoreApi.AllocArray(descr, 1, dims, false);

            if (result.ndim != 1)
            {
                throw new ArgumentException("shape-mismatch on array construction");
            }

            result.Dtype.f.setitem(0, src, result.Array);
            return(result);
        }
Esempio n. 30
0
        internal static ndarray FromNestedList(object src, dtype descr, bool fortran)
        {
            npy_intp[] dims = new npy_intp[NpyDefs.NPY_MAXDIMS];


            int nd = ObjectDepthAndDimension(src, dims, 0, NpyDefs.NPY_MAXDIMS);

            if (nd == 0)
            {
                return(FromPythonScalar(src, descr));
            }
            ndarray result = NpyCoreApi.AllocArray(descr, nd, dims, fortran);

            AssignToArray(src, result);
            return(result);
        }