{

[TestMethod]

public void reshapeTest()

{

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

// >>> np.reshape(a, 6)

// array([1, 2, 3, 4, 5, 6])

// >>> np.reshape(a, 6, order='F')

// array([1, 4, 2, 5, 3, 6])

//

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

var given = np.reshape(a, 6);

var expected =

"array([1, 2, 3, 4, 5, 6])";

Assert.AreEqual(expected, given.repr);

given = np.reshape(a, new Shape(6), order: "F");

expected =

"array([1, 4, 2, 5, 3, 6])";

Assert.AreEqual(expected, given.repr);

// >>> np.reshape(a, (3,-1)) # the unspecified value is inferred to be 2

// array([[1, 2],

// [3, 4],

// [5, 6]])

//

given = np.reshape(a, 3, -1); // the unspecified value is inferred to be 2;

expected =

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

" [3, 4],\n" +

" [5, 6]])";

Assert.AreEqual(expected, given.repr);

}

[TestMethod]

public void ravelTest()

{

// It is equivalent to reshape(-1, order=order).

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

// >>> print(np.ravel(x))

// [1 2 3 4 5 6]

//

#if TODO

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

given= print(np.ravel(x));

var expected=

"[1 2 3 4 5 6]";

Assert.AreEqual(expected, given.repr);

#endif

// >>> print(x.reshape(-1))

// [1 2 3 4 5 6]

//

#if TODO

given= print(x.reshape(-1));

expected=

"[1 2 3 4 5 6]";

Assert.AreEqual(expected, given.repr);

#endif

// >>> print(np.ravel(x, order='F'))

// [1 4 2 5 3 6]

//

#if TODO

given= print(np.ravel(x, order='F'));

expected=

"[1 4 2 5 3 6]";

Assert.AreEqual(expected, given.repr);

#endif

// When order is ‘A’, it will preserve the array’s ‘C’ or ‘F’ ordering:

// >>> print(np.ravel(x.T))

// [1 4 2 5 3 6]

// >>> print(np.ravel(x.T, order='A'))

// [1 2 3 4 5 6]

//

#if TODO

given= print(np.ravel(x.T));

expected=

"[1 4 2 5 3 6]";

Assert.AreEqual(expected, given.repr);

given= print(np.ravel(x.T, order='A'));

expected=

"[1 2 3 4 5 6]";

Assert.AreEqual(expected, given.repr);

#endif

// When order is ‘K’, it will preserve orderings that are neither ‘C’

// nor ‘F’, but won’t reverse axes:

// >>> a = np.arange(3)[::-1]; a

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

// >>> a.ravel(order='C')

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

// >>> a.ravel(order='K')

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

//

#if TODO

given= a = np.arange(3){::-1}; a;

expected=

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

Assert.AreEqual(expected, given.repr);

given= a.ravel(order='C');

expected=

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

Assert.AreEqual(expected, given.repr);

given= a.ravel(order='K');

expected=

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

Assert.AreEqual(expected, given.repr);

#endif

// >>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a

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

// [ 1, 3, 5]],

// [[ 6, 8, 10],

// [ 7, 9, 11]]])

// >>> a.ravel(order='C')

// array([ 0, 2, 4, 1, 3, 5, 6, 8, 10, 7, 9, 11])

// >>> a.ravel(order='K')

// array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])

//

#if TODO

given= a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a;

expected=

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

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

" [[ 6, 8, 10],\n" +

" [ 7, 9, 11]]])";

Assert.AreEqual(expected, given.repr);

given= a.ravel(order='C');

expected=

"array([ 0, 2, 4, 1, 3, 5, 6, 8, 10, 7, 9, 11])";

Assert.AreEqual(expected, given.repr);

given= a.ravel(order='K');

expected=

"array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void flattenTest()

{

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

// >>> a.flatten()

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

// >>> a.flatten('F')

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

//

#if TODO

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

given= a.flatten();

var expected=

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

Assert.AreEqual(expected, given.repr);

given= a.flatten('F');

expected=

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

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void moveaxisTest()

{

// >>> x = np.zeros((3, 4, 5))

// >>> np.moveaxis(x, 0, -1).shape

// (4, 5, 3)

// >>> np.moveaxis(x, -1, 0).shape

// (5, 3, 4)

//

#if TODO

var given= x = np.zeros((3, 4, 5));

given= np.moveaxis(x, 0, -1).shape;

var expected=

"(4, 5, 3)";

Assert.AreEqual(expected, given.repr);

given= np.moveaxis(x, -1, 0).shape;

expected=

"(5, 3, 4)";

Assert.AreEqual(expected, given.repr);

#endif

// These all achieve the same result:

// >>> np.transpose(x).shape

// (5, 4, 3)

// >>> np.swapaxes(x, 0, -1).shape

// (5, 4, 3)

// >>> np.moveaxis(x, [0, 1], [-1, -2]).shape

// (5, 4, 3)

// >>> np.moveaxis(x, [0, 1, 2], [-1, -2, -3]).shape

// (5, 4, 3)

//

#if TODO

given= np.transpose(x).shape;

expected=

"(5, 4, 3)";

Assert.AreEqual(expected, given.repr);

given= np.swapaxes(x, 0, -1).shape;

expected=

"(5, 4, 3)";

Assert.AreEqual(expected, given.repr);

given= np.moveaxis(x, {0, 1}, {-1, -2}).shape;

expected=

"(5, 4, 3)";

Assert.AreEqual(expected, given.repr);

given= np.moveaxis(x, {0, 1, 2}, {-1, -2, -3}).shape;

expected=

"(5, 4, 3)";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void rollaxisTest()

{

// >>> a = np.ones((3,4,5,6))

// >>> np.rollaxis(a, 3, 1).shape

// (3, 6, 4, 5)

// >>> np.rollaxis(a, 2).shape

// (5, 3, 4, 6)

// >>> np.rollaxis(a, 1, 4).shape

// (3, 5, 6, 4)

//

#if TODO

var given= a = np.ones((3,4,5,6));

given= np.rollaxis(a, 3, 1).shape;

var expected=

"(3, 6, 4, 5)";

Assert.AreEqual(expected, given.repr);

given= np.rollaxis(a, 2).shape;

expected=

"(5, 3, 4, 6)";

Assert.AreEqual(expected, given.repr);

given= np.rollaxis(a, 1, 4).shape;

expected=

"(3, 5, 6, 4)";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void swapaxesTest()

{

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

// >>> np.swapaxes(x,0,1)

// array([[1],

// [2],

// [3]])

//

#if TODO

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

given= np.swapaxes(x,0,1);

var expected=

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

" [2],\n" +

" [3]])";

Assert.AreEqual(expected, given.repr);

#endif

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

// >>> x

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

// [2, 3]],

// [[4, 5],

// [6, 7]]])

//

#if TODO

given= x = np.array({{{0,1},{2,3}},{{4,5},{6,7}}});

given= x;

expected=

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

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

" [[4, 5],\n" +

" [6, 7]]])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> np.swapaxes(x,0,2)

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

// [2, 6]],

// [[1, 5],

// [3, 7]]])

//

#if TODO

given= np.swapaxes(x,0,2);

expected=

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

" [2, 6]],\n" +

" [[1, 5],\n" +

" [3, 7]]])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void transposeTest()

{

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

// >>> x

// array([[0, 1],

// [2, 3]])

//

#if TODO

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

given= x;

var expected=

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

" [2, 3]])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> np.transpose(x)

// array([[0, 2],

// [1, 3]])

//

#if TODO

given= np.transpose(x);

expected=

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

" [1, 3]])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> x = np.ones((1, 2, 3))

// >>> np.transpose(x, (1, 0, 2)).shape

// (2, 1, 3)

//

#if TODO

given= x = np.ones((1, 2, 3));

given= np.transpose(x, (1, 0, 2)).shape;

expected=

"(2, 1, 3)";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void atleast_1dTest()

{

// >>> np.atleast_1d(1.0)

// array([ 1.])

//

#if TODO

var given= np.atleast_1d(1.0);

var expected=

"array([ 1.])";

Assert.AreEqual(expected, given.repr);

#endif

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

// >>> np.atleast_1d(x)

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

// [ 3., 4., 5.],

// [ 6., 7., 8.]])

// >>> np.atleast_1d(x) is x

// True

//

#if TODO

given= x = np.arange(9.0).reshape(3,3);

given= np.atleast_1d(x);

expected=

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

" [ 3., 4., 5.],\n" +

" [ 6., 7., 8.]])";

Assert.AreEqual(expected, given.repr);

given= np.atleast_1d(x) is x;

expected=

"True";

Assert.AreEqual(expected, given.repr);

#endif

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

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

//

#if TODO

given= np.atleast_1d(1, {3, 4});

expected=

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

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void atleast_2dTest()

{

// >>> np.atleast_2d(3.0)

// array([[ 3.]])

//

#if TODO

var given= np.atleast_2d(3.0);

var expected=

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

Assert.AreEqual(expected, given.repr);

#endif

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

// >>> np.atleast_2d(x)

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

// >>> np.atleast_2d(x).base is x

// True

//

#if TODO

given= x = np.arange(3.0);

given= np.atleast_2d(x);

expected=

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

Assert.AreEqual(expected, given.repr);

given= np.atleast_2d(x).base is x;

expected=

"True";

Assert.AreEqual(expected, given.repr);

#endif

// >>> np.atleast_2d(1, [1, 2], [[1, 2]])

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

//

#if TODO

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

expected=

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

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void atleast_3dTest()

{

// >>> np.atleast_3d(3.0)

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

//

#if TODO

var given= np.atleast_3d(3.0);

var expected=

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

Assert.AreEqual(expected, given.repr);

#endif

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

// >>> np.atleast_3d(x).shape

// (1, 3, 1)

//

#if TODO

given= x = np.arange(3.0);

given= np.atleast_3d(x).shape;

expected=

"(1, 3, 1)";

Assert.AreEqual(expected, given.repr);

#endif

// >>> x = np.arange(12.0).reshape(4,3)

// >>> np.atleast_3d(x).shape

// (4, 3, 1)

// >>> np.atleast_3d(x).base is x.base # x is a reshape, so not base itself

// True

//

#if TODO

given= x = np.arange(12.0).reshape(4,3);

given= np.atleast_3d(x).shape;

expected=

"(4, 3, 1)";

Assert.AreEqual(expected, given.repr);

given= np.atleast_3d(x).base is x.base # x is a reshape, so not base itself;

expected=

"True";

Assert.AreEqual(expected, given.repr);

#endif

// >>> for arr in np.atleast_3d([1, 2], [[1, 2]], [[[1, 2]]]):

// ... print(arr, arr.shape)

// ...

// [[[1]

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

// [[[1]

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

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

//

#if TODO

given= for arr in np.atleast_3d({1, 2}, {{1, 2}}, {{{1, 2}}}):;

expected=

"... print(arr, arr.shape)\n" +

"...\n" +

"[[[1]\n" +

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

"[[[1]\n" +

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

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

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void broadcastTest()

{

// Manually adding two vectors, using broadcasting:

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

// >>> y = np.array([4, 5, 6])

// >>> b = np.broadcast(x, y)

//

#if TODO

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

given= y = np.array({4, 5, 6});

given= b = np.broadcast(x, y);

#endif

// >>> out = np.empty(b.shape)

// >>> out.flat = [u+v for (u,v) in b]

// >>> out

// array([[ 5., 6., 7.],

// [ 6., 7., 8.],

// [ 7., 8., 9.]])

//

#if TODO

given= out = np.empty(b.shape);

given= out.flat = [u+v for (u,v) in b];

given= out;

var expected=

"array([[ 5., 6., 7.],\n" +

" [ 6., 7., 8.],\n" +

" [ 7., 8., 9.]])";

Assert.AreEqual(expected, given.repr);

#endif

// Compare against built-in broadcasting:

// >>> x + y

// array([[5, 6, 7],

// [6, 7, 8],

// [7, 8, 9]])

//

#if TODO

given= x + y;

expected=

"array([[5, 6, 7],\n" +

" [6, 7, 8],\n" +

" [7, 8, 9]])";

Assert.AreEqual(expected, given.repr);

#endif

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

// >>> y = np.array([[4], [5], [6]])

// >>> b = np.broadcast(x, y)

// >>> b.nd

// 2

//

#if TODO

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

given= y = np.array({{4}, {5}, {6}});

given= b = np.broadcast(x, y);

given= b.nd;

expected=

"2";

Assert.AreEqual(expected, given.repr);

#endif

// Methods

}

[TestMethod]

public void broadcast_toTest()

{

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

// >>> np.broadcast_to(x, (3, 3))

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

// [1, 2, 3],

// [1, 2, 3]])

//

#if TODO

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

given= np.broadcast_to(x, (3, 3));

var expected=

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

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

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

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void broadcast_arraysTest()

{

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

// >>> y = np.array([[4],[5]])

// >>> np.broadcast_arrays(x, y)

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

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

// [5, 5, 5]])]

//

#if TODO

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

given= y = np.array({{4},{5}});

given= np.broadcast_arrays(x, y);

var expected=

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

" [1, 2, 3]]), array([[4, 4, 4],\n" +

" [5, 5, 5]])]";

Assert.AreEqual(expected, given.repr);

#endif

// Here is a useful idiom for getting contiguous copies instead of

// non-contiguous views.

// >>> [np.array(a) for a in np.broadcast_arrays(x, y)]

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

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

// [5, 5, 5]])]

//

#if TODO

given= {np.array(a) for a in np.broadcast_arrays(x, y)};

expected=

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

" [1, 2, 3]]), array([[4, 4, 4],\n" +

" [5, 5, 5]])]";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void expand_dimsTest()

{

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

// >>> x.shape

// (2,)

//

#if TODO

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

given= x.shape;

var expected=

"(2,)";

Assert.AreEqual(expected, given.repr);

#endif

// The following is equivalent to x[np.newaxis,:] or x[np.newaxis]:

// >>> y = np.expand_dims(x, axis=0)

// >>> y

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

// >>> y.shape

// (1, 2)

//

#if TODO

given= y = np.expand_dims(x, axis=0);

given= y;

expected=

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

Assert.AreEqual(expected, given.repr);

given= y.shape;

expected=

"(1, 2)";

Assert.AreEqual(expected, given.repr);

#endif

// >>> y = np.expand_dims(x, axis=1) # Equivalent to x[:,np.newaxis]

// >>> y

// array([[1],

// [2]])

// >>> y.shape

// (2, 1)

//

#if TODO

given= y = np.expand_dims(x, axis=1) # Equivalent to x{:,np.newaxis};

given= y;

expected=

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

" [2]])";

Assert.AreEqual(expected, given.repr);

given= y.shape;

expected=

"(2, 1)";

Assert.AreEqual(expected, given.repr);

#endif

// Note that some examples may use None instead of np.newaxis. These

// are the same objects:

// >>> np.newaxis is None

// True

//

#if TODO

given= np.newaxis is None;

expected=

"True";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void squeezeTest()

{

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

// >>> x.shape

// (1, 3, 1)

// >>> np.squeeze(x).shape

// (3,)

// >>> np.squeeze(x, axis=0).shape

// (3, 1)

// >>> np.squeeze(x, axis=1).shape

// Traceback (most recent call last):

// ...

// ValueError: cannot select an axis to squeeze out which has size not equal to one

// >>> np.squeeze(x, axis=2).shape

// (1, 3)

//

#if TODO

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

given= x.shape;

var expected=

"(1, 3, 1)";

Assert.AreEqual(expected, given.repr);

given= np.squeeze(x).shape;

expected=

"(3,)";

Assert.AreEqual(expected, given.repr);

given= np.squeeze(x, axis=0).shape;

expected=

"(3, 1)";

Assert.AreEqual(expected, given.repr);

given= np.squeeze(x, axis=1).shape;

expected=

"Traceback (most recent call last):\n" +

"...\n" +

"ValueError: cannot select an axis to squeeze out which has size not equal to one";

Assert.AreEqual(expected, given.repr);

given= np.squeeze(x, axis=2).shape;

expected=

"(1, 3)";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void asfarrayTest()

{

// >>> np.asfarray([2, 3])

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

// >>> np.asfarray([2, 3], dtype='float')

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

// >>> np.asfarray([2, 3], dtype='int8')

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

//

#if TODO

var given= np.asfarray({2, 3});

var expected=

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

Assert.AreEqual(expected, given.repr);

given= np.asfarray({2, 3}, dtype='float');

expected=

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

Assert.AreEqual(expected, given.repr);

given= np.asfarray({2, 3}, dtype='int8');

expected=

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

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void asfortranarrayTest()

{

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

// >>> y = np.asfortranarray(x)

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

// False

// >>> y.flags['F_CONTIGUOUS']

// True

//

#if TODO

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

given= y = np.asfortranarray(x);

given= x.flags['F_CONTIGUOUS'];

var expected=

"False";

Assert.AreEqual(expected, given.repr);

given= y.flags['F_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 asarray_chkfiniteTest()

{

// Convert a list into an array. If all elements are finite

// asarray_chkfinite is identical to asarray.

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

// >>> np.asarray_chkfinite(a, dtype=float)

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

//

#if TODO

var given= a = [1, 2];

given= np.asarray_chkfinite(a, dtype=float);

var expected=

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

Assert.AreEqual(expected, given.repr);

#endif

// Raises ValueError if array_like contains Nans or Infs.

// >>> a = [1, 2, np.inf]

// >>> try:

// ... np.asarray_chkfinite(a)

// ... except ValueError:

// ... print('ValueError')

// ...

// ValueError

//

#if TODO

given= a = {1, 2, np.inf};

given= try:;

expected=

"... np.asarray_chkfinite(a)\n" +

"... except ValueError:\n" +

"... print('ValueError')\n" +

"...\n" +

"ValueError";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void asscalarTest()

{

// >>> np.asscalar(np.array([24]))

// 24

//

#if TODO

var given= np.asscalar(np.array({24}));

var expected=

"24";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void requireTest()

{

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

// >>> x.flags

// C_CONTIGUOUS : True

// F_CONTIGUOUS : False

// OWNDATA : False

// WRITEABLE : True

// ALIGNED : True

// WRITEBACKIFCOPY : False

// UPDATEIFCOPY : False

//

#if TODO

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

given= x.flags;

var expected=

" C_CONTIGUOUS : True\n" +

" F_CONTIGUOUS : False\n" +

" OWNDATA : False\n" +

" WRITEABLE : True\n" +

" ALIGNED : True\n" +

" WRITEBACKIFCOPY : False\n" +

" UPDATEIFCOPY : False";

Assert.AreEqual(expected, given.repr);

#endif

// >>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F'])

// >>> y.flags

// C_CONTIGUOUS : False

// F_CONTIGUOUS : True

// OWNDATA : True

// WRITEABLE : True

// ALIGNED : True

// WRITEBACKIFCOPY : False

// UPDATEIFCOPY : False

//

#if TODO

given= y = np.require(x, dtype=np.float32, requirements={'A', 'O', 'W', 'F'});

given= y.flags;

expected=

" C_CONTIGUOUS : False\n" +

" F_CONTIGUOUS : True\n" +

" OWNDATA : True\n" +

" WRITEABLE : True\n" +

" ALIGNED : True\n" +

" WRITEBACKIFCOPY : False\n" +

" UPDATEIFCOPY : False";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void concatenateTest()

{

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

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

// >>> np.concatenate((a, b), axis=0)

// array([[1, 2],

// [3, 4],

// [5, 6]])

// >>> np.concatenate((a, b.T), axis=1)

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

// [3, 4, 6]])

// >>> np.concatenate((a, b), axis=None)

// array([1, 2, 3, 4, 5, 6])

//

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

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

var given = np.concatenate(new[] { a, b }, axis: 0);

var expected =

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

" [3, 4],\n" +

" [5, 6]])";

Assert.AreEqual(expected, given.repr);

given = np.concatenate((a, b.T), axis: 1);

expected =

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

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

Assert.AreEqual(expected, given.repr);

given = np.concatenate((a, b), axis: null);

expected =

"array([1, 2, 3, 4, 5, 6])";

Assert.AreEqual(expected, given.repr);

}

[Ignore("np.ma not wrapped yet")]

public void ConcatenateMaskedArrayTest()

{

// This function will not preserve masking of MaskedArray inputs.

// >>> a = np.ma.arange(3)

// >>> a[1] = np.ma.masked

// >>> b = np.arange(2, 5)

// >>> a

// masked_array(data=[0, --, 2],