public static ndarray reshape(this ndarray a, params long[] newshape)
{
npy_intp[] newdims = new npy_intp[newshape.Length];
for (int i = 0; i < newshape.Length; i++)
{
newdims[i] = newshape[i];
}
return(a.reshape(newdims, NPY_ORDER.NPY_ANYORDER));
}
private static ndarray reshape_uniq(ndarray uniq, int axis, dtype orig_dtype, npy_intp[] orig_shape)
{
uniq = uniq.view(orig_dtype);
npy_intp[] orig_shape_adjusted = new npy_intp[orig_shape.Length];
Array.Copy(orig_shape, 0, orig_shape_adjusted, 0, orig_shape.Length);
orig_shape_adjusted[0] = -1;
uniq = uniq.reshape(new shape(orig_shape_adjusted));
uniq = np.swapaxes(uniq, 0, axis);
return(uniq);
}
public static ndarray upscale_to(ndarray a, object oshape)
{
shape newshape = NumpyExtensions.ConvertTupleToShape(oshape);
if (newshape == null)
{
throw new Exception("Unable to convert shape object");
}
if (!broadcastable(a, newshape.iDims, newshape.iDims.Length))
{
throw new Exception(string.Format("operands could not be broadcast together with shapes ({0}),({1})", a.shape.ToString(), newshape.ToString()));
}
ndarray ret = NpyCoreApi.NpyArray_UpscaleSourceArray(a, newshape);
return(ret.reshape(newshape));
}
public static uniqueData unique(ndarray ar, bool return_index = false, bool return_inverse = false, bool return_counts = false, int?axis = null)
{
/*
* Find the unique elements of an array.
*
* Returns the sorted unique elements of an array. There are three optional
* outputs in addition to the unique elements:
*
* the indices of the input array that give the unique values
* the indices of the unique array that reconstruct the input array
* the number of times each unique value comes up in the input array
*
* Parameters
* ----------
* ar : array_like
* Input array. Unless `axis` is specified, this will be flattened if it
* is not already 1-D.
* return_index : bool, optional
* If True, also return the indices of `ar` (along the specified axis,
* if provided, or in the flattened array) that result in the unique array.
* return_inverse : bool, optional
* If True, also return the indices of the unique array (for the specified
* axis, if provided) that can be used to reconstruct `ar`.
* return_counts : bool, optional
* If True, also return the number of times each unique item appears
* in `ar`.
*
* .. versionadded:: 1.9.0
*
* axis : int or None, optional
* The axis to operate on. If None, `ar` will be flattened. If an integer,
* the subarrays indexed by the given axis will be flattened and treated
* as the elements of a 1-D array with the dimension of the given axis,
* see the notes for more details. Object arrays or structured arrays
* that contain objects are not supported if the `axis` kwarg is used. The
* default is None.
*
* .. versionadded:: 1.13.0
*
* Returns
* -------
* unique : ndarray
* The sorted unique values.
* unique_indices : ndarray, optional
* The indices of the first occurrences of the unique values in the
* original array. Only provided if `return_index` is True.
* unique_inverse : ndarray, optional
* The indices to reconstruct the original array from the
* unique array. Only provided if `return_inverse` is True.
* unique_counts : ndarray, optional
* The number of times each of the unique values comes up in the
* original array. Only provided if `return_counts` is True.
*/
ar = np.asanyarray(ar);
if (axis == null)
{
var ret = _unique1d(ar, return_index, return_inverse, return_counts);
return(ret);
}
// axis was specified and not None
try
{
ar = swapaxes(ar, axis.Value, 0);
}
catch (Exception ex)
{
string Error = ex.Message;
throw new Exception(Error);
}
npy_intp[] orig_shape = ar.dims;
dtype orig_dtype = ar.Dtype;
ar = ar.reshape(new shape((int)orig_shape[0], -1));
ar = np.ascontiguousarray(ar);
ndarray consolidated = null;
try
{
// todo: this nasty code needs to be implemented in order for this to work correctly.
// dtype = [('f{i}'.format(i = i), ar.dtype) for i in range(ar.shape[1])]
// consolidated = ar.view(dtype);
consolidated = ar.view(ar.Dtype);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
var output = _unique1d(consolidated, return_index, return_inverse, return_counts);
output.data = reshape_uniq(output.data, axis.Value, orig_dtype, orig_shape);
return(output);
}
