{

[TestMethod]

public void emptyTest()

{

var given = np.empty(new Shape(2, 2), np.int32);

Assert.IsTrue(given.repr.StartsWith("array([["));

Assert.IsTrue(given.repr.EndsWith("]])"));

}

[TestMethod]

public void empty_likeTest()

{

var a = new[,] { { 1, 2, 3 }, { 4, 5, 6 } };

var given = np.empty_like(a);

Assert.AreEqual(new Shape(2, 3), given.shape);

Assert.AreEqual(np.int32, given.dtype);

var b = np.array(new[,] { { 1f, 2f, 3f }, { 4f, 5f, 6f } });

var c = np.empty_like(b);

Assert.AreEqual(new Shape(2, 3), c.shape);

Assert.AreEqual(np.float32, c.dtype);

}

[TestMethod]

public void eyeTest()

{

// >>> np.eye(2, dtype=int)

// array([[1, 0],

// [0, 1]])

// >>> np.eye(3, k=1)

// array([[ 0., 1., 0.],

// [ 0., 0., 1.],

// [ 0., 0., 0.]])

//

var given = np.eye(2, dtype: np.int_);

var expected =

"array([[1, 0],\n" +

" [0, 1]])";

Assert.AreEqual(expected, given.repr);

given = np.eye(3, k: 1);

expected =

"array([[0., 1., 0.],\n" +

" [0., 0., 1.],\n" +

" [0., 0., 0.]])";

Assert.AreEqual(expected, given.repr);

}

[TestMethod]

public void identityTest()

{

// >>> np.identity(3)

// array([[ 1., 0., 0.],

// [ 0., 1., 0.],

// [ 0., 0., 1.]])

//

var given = np.identity(3);

var expected =

"array([[1., 0., 0.],\n" +

" [0., 1., 0.],\n" +

" [0., 0., 1.]])";

Assert.AreEqual(expected, given.repr);

}

[TestMethod]

public void onesTest()

{

// >>> np.ones(5)

// array([ 1., 1., 1., 1., 1.])

//

var given = np.ones(5);

var expected =

"array([1., 1., 1., 1., 1.])";

Assert.AreEqual(expected, given.repr);

// >>> np.ones((5,), dtype=int)

// array([1, 1, 1, 1, 1])

//

given = np.ones(new Shape(5), dtype: np.int_);

expected =

"array([1, 1, 1, 1, 1])";

Assert.AreEqual(expected, given.repr);

// >>> np.ones((2, 1))

// array([[ 1.],

// [ 1.]])

//

given = np.ones(new Shape(2, 1));

expected =

"array([[1.],\n" +

" [1.]])";

Assert.AreEqual(expected, given.repr);

// >>> s = (2,2)

// >>> np.ones(s)

// array([[ 1., 1.],

// [ 1., 1.]])

//

var s = new Shape(2, 2);

given = np.ones(s);

expected =

"array([[1., 1.],\n" +

" [1., 1.]])";

Assert.AreEqual(expected, given.repr);

}

[TestMethod]

public void ones_likeTest()

{

// >>> x = np.arange(6)

// >>> x = x.reshape((2, 3))

// >>> x

// array([[0, 1, 2],

// [3, 4, 5]])

// >>> np.ones_like(x)

// array([[1, 1, 1],

// [1, 1, 1]])

//

var x = np.arange(6);

x = x.reshape(2, 3);

var given = x;

var expected =

"array([[0, 1, 2],\n" +

" [3, 4, 5]])";

Assert.AreEqual(expected, given.repr);

given = np.ones_like(x);

expected =

"array([[1, 1, 1],\n" +

" [1, 1, 1]])";

Assert.AreEqual(expected, given.repr);

// >>> y = np.arange(3, dtype=float)

// >>> y

// array([ 0., 1., 2.])

// >>> np.ones_like(y)

// array([ 1., 1., 1.])

//

var y = np.arange(3, dtype: np.float_);

given = y;

expected =

"array([0., 1., 2.])";

Assert.AreEqual(expected, given.repr);

given = np.ones_like(y);

expected =

"array([1., 1., 1.])";

Assert.AreEqual(expected, given.repr);

}

[TestMethod]

public void zerosTest()

{

// >>> np.zeros(5)

// array([ 0., 0., 0., 0., 0.])

//

var given = np.zeros(5);

var expected =

"array([0., 0., 0., 0., 0.])";

Assert.AreEqual(expected, given.repr);

// >>> np.zeros((5,), dtype=int)

// array([0, 0, 0, 0, 0])

//

#if TODO

given= np.zeros((5,), dtype=int);

expected=

"array([0, 0, 0, 0, 0])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> np.zeros((2, 1))

// array([[ 0.],

// [ 0.]])

//

#if TODO

given= np.zeros((2, 1));

expected=

"array([[ 0.],\n" +

" [ 0.]])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> s = (2,2)

// >>> np.zeros(s)

// array([[ 0., 0.],

// [ 0., 0.]])

//

#if TODO

given= s = (2,2);

given= np.zeros(s);

expected=

"array([[ 0., 0.],\n" +

" [ 0., 0.]])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype

// array([(0, 0), (0, 0)],

// dtype=[('x', '<i4'), ('y', '<i4')])

//

#if TODO

given= np.zeros((2,), dtype={('x', 'i4'), ('y', 'i4')}) # custom dtype;

expected=

"array([(0, 0), (0, 0)],\n" +

" dtype=[('x', '<i4'), ('y', '<i4')])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void zeros_likeTest()

{

// >>> x = np.arange(6)

// >>> x = x.reshape((2, 3))

// >>> x

// array([[0, 1, 2],

// [3, 4, 5]])

// >>> np.zeros_like(x)

// array([[0, 0, 0],

// [0, 0, 0]])

//

#if TODO

var given= x = np.arange(6);

given= x = x.reshape((2, 3));

given= x;

var expected=

"array([[0, 1, 2],\n" +

" [3, 4, 5]])";

Assert.AreEqual(expected, given.repr);

given= np.zeros_like(x);

expected=

"array([[0, 0, 0],\n" +

" [0, 0, 0]])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> y = np.arange(3, dtype=float)

// >>> y

// array([ 0., 1., 2.])

// >>> np.zeros_like(y)

// array([ 0., 0., 0.])

//

#if TODO

given= y = np.arange(3, dtype=float);

given= y;

expected=

"array([ 0., 1., 2.])";

Assert.AreEqual(expected, given.repr);

given= np.zeros_like(y);

expected=

"array([ 0., 0., 0.])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void fullTest()

{

// >>> np.full((2, 2), np.inf)

// array([[ inf, inf],

// [ inf, inf]])

// >>> np.full((2, 2), 10)

// array([[10, 10],

// [10, 10]])

//

#if TODO

var given= np.full((2, 2), np.inf);

var expected=

"array([[ inf, inf],\n" +

" [ inf, inf]])";

Assert.AreEqual(expected, given.repr);

given= np.full((2, 2), 10);

expected=

"array([[10, 10],\n" +

" [10, 10]])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void full_likeTest()

{

// >>> x = np.arange(6, dtype=int)

// >>> np.full_like(x, 1)

// array([1, 1, 1, 1, 1, 1])

// >>> np.full_like(x, 0.1)

// array([0, 0, 0, 0, 0, 0])

// >>> np.full_like(x, 0.1, dtype=np.double)

// array([ 0.1, 0.1, 0.1, 0.1, 0.1, 0.1])

// >>> np.full_like(x, np.nan, dtype=np.double)

// array([ nan, nan, nan, nan, nan, nan])

//

#if TODO

var given= x = np.arange(6, dtype=int);

given= np.full_like(x, 1);

var expected=

"array([1, 1, 1, 1, 1, 1])";

Assert.AreEqual(expected, given.repr);

given= np.full_like(x, 0.1);

expected=

"array([0, 0, 0, 0, 0, 0])";

Assert.AreEqual(expected, given.repr);

given= np.full_like(x, 0.1, dtype=np.double);

expected=

"array([ 0.1, 0.1, 0.1, 0.1, 0.1, 0.1])";

Assert.AreEqual(expected, given.repr);

given= np.full_like(x, np.nan, dtype=np.double);

expected=

"array([ nan, nan, nan, nan, nan, nan])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> y = np.arange(6, dtype=np.double)

// >>> np.full_like(y, 0.1)

// array([ 0.1, 0.1, 0.1, 0.1, 0.1, 0.1])

//

#if TODO

given= y = np.arange(6, dtype=np.double);

given= np.full_like(y, 0.1);

expected=

"array([ 0.1, 0.1, 0.1, 0.1, 0.1, 0.1])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void arrayLeakTest()

{

var arr = new double[10_000_000];

using (var process = System.Diagnostics.Process.GetCurrentProcess())

{

long memStart;

long getMemAfterGc()

{

GC.Collect(2, GCCollectionMode.Forced, true, true);

process.Refresh();

return process.PrivateMemorySize64;

}

long getOutstandingMem() => getMemAfterGc() - memStart;

var ones = np.ones(10_000_000); // python runtime warmup

ones.Dispose();

memStart = getMemAfterGc();

ones = np.ones(10_000_000);

Assert.IsTrue(getOutstandingMem() > 70_000_000);

ones.Dispose();

Assert.IsTrue(getOutstandingMem() < 1_000_000);

var array = np.array(arr);

Assert.IsTrue(getOutstandingMem() > 70_000_000);

array.Dispose();

Assert.IsTrue(getOutstandingMem() < 1_000_000);

array = np.array(arr, np.float32);

Assert.IsTrue(getOutstandingMem() > 30_000_000);

array.Dispose();

Assert.IsTrue(getOutstandingMem() < 1_000_000);

}

}

[TestMethod]

public void arrayTest()

{

// >>> np.array([1, 2, 3])

// array([1, 2, 3])

//

NDarray given = np.array(new int[] { 1, 2, 3 });

var expected =

"array([1, 2, 3])";

Assert.AreEqual(expected, given.repr);

// Upcasting:

// >>> np.array([1, 2, 3.0])

// array([ 1., 2., 3.])

//

given = np.array(new double[] { 1, 2, 3.0 });

expected =

"array([1., 2., 3.])";

Assert.AreEqual(expected, given.repr);

// More than one dimension:

// >>> np.array([[1, 2], [3, 4]])

// array([[1, 2],

// [3, 4]])

//

given = np.array(new int[,] { { 1, 2 }, { 3, 4 } });

expected =

"array([[1, 2],\n" +

" [3, 4]])";

Assert.AreEqual(expected, given.repr);

// Minimum dimensions 2:

// >>> np.array([1, 2, 3], ndmin=2)

// array([[1, 2, 3]])

//

given = np.array(new int[] { 1, 2, 3 }, ndmin: 2);

expected =

"array([[1, 2, 3]])";

Assert.AreEqual(expected, given.repr);

// Type provided:

// >>> np.array([1, 2, 3], dtype=complex)

// array([ 1.+0.j, 2.+0.j, 3.+0.j])

//

given = np.array(new int[] { 1, 2, 3 }, dtype: np.complex_);

expected =

"array([1.+0.j, 2.+0.j, 3.+0.j])";

Assert.AreEqual(expected, given.repr);

// Data-type consisting of more than one element:

// >>> x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')])

// >>> x['a']

// array([1, 3])

//

#if TODO

given= x = np.array({(1,2),(3,4)},dtype={('a','<i4'),('b','<i4')});

given= x['a'];

expected=

"array([1, 3])";

Assert.AreEqual(expected, given.repr);

#endif

// Creating an array from sub-classes:

// >>> np.array(np.mat('1 2; 3 4'))

// array([[1, 2],

// [3, 4]])

//

#if TODO

given= np.array(np.mat('1 2; 3 4'));

expected=

"array([[1, 2],\n" +

" [3, 4]])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> np.array(np.mat('1 2; 3 4'), subok=True)

// matrix([[1, 2],

// [3, 4]])

//

#if TODO

given= np.array(np.mat('1 2; 3 4'), subok=True);

expected=

"matrix([[1, 2],\n" +

" [3, 4]])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void array1Test()

{

//>>> a=[]

//>>> a.append(np.arange(5))

//>>> a.append(np.arange(5))

//>>> a.append(np.arange(5))

//>>> a.append(np.arange(5))

//>>> a

// [array([0, 1, 2, 3, 4]), array([0, 1, 2, 3, 4]), array([0, 1, 2, 3, 4]), array([0, 1, 2, 3, 4])]

//>>> b=np.array(a)

//>>> b

//array([[0, 1, 2, 3, 4],

//[0, 1, 2, 3, 4]])

//>>>

var a = new List<NDarray>();

a.Add(np.arange(5));

a.Add(np.arange(5));

var b = np.array(a);

Assert.AreEqual("array([[0, 1, 2, 3, 4],\n [0, 1, 2, 3, 4]])", b.repr);

}

[TestMethod]

public void array2Test()

{

//>>> a=np.array([1, 2, 3])

//>>> b=np.array([a, a, a])

//>>> b

//array([[1, 2, 3],

// [1, 2, 3],

// [1, 2, 3]])

var a = np.array(new[] { 1, 2, 3 });

var b = np.array(new[] { a, a, a });

Assert.AreEqual("array([[1, 2, 3],\n [1, 2, 3],\n [1, 2, 3]])", b.repr);

}

[TestMethod]

public void asarrayTest()

{

// Convert a list into an array:

// >>> a = [1, 2]

// >>> np.asarray(a)

// array([1, 2])

//

#if TODO

var given= a = [1, 2];

given= np.asarray(a);

var expected=

"array([1, 2])";

Assert.AreEqual(expected, given.repr);

#endif

// Existing arrays are not copied:

// >>> a = np.array([1, 2])

// >>> np.asarray(a) is a

// True

//

#if TODO

given= a = np.array({1, 2});

given= np.asarray(a) is a;

expected=

"True";

Assert.AreEqual(expected, given.repr);

#endif

// If dtype is set, array is copied only if dtype does not match:

// >>> a = np.array([1, 2], dtype=np.float32)

// >>> np.asarray(a, dtype=np.float32) is a

// True

// >>> np.asarray(a, dtype=np.float64) is a

// False

//

#if TODO

given= a = np.array({1, 2}, dtype=np.float32);

given= np.asarray(a, dtype=np.float32) is a;

expected=

"True";

Assert.AreEqual(expected, given.repr);

given= np.asarray(a, dtype=np.float64) is a;

expected=

"False";

Assert.AreEqual(expected, given.repr);

#endif

// Contrary to asanyarray, ndarray subclasses are not passed through:

// >>> issubclass(np.recarray, np.ndarray)

// True

// >>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)

// >>> np.asarray(a) is a

// False

// >>> np.asanyarray(a) is a

// True

//

#if TODO

given= issubclass(np.recarray, np.ndarray);

expected=

"True";

Assert.AreEqual(expected, given.repr);

given= a = np.array({(1.0, 2), (3.0, 4)}, dtype='f4,i4').view(np.recarray);

given= np.asarray(a) is a;

expected=

"False";

Assert.AreEqual(expected, given.repr);

given= np.asanyarray(a) is a;

expected=

"True";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void asanyarrayTest()

{

// Convert a list into an array:

// >>> a = [1, 2]

// >>> np.asanyarray(a)

// array([1, 2])

//

#if TODO

var given= a = [1, 2];

given= np.asanyarray(a);

var expected=

"array([1, 2])";

Assert.AreEqual(expected, given.repr);

#endif

// Instances of ndarray subclasses are passed through as-is:

// >>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)

// >>> np.asanyarray(a) is a

// True

//

#if TODO

given= a = np.array({(1.0, 2), (3.0, 4)}, dtype='f4,i4').view(np.recarray);

given= np.asanyarray(a) is a;

expected=

"True";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void ascontiguousarrayTest()

{

// >>> x = np.arange(6).reshape(2,3)

// >>> np.ascontiguousarray(x, dtype=np.float32)

// array([[ 0., 1., 2.],

// [ 3., 4., 5.]], dtype=float32)

// >>> x.flags['C_CONTIGUOUS']

// True

//

#if TODO

var given= x = np.arange(6).reshape(2,3);

given= np.ascontiguousarray(x, dtype=np.float32);

var expected=

"array([[ 0., 1., 2.],\n" +

" [ 3., 4., 5.]], dtype=float32)";

Assert.AreEqual(expected, given.repr);

given= x.flags['C_CONTIGUOUS'];

expected=

"True";

Assert.AreEqual(expected, given.repr);

#endif

// Note: This function returns an array with at least one-dimension (1-d)

// so it will not preserve 0-d arrays.

}

[TestMethod]

public void asmatrixTest()

{

// >>> x = np.array([[1, 2], [3, 4]])

//

#if TODO

var given= x = np.array({{1, 2}, {3, 4}});

#endif

// >>> m = np.asmatrix(x)

//

#if TODO

given= m = np.asmatrix(x);

#endif

// >>> x[0,0] = 5

//

#if TODO

given= x[0,0] = 5;

#endif

// >>> m

// matrix([[5, 2],

// [3, 4]])

//

#if TODO

given= m;

var expected=

"matrix([[5, 2],\n" +

" [3, 4]])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void copyTest()

{

// Create an array x, with a reference y and a copy z:

var x = np.array(new[] { 1, 2, 3 });

var y = x;

var z = np.copy(x);

// Note that, when we modify x, y changes, but not z:

x[0] = (NDarray)10;

Assert.AreEqual(x[0], y[0]);

Assert.AreNotEqual(x[0], z[0]);

}

[TestMethod]

public void copyTest1()

{

// Create an array x, with a reference y and a copy z:

var x = np.array(new[] { 1, 2, 3 });

var y = x;

var z = x.copy();

// Note that, when we modify x, y changes, but not z:

x[0] = (NDarray)10;

Assert.AreEqual(x[0], y[0]);

Assert.AreNotEqual(x[0], z[0]);

}

[TestMethod]

public void frombufferTest()

{

// >>> s = 'hello world'

// >>> np.frombuffer(s, dtype='S1', count=5, offset=6)

// array(['w', 'o', 'r', 'l', 'd'],

// dtype='|S1')

//

#if TODO

var given= s = 'hello world';

given= np.frombuffer(s, dtype='S1', count=5, offset=6);

var expected=

"array(['w', 'o', 'r', 'l', 'd'],\n" +

" dtype='|S1')";

Assert.AreEqual(expected, given.repr);

#endif

// >>> np.frombuffer(b'\x01\x02', dtype=np.uint8)

// array([1, 2], dtype=uint8)

// >>> np.frombuffer(b'\x01\x02\x03\x04\x05', dtype=np.uint8, count=3)

// array([1, 2, 3], dtype=uint8)

//

#if TODO

given= np.frombuffer(b'\x01\x02', dtype=np.uint8);

expected=

"array([1, 2], dtype=uint8)";

Assert.AreEqual(expected, given.repr);

given= np.frombuffer(b'\x01\x02\x03\x04\x05', dtype=np.uint8, count=3);

expected=

"array([1, 2, 3], dtype=uint8)";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void fromfileTest()

{

// Construct an ndarray:

// >>> dt = np.dtype([('time', [('min', int), ('sec', int)]),

// ... ('temp', float)])

// >>> x = np.zeros((1,), dtype=dt)

// >>> x['time']['min'] = 10; x['temp'] = 98.25

// >>> x

// array([((10, 0), 98.25)],

// dtype=[('time', [('min', '<i4'), ('sec', '<i4')]), ('temp', '<f8')])

//

#if TODO

var given= dt = np.dtype({('time', {('min', int), ('sec', int)}),;

var expected=

"... ('temp', float)])";

Assert.AreEqual(expected, given.repr);

given= x = np.zeros((1,), dtype=dt);

given= x['time']['min'] = 10; x['temp'] = 98.25;

given= x;

expected=

"array([((10, 0), 98.25)],\n" +

" dtype=[('time', [('min', '<i4'), ('sec', '<i4')]), ('temp', '<f8')])";

Assert.AreEqual(expected, given.repr);

#endif

// Save the raw data to disk:

// >>> import os

// >>> fname = os.tmpnam()

// >>> x.tofile(fname)

//

#if TODO

given= import os;

given= fname = os.tmpnam();

given= x.tofile(fname);

#endif

// Read the raw data from disk:

// >>> np.fromfile(fname, dtype=dt)

// array([((10, 0), 98.25)],

// dtype=[('time', [('min', '<i4'), ('sec', '<i4')]), ('temp', '<f8')])

//

#if TODO

given= np.fromfile(fname, dtype=dt);

expected=

"array([((10, 0), 98.25)],\n" +

" dtype=[('time', [('min', '<i4'), ('sec', '<i4')]), ('temp', '<f8')])";

Assert.AreEqual(expected, given.repr);

#endif

// The recommended way to store and load data:

// >>> np.save(fname, x)

// >>> np.load(fname + '.npy')

// array([((10, 0), 98.25)],

// dtype=[('time', [('min', '<i4'), ('sec', '<i4')]), ('temp', '<f8')])

//

#if TODO

given= np.save(fname, x);

given= np.load(fname + '.npy');

expected=

"array([((10, 0), 98.25)],\n" +

" dtype=[('time', [('min', '<i4'), ('sec', '<i4')]), ('temp', '<f8')])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void fromfunctionTest()

{

// >>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)

// array([[ True, False, False],

// [False, True, False],

// [False, False, True]])

//

#if TODO

var given= np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int);

var expected=

"array([[ True, False, False],\n" +

" [False, True, False],\n" +

" [False, False, True]])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)

// array([[0, 1, 2],

// [1, 2, 3],

// [2, 3, 4]])

//

#if TODO

given= np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int);

expected=

"array([[0, 1, 2],\n" +

" [1, 2, 3],\n" +

" [2, 3, 4]])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void fromiterTest()

{

// >>> iterable = (x*x for x in range(5))

// >>> np.fromiter(iterable, float)

// array([ 0., 1., 4., 9., 16.])

//

#if TODO

var given= iterable = (x*x for x in range(5));

given= np.fromiter(iterable, float);

var expected=

"array([ 0., 1., 4., 9., 16.])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void fromstringTest()

{

// >>> np.fromstring('1 2', dtype=int, sep=' ')

// array([1, 2])

// >>> np.fromstring('1, 2', dtype=int, sep=',')

// array([1, 2])

//

#if TODO

var given= np.fromstring('1 2', dtype=int, sep=' ');

var expected=

"array([1, 2])";

Assert.AreEqual(expected, given.repr);

given= np.fromstring('1, 2', dtype=int, sep=',');

expected=

"array([1, 2])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void loadtxtTest()

{

// >>> from io import StringIO # StringIO behaves like a file object

// >>> c = StringIO(u"0 1\n2 3")

// >>> np.loadtxt(c)

// array([[ 0., 1.],

// [ 2., 3.]])

//

string tempFile = Path.GetTempFileName();

File.WriteAllText(tempFile, "0 1\n2 3");

var given = np.loadtxt(tempFile);

var expected =

"array([[0., 1.],\n" +

" [2., 3.]])";

Assert.AreEqual(expected, given.repr);

// >>> c = StringIO(u"1,0,2\n3,0,4")

// >>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True)

// >>> x

// array([ 1., 3.])

// >>> y

// array([ 2., 4.])

//

File.WriteAllText(tempFile, "1,0,2\n3,0,4");

var a = np.loadtxt(tempFile, delimiter: ",", usecols: new[] { 0, 2 }, unpack: true);

given = a[0];

expected =

"array([1., 3.])";

Assert.AreEqual(expected, given.repr);

given = a[1];

expected =

"array([2., 4.])";

Assert.AreEqual(expected, given.repr);

}

[TestMethod]

public void loadtxt_custom_dtype()

{

// >>> d = StringIO(u"M 21 72\nF 35 58")

// >>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'),

// ... 'formats': ('S1', 'i4', 'f4')})

// array([('M', 21, 72.0), ('F', 35, 58.0)],

// dtype=[('gender', '|S1'), ('age', '<i4'), ('weight', '<f4')])

//