using System;

using System.Collections.Generic;

using System.Linq;

using System.Numerics;

using System.Runtime.InteropServices;

using System.Text;

using Numpy.Models;

using Python.Runtime;

namespace Numpy

{

public partial class NDarray : PythonObject

{

// this is needed for constructors in NDarray<T>

protected NDarray() : base() { }

// these are manual overrides of functions or properties that can not be automatically generated

public NDarray(PyObject pyobj) : base(pyobj)

{

}

public NDarray(NDarray t) : base((PyObject) t.PyObject)

{

}

/// <summary>

/// Creates an array from an unmanaged (or fixed) memory pointer without copying.

/// </summary>

/// <param name="dataPtr">Pointer to a block of unmanaged memory or to a block of pinned managed memory</param>

/// <param name="dataLength">The length of the block of memory in bytes</param>

/// <param name="dtype">The data type of the resulting NDarray</param>

public NDarray(IntPtr dataPtr, long dataLength, Dtype dtype) : base()

{

// adapted from https://pastebin.com/4hANmBNy

// thanks to Eli Belash

var g = (Numpy.ctypes.dynamic_self.c_uint8 * dataLength).from_address(dataPtr.ToInt64());

self = np.dynamic_self.frombuffer(g, dtype.PyObject, -1);

}

/// <summary>

/// Returns a copy of the array data

/// </summary>

public T[] GetData<T>()

{

if (!PyObject.flags.c_contiguous)

return np.ascontiguousarray(this).GetData<T>();

long ptr = PyObject.ctypes.data;

int size = PyObject.size;

object array = null;

if (typeof(T) == typeof(byte)) array = new byte[size];

else if (typeof(T) == typeof(short)) array = new short[size];

else if (typeof(T) == typeof(int)) array = new int[size];

else if (typeof(T) == typeof(long)) array = new long[size];

else if (typeof(T) == typeof(float)) array = new float[size];

else if (typeof(T) == typeof(double)) array = new double[size];

else if (typeof(T) == typeof(bool)) array = new byte[size];

else if (typeof(T) == typeof(Complex)) array = new Complex[size];

else

throw new InvalidOperationException(

"Can not copy the data with data type due to limitations of Marshal.Copy: " + typeof(T).Name);

switch (array)

{

case byte[] a:

Marshal.Copy(new IntPtr(ptr), a, 0, a.Length);

break;

case short[] a:

Marshal.Copy(new IntPtr(ptr), a, 0, a.Length);

break;

case int[] a:

Marshal.Copy(new IntPtr(ptr), a, 0, a.Length);

break;

case long[] a:

Marshal.Copy(new IntPtr(ptr), a, 0, a.Length);

break;

case float[] a:

Marshal.Copy(new IntPtr(ptr), a, 0, a.Length);

break;

case double[] a:

Marshal.Copy(new IntPtr(ptr), a, 0, a.Length);

break;

case Complex[] a:

var real = this.real.GetData<double>();

var imag = this.imag.GetData<double>();

for(int i =0; i<a.Length; i++)

a[i]=new Complex(real[i], imag[i]);

break;

}

// special handling for types that are not supported by Marshal.Copy: must be converted i.e. 1 => true, 0 => false

if (typeof(T) == typeof(bool)) return (T[])(object)((byte[])array).Select(x=>x>0).ToArray();

return (T[]) array;

}

/// <summary>

/// Information about the memory layout of the array.

/// </summary>

public Flags flags => new Flags(self.GetAttr("flags")); // TODO: implement Flags

/// <summary>

/// Tuple of array dimensions.

/// </summary>

public Shape shape => new Shape( self.GetAttr("shape").As<int[]>());

/// <summary>

/// Tuple of bytes to step in each dimension when traversing an array.

/// </summary>

public int[] strides => self.GetAttr("strides").As<int[]>();

/// <summary>

/// Number of array dimensions.

/// </summary>

public int ndim => self.GetAttr("ndim").As<int>();

/// <summary>

/// Python buffer object pointing to the start of the array’s data.

/// </summary>

public PyObject data => self.GetAttr("data");

/// <summary>

/// Number of elements in the array.

/// </summary>

public int size => self.GetAttr("size").As<int>();

/// <summary>

/// Length of one array element in bytes.

/// </summary>

public int itemsize => self.GetAttr("itemsize").As<int>();

/// <summary>

/// Total bytes consumed by the elements of the array.

/// </summary>

public int nbytes => self.GetAttr("nbytes").As<int>();

/// <summary>

/// Base object if memory is from some other object.

/// </summary>

public NDarray @base

{

get

{

PyObject base_obj = self.GetAttr("base");

if (base_obj.IsNone())

return null;

return new NDarray(base_obj);

}

}

/// <summary>

/// Data-type of the array’s elements.

/// </summary>

public Dtype dtype => new Dtype(self.GetAttr("dtype"));

/// <summary>

/// Same as self.transpose(), except that self is returned if self.ndim &lt; 2.

/// </summary>

public NDarray T => new NDarray(self.GetAttr("T"));

///// <summary>

///// The real part of the array.

///// </summary>

//public NDarray real => new NDarray(self.GetAttr("real"));

///// <summary>

///// The imaginary part of the array.

///// </summary>

//public NDarray imag => new NDarray(self.GetAttr("imag"));

/// <summary>

/// A 1-D iterator over the array.

/// </summary>

public PyObject flat => self.GetAttr("flat"); // todo: wrap and support usecases

/// <summary>

/// An object to simplify the interaction of the array with the ctypes module.

/// </summary>

public PyObject ctypes => self.GetAttr("ctypes"); // TODO: wrap ctypes

/// <summary>

/// Length of the array (same as size)

/// </summary>

public int len => self.InvokeMethod("__len__").As<int>();

/// <summary>

/// Insert scalar into an array (scalar is cast to array’s dtype, if possible)

///

/// There must be at least 1 argument, and define the last argument

/// as item. Then, a.itemset(*args) is equivalent to but faster

/// than a[args] = item. The item should be a scalar value and args

/// must select a single item in the array a.

///

/// Notes

///

/// Compared to indexing syntax, itemset provides some speed increase

/// for placing a scalar into a particular location in an ndarray,

/// if you must do this. However, generally this is discouraged:

/// among other problems, it complicates the appearance of the code.

/// Also, when using itemset (and item) inside a loop, be sure

/// to assign the methods to a local variable to avoid the attribute

/// look-up at each loop iteration.

/// </summary>

/// <param name="args">

/// If one argument: a scalar, only used in case a is of size 1.

/// If two arguments: the last argument is the value to be set

/// and must be a scalar, the first argument specifies a single array

/// element location. It is either an int or a tuple.

/// </param>

public void itemset(params object[] args)

{

var pyargs = ToTuple(args);

var kwargs = new PyDict();

dynamic py = self.InvokeMethod("itemset", pyargs, kwargs);

}

/// <summary>

/// Construct Python bytes containing the raw data bytes in the array.

///

/// Constructs Python bytes showing a copy of the raw contents of

/// data memory. The bytes object can be produced in either ‘C’ or ‘Fortran’,

/// or ‘Any’ order (the default is ‘C’-order). ‘Any’ order means C-order

/// unless the F_CONTIGUOUS flag in the array is set, in which case it

/// means ‘Fortran’ order.

///

/// This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings.

/// </summary>

/// <param name="order">

/// Order of the data for multidimensional arrays:

/// C, Fortran, or the same as for the original array.

/// </param>

/// <returns>

/// Python bytes exhibiting a copy of a’s raw data.

/// </returns>

public byte[] tostring(string order = null)

{

return tobytes();

}

/// <summary>

/// Construct Python bytes containing the raw data bytes in the array.

///

/// Constructs Python bytes showing a copy of the raw contents of

/// data memory. The bytes object can be produced in either ‘C’ or ‘Fortran’,

/// or ‘Any’ order (the default is ‘C’-order). ‘Any’ order means C-order

/// unless the F_CONTIGUOUS flag in the array is set, in which case it

/// means ‘Fortran’ order.

/// </summary>

/// <param name="order">

/// Order of the data for multidimensional arrays:

/// C, Fortran, or the same as for the original array.

/// </param>

/// <returns>

/// Python bytes exhibiting a copy of a’s raw data.

/// </returns>

public byte[] tobytes(string order = null)

{

throw new NotImplementedException("TODO: this needs to be implemented with Marshal.Copy");

var pyargs = ToTuple(new object[]

{

});

var kwargs = new PyDict();

if (order != null) kwargs["order"] = ToPython(order);

dynamic py = self.InvokeMethod("tobytes", pyargs, kwargs);

return ToCsharp<byte[]>(py);

}

/// <summary>

/// New view of array with the same data.

///

/// Notes

///

/// a.view() is used two different ways:

///

/// a.view(some_dtype) or a.view(dtype=some_dtype) constructs a view

/// of the array’s memory with a different data-type. This can cause a

/// reinterpretation of the bytes of memory.

///

/// a.view(ndarray_subclass) or a.view(type=ndarray_subclass) just

/// returns an instance of ndarray_subclass that looks at the same array

/// (same shape, dtype, etc.) This does not cause a reinterpretation of the

/// memory.

///

/// For a.view(some_dtype), if some_dtype has a different number of

/// bytes per entry than the previous dtype (for example, converting a

/// regular array to a structured array), then the behavior of the view

/// cannot be predicted just from the superficial appearance of a (shown

/// by print(a)). It also depends on exactly how a is stored in

/// memory. Therefore if a is C-ordered versus fortran-ordered, versus

/// defined as a slice or transpose, etc., the view may give different

/// results.

/// </summary>

/// <param name="dtype">

/// Data-type descriptor of the returned view, e.g., float32 or int16. The

/// default, None, results in the view having the same data-type as a.

/// This argument can also be specified as an ndarray sub-class, which

/// then specifies the type of the returned object (this is equivalent to

/// setting the type parameter).

/// </param>

/// <param name="type">

/// Type of the returned view, e.g., ndarray or matrix. Again, the

/// default None results in type preservation.

/// </param>

public void view(Dtype dtype = null, Type type = null)

{

throw new NotImplementedException("Get python type 'ndarray' and 'matrix' and substitute them for the given .NET type");

var pyargs = ToTuple(new object[]

{

});

var kwargs = new PyDict();

if (dtype != null) kwargs["dtype"] = ToPython(dtype);

if (type != null) kwargs["type"] = ToPython(type);

dynamic py = self.InvokeMethod("view", pyargs, kwargs);

}

/// <summary>

/// Change shape and size of array in-place.

///

/// Notes

///

/// This reallocates space for the data area if necessary.

///

/// Only contiguous arrays (data elements consecutive in memory) can be

/// resized.

///

/// The purpose of the reference count check is to make sure you

/// do not use this array as a buffer for another Python object and then

/// reallocate the memory. However, reference counts can increase in

/// other ways so if you are sure that you have not shared the memory

/// for this array with another Python object, then you may safely set

/// refcheck to False.

/// </summary>

/// <param name="new_shape">

/// Shape of resized array.

/// </param>

/// <param name="refcheck">

/// If False, reference count will not be checked. Default is True.

/// </param>

public void resize(Shape new_shape, bool? refcheck = null)

{

var pyargs = ToTuple(new object[]

{

new_shape,

});

var kwargs = new PyDict();

if (refcheck != null) kwargs["refcheck"] = ToPython(refcheck);

dynamic py = self.InvokeMethod("resize", pyargs, kwargs);

}

/// <summary>

/// Gives a new shape to an array without changing its data.

///

/// Notes

///

/// It is not always possible to change the shape of an array without

/// copying the data. If you want an error to be raised when the data is copied,

/// you should assign the new shape to the shape attribute of the array:

///

/// The order keyword gives the index ordering both for fetching the values

/// from a, and then placing the values into the output array.

/// For example, let’s say you have an array:

///

/// You can think of reshaping as first raveling the array (using the given

/// index order), then inserting the elements from the raveled array into the

/// new array using the same kind of index ordering as was used for the

/// raveling.

/// </summary>

/// <param name="newshape">

/// The new shape should be compatible with the original shape. If

/// an integer, then the result will be a 1-D array of that length.

/// One shape dimension can be -1. In this case, the value is

/// inferred from the length of the array and remaining dimensions.

/// </param>

/// <returns>

/// This will be a new view object if possible; otherwise, it will

/// be a copy. Note there is no guarantee of the memory layout (C- or

/// Fortran- contiguous) of the returned array.

/// </returns>

public NDarray reshape(params int[] newshape)

{

//auto-generated code, do not change

var @this = this;

return np.reshape(@this, new Shape(newshape));

}

/// <summary>

/// returns the 'array([ .... ])'-representation known from the console

/// </summary>

public string repr => self.InvokeMethod("__repr__").As<string>();

/// <summary>

/// returns the '[ .... ]'-representation

/// </summary>

public string str => self.InvokeMethod("__str__").As<string>();

public NDarray this[string slicing_notation]

{

get

{

var tuple=new PyTuple(Slice.ParseSlices(slicing_notation).Select(s =>

{

if (s.IsIndex)

return new PyInt(s.Start.Value);

else

return s.ToPython();

}).ToArray());

return new NDarray(this.PyObject[tuple]);

}

set

{

var tuple = new PyTuple(Slice.ParseSlices(slicing_notation).Select(s =>

{

if (s.IsIndex)

return new PyInt(s.Start.Value);

else

return s.ToPython();

}).ToArray());

self.SetItem(tuple, ToPython(value));

}

}

public NDarray this[params int[] coords]

{

get

{

var tuple = ToTuple(coords);

return new NDarray(this.PyObject[tuple]);

}

set

{

var tuple = ToTuple(coords);

self.SetItem(tuple, ToPython(value));

}

}

public NDarray this[params NDarray[] indices]

{

get

{

var tuple = new PyTuple(indices.Select(a => (PyObject)a.PyObject).ToArray());

return new NDarray(this.PyObject[tuple]);

}

set

{

var tuple = new PyTuple(indices.Select(a => (PyObject)a.PyObject).ToArray());

self.SetItem(tuple, ToPython(value));

}

}

public NDarray this[params object[] arrays_slices_or_indices]

{

get

{

var pyobjs = arrays_slices_or_indices.Select<object ,PyObject>(x =>

{

switch (x)

{

case int i: return new PyInt(i);

case NDarray a: return a.PyObject;

case string s: return new Slice(s).ToPython();

default: return ToPython(x);

}

}).ToArray();

var tuple = new PyTuple(pyobjs);

return new NDarray(this.PyObject[tuple]);

}

set

{

var pyobjs = arrays_slices_or_indices.Select<object, PyObject>(x =>

{

switch (x)

{

case int i: return new PyInt(i);

case NDarray a: return a.PyObject;

case string s: return new Slice(s).ToPython();

default: return ToPython(x);

}

}).ToArray();

var tuple = new PyTuple(pyobjs);

self.SetItem(tuple, ToPython(value));

}

}

/// <summary>

/// Convert an array of size 1 to its scalar equivalent.

/// </summary>

/// <returns>

/// Scalar representation of a. The output data type is the same type

/// returned by the input’s item method.

/// </returns>

public T asscalar<T>()

{

return np.asscalar<T>(this);

}

public override bool Equals(object obj)

{

if (obj == null)

return false;

var array = obj as NDarray;

if (!object.ReferenceEquals(array, null))

return np.array_equal(this, array);

return base.Equals(obj);

}

public NDarray real

{

get

{

dynamic py = self.GetAttr("real");

return ToCsharp<NDarray>(py);

}

set

{

self.SetAttr("real", value.PyObject);

}

}

public NDarray imag

{

get

{

dynamic py = self.GetAttr("imag");

return ToCsharp<NDarray>(py);

}

set

{

self.SetAttr("imag", value.PyObject);

}

}

/// <summary>

/// Returns a view of the array with axes transposed.<br></br>

///

/// For a 1-D array, this has no effect.<br></br>

/// (To change between column and

/// row vectors, first cast the 1-D array into a matrix object.)

/// For a 2-D array, this is the usual matrix transpose.<br></br>

///

/// For an n-D array, if axes are given, their order indicates how the

/// axes are permuted (see Examples).<br></br>

/// If axes are not provided and

/// a.shape = (i[0], i[1], ... i[n-2], i[n-1]), then

/// a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0]).

/// </summary>

/// <returns>

/// View of a, with axes suitably permuted.

/// </returns>

public NDarray transpose(params int[] axes)

{

//auto-generated code, do not change

var __self__ = self;

var pyargs = ToTuple(new object[]

{

ToPython(axes),

});

//if (axes != null) kwargs["axes"] = ToPython(axes);

dynamic py = __self__.InvokeMethod("transpose", pyargs);

return ToCsharp<NDarray>(py);

}

}

public class NDarray<T> : NDarray

{

public NDarray(NDarray t) : base(t)

{

}

public NDarray(PyObject pyobject) : base(pyobject)

{

}

public NDarray(T[] array) : base()

{

var nd = np.array(array);

self = nd.self;

}

/// <summary>

/// Returns a copy of the array data

/// </summary>

public T[] GetData()

{

return base.GetData<T>();

}

public new NDarray<T> this[string slicing_notation]

{

get

{

var tuple = new PyTuple(Slice.ParseSlices(slicing_notation).Select(s =>

{

if (s.IsIndex)

return new PyInt(s.Start.Value);

else

return s.ToPython();

}).ToArray());

return new NDarray<T>(this.PyObject[tuple]);

}

set

{

var tuple = new PyTuple(Slice.ParseSlices(slicing_notation).Select(s =>

{

if (s.IsIndex)

return new PyInt(s.Start.Value);

else

return s.ToPython();

}).ToArray());

self.SetItem(tuple, ToPython(value));

}

}

public new NDarray this[params int[] coords]

{

get

{

var tuple = ToTuple(coords);

return new NDarray<T>(this.PyObject[tuple]);

}

set

{

var tuple = ToTuple(coords);

self.SetItem(tuple, ToPython(value));

}

}

public new NDarray this[params NDarray[] indices]

{

get

{

var tuple = new PyTuple(indices.Select(a => (PyObject)a.PyObject).ToArray());

return new NDarray<T>(this.PyObject[tuple]);

}

set

{

var tuple = new PyTuple(indices.Select(a => (PyObject)a.PyObject).ToArray());

self.SetItem(tuple, ToPython(value));

}

}

public new NDarray this[params object[] arrays_slices_or_indices]

{

get

{

var pyobjs = arrays_slices_or_indices.Select<object, PyObject>(x =>

{

switch (x)

{

case int i: return new PyInt(i);

case NDarray a: return a.PyObject;

case string s: return new Slice(s).ToPython();

default: return ToPython(x);

}

}).ToArray();

var tuple = new PyTuple(pyobjs);

return new NDarray(this.PyObject[tuple]);

}

set

{

var pyobjs = arrays_slices_or_indices.Select<object, PyObject>(x =>

{

switch (x)

{

case int i: return new PyInt(i);

case NDarray a: return a.PyObject;

case string s: return new Slice(s).ToPython();

default: return ToPython(x);

}

}).ToArray();

var tuple = new PyTuple(pyobjs);

self.SetItem(tuple, ToPython(value));

}

}

}

}