{

[TestMethod]

public void r_Test()

{

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

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

// >>> np.r_[-1:1:6j, [0]*3, 5, 6]

// array([-1. , -0.6, -0.2, 0.2, 0.6, 1. , 0. , 0. , 0. , 5. , 6. ])

//

#if TODO

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

var expected=

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

Assert.AreEqual(expected, given.repr);

given= np.r_{-1:1:6j, {0}*3, 5, 6};

expected=

"array([-1. , -0.6, -0.2, 0.2, 0.6, 1. , 0. , 0. , 0. , 5. , 6. ])";

Assert.AreEqual(expected, given.repr);

#endif

// String integers specify the axis to concatenate along or the minimum

// number of dimensions to force entries into.

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

// >>> np.r_['-1', a, a] # concatenate along last axis

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

// [3, 4, 5, 3, 4, 5]])

// >>> np.r_['0,2', [1,2,3], [4,5,6]] # concatenate along first axis, dim>=2

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

// [4, 5, 6]])

//

#if TODO

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

given= np.r_{'-1', a, a} # concatenate along last axis;

expected=

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

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

Assert.AreEqual(expected, given.repr);

given= np.r_{'0,2', {1,2,3}, {4,5,6}} # concatenate along first axis, dim>=2;

expected=

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

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

Assert.AreEqual(expected, given.repr);

#endif

// >>> np.r_['0,2,0', [1,2,3], [4,5,6]]

// array([[1],

// [2],

// [3],

// [4],

// [5],

// [6]])

// >>> np.r_['1,2,0', [1,2,3], [4,5,6]]

// array([[1, 4],

// [2, 5],

// [3, 6]])

//

#if TODO

given= np.r_{'0,2,0', {1,2,3}, {4,5,6}};

expected=

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

" [2],\n" +

" [3],\n" +

" [4],\n" +

" [5],\n" +

" [6]])";

Assert.AreEqual(expected, given.repr);

given= np.r_{'1,2,0', {1,2,3}, {4,5,6}};

expected=

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

" [2, 5],\n" +

" [3, 6]])";

Assert.AreEqual(expected, given.repr);

#endif

// Using ‘r’ or ‘c’ as a first string argument creates a matrix.

// >>> np.r_['r',[1,2,3], [4,5,6]]

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

//

#if TODO

given= np.r_{'r',{1,2,3}, {4,5,6}};

expected=

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

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void s_Test()

{

// >>> np.s_[2::2]

// slice(2, None, 2)

// >>> np.index_exp[2::2]

// (slice(2, None, 2),)

//

#if TODO

var given= np.s_{2::2};

var expected=

"slice(2, None, 2)";

Assert.AreEqual(expected, given.repr);

given= np.index_exp{2::2};

expected=

"(slice(2, None, 2),)";

Assert.AreEqual(expected, given.repr);

#endif

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

// array([2, 4])

//

#if TODO

given= np.array({0, 1, 2, 3, 4}){np.s_{2::2}};

expected=

"array([2, 4])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void nonzeroTest()

{

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

// >>> x

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

// [0, 4, 0],

// [5, 6, 0]])

// >>> np.nonzero(x)

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

//

#if TODO

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

given= x;

var expected=

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

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

" [5, 6, 0]])";

Assert.AreEqual(expected, given.repr);

given= np.nonzero(x);

expected=

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

Assert.AreEqual(expected, given.repr);

#endif

// >>> x[np.nonzero(x)]

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

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

// array([[0, 0],

// [1, 1],

// [2, 0],

// [2, 1])

//

#if TODO

given= x{np.nonzero(x)};

expected=

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

Assert.AreEqual(expected, given.repr);

given= np.transpose(np.nonzero(x));

expected=

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

" [1, 1],\n" +

" [2, 0],\n" +

" [2, 1])";

Assert.AreEqual(expected, given.repr);

#endif

// A common use for nonzero is to find the indices of an array, where

// a condition is True. Given an array a, the condition a > 3 is a

// boolean array and since False is interpreted as 0, np.nonzero(a > 3)

// yields the indices of the a where the condition is true.

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

// >>> a > 3

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

// [ True, True, True],

// [ True, True, True]])

// >>> np.nonzero(a > 3)

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

//

#if TODO

given= a = np.array({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}});

given= a > 3;

expected=

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

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

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

Assert.AreEqual(expected, given.repr);

given= np.nonzero(a > 3);

expected=

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

Assert.AreEqual(expected, given.repr);

#endif

// Using this result to index a is equivalent to using the mask directly:

// >>> a[np.nonzero(a > 3)]

// array([4, 5, 6, 7, 8, 9])

// >>> a[a > 3] # prefer this spelling

// array([4, 5, 6, 7, 8, 9])

//

#if TODO

given= a{np.nonzero(a > 3)};

expected=

"array([4, 5, 6, 7, 8, 9])";

Assert.AreEqual(expected, given.repr);

given= a[a > 3] # prefer this spelling;

expected=

"array([4, 5, 6, 7, 8, 9])";

Assert.AreEqual(expected, given.repr);

#endif

// nonzero can also be called as a method of the array.

// >>> (a > 3).nonzero()

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

//

#if TODO

given= (a > 3).nonzero();

expected=

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

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void whereTest()

{

// >>> a = np.arange(10)

// >>> a

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

// >>> np.where(a < 5, a, 10*a)

// array([ 0, 1, 2, 3, 4, 50, 60, 70, 80, 90])

//

#if TODO

var given= a = np.arange(10);

given= a;

var expected=

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

Assert.AreEqual(expected, given.repr);

given= np.where(a < 5, a, 10*a);

expected=

"array([ 0, 1, 2, 3, 4, 50, 60, 70, 80, 90])";

Assert.AreEqual(expected, given.repr);

#endif

// This can be used on multidimensional arrays too:

// >>> np.where([[True, False], [True, True]],

// ... [[1, 2], [3, 4]],

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

// array([[1, 8],

// [3, 4]])

//

#if TODO

given= np.where({{True, False}, {True, True}},;

expected=

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

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

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

" [3, 4]])";

Assert.AreEqual(expected, given.repr);

#endif

// The shapes of x, y, and the condition are broadcast together:

// >>> x, y = np.ogrid[:3, :4]

// >>> np.where(x < y, x, 10 + y) # both x and 10+y are broadcast

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

// [10, 11, 1, 1],

// [10, 11, 12, 2]])

//

#if TODO

given= x, y = np.ogrid{:3, :4};

given= np.where(x < y, x, 10 + y) # both x and 10+y are broadcast;

expected=

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

" [10, 11, 1, 1],\n" +

" [10, 11, 12, 2]])";

Assert.AreEqual(expected, given.repr);

#endif

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

// ... [0, 2, 4],

// ... [0, 3, 6]])

// >>> np.where(a < 4, a, -1) # -1 is broadcast

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

// [ 0, 2, -1],

// [ 0, 3, -1]])

//

#if TODO

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

expected=

"... [0, 2, 4],\n" +

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

Assert.AreEqual(expected, given.repr);

given= np.where(a < 4, a, -1) # -1 is broadcast;

expected=

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

" [ 0, 2, -1],\n" +

" [ 0, 3, -1]])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void indicesTest()

{

// >>> grid = np.indices((2, 3))

// >>> grid.shape

// (2, 2, 3)

// >>> grid[0] # row indices

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

// [1, 1, 1]])

// >>> grid[1] # column indices

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

// [0, 1, 2]])

//

#if TODO

var given= grid = np.indices((2, 3));

given= grid.shape;

var expected=

"(2, 2, 3)";

Assert.AreEqual(expected, given.repr);

given= grid[0] # row indices;

expected=

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

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

Assert.AreEqual(expected, given.repr);

given= grid[1] # column indices;

expected=

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

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

Assert.AreEqual(expected, given.repr);

#endif

// The indices can be used as an index into an array.

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

// >>> row, col = np.indices((2, 3))

// >>> x[row, col]

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

// [4, 5, 6]])

//

#if TODO

given= x = np.arange(20).reshape(5, 4);

given= row, col = np.indices((2, 3));

given= x[row, col];

expected=

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

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

Assert.AreEqual(expected, given.repr);

#endif

// Note that it would be more straightforward in the above example to

// extract the required elements directly with x[:2, :3].

}

[TestMethod]

public void ix_Test()

{

// >>> a = np.arange(10).reshape(2, 5)

// >>> a

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

// [5, 6, 7, 8, 9]])

// >>> ixgrid = np.ix_([0, 1], [2, 4])

// >>> ixgrid

// (array([[0],

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

// >>> ixgrid[0].shape, ixgrid[1].shape

// ((2, 1), (1, 2))

// >>> a[ixgrid]

// array([[2, 4],

// [7, 9]])

//

#if TODO

var given= a = np.arange(10).reshape(2, 5);

given= a;

var expected=

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

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

Assert.AreEqual(expected, given.repr);

given= ixgrid = np.ix_({0, 1}, {2, 4});

given= ixgrid;

expected=

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

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

Assert.AreEqual(expected, given.repr);

given= ixgrid[0].shape, ixgrid[1].shape;

expected=

"((2, 1), (1, 2))";

Assert.AreEqual(expected, given.repr);

given= a[ixgrid];

expected=

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

" [7, 9]])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> ixgrid = np.ix_([True, True], [2, 4])

// >>> a[ixgrid]

// array([[2, 4],

// [7, 9]])

// >>> ixgrid = np.ix_([True, True], [False, False, True, False, True])

// >>> a[ixgrid]

// array([[2, 4],

// [7, 9]])

//

#if TODO

given= ixgrid = np.ix_({True, True}, {2, 4});

given= a[ixgrid];

expected=

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

" [7, 9]])";

Assert.AreEqual(expected, given.repr);

given= ixgrid = np.ix_({True, True}, {False, False, True, False, True});

given= a[ixgrid];

expected=

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

" [7, 9]])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void ravel_multi_indexTest()

{

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

// >>> np.ravel_multi_index(arr, (7,6))

// array([22, 41, 37])

// >>> np.ravel_multi_index(arr, (7,6), order='F')

// array([31, 41, 13])

// >>> np.ravel_multi_index(arr, (4,6), mode='clip')

// array([22, 23, 19])

// >>> np.ravel_multi_index(arr, (4,4), mode=('clip','wrap'))

// array([12, 13, 13])

//

#if TODO

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

given= np.ravel_multi_index(arr, (7,6));

var expected=

"array([22, 41, 37])";

Assert.AreEqual(expected, given.repr);

given= np.ravel_multi_index(arr, (7,6), order='F');

expected=

"array([31, 41, 13])";

Assert.AreEqual(expected, given.repr);

given= np.ravel_multi_index(arr, (4,6), mode='clip');

expected=

"array([22, 23, 19])";

Assert.AreEqual(expected, given.repr);

given= np.ravel_multi_index(arr, (4,4), mode=('clip','wrap'));

expected=

"array([12, 13, 13])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> np.ravel_multi_index((3,1,4,1), (6,7,8,9))

// 1621

//

#if TODO

given= np.ravel_multi_index((3,1,4,1), (6,7,8,9));

expected=

"1621";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void unravel_indexTest()

{

// >>> np.unravel_index([22, 41, 37], (7,6))

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

// >>> np.unravel_index([31, 41, 13], (7,6), order='F')

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

//

#if TODO

var given= np.unravel_index({22, 41, 37}, (7,6));

var expected=

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

Assert.AreEqual(expected, given.repr);

given= np.unravel_index({31, 41, 13}, (7,6), order='F');

expected=

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

Assert.AreEqual(expected, given.repr);

#endif

// >>> np.unravel_index(1621, (6,7,8,9))

// (3, 1, 4, 1)

//

#if TODO

given= np.unravel_index(1621, (6,7,8,9));

expected=

"(3, 1, 4, 1)";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void diag_indicesTest()

{

// Create a set of indices to access the diagonal of a (4, 4) array:

// >>> di = np.diag_indices(4)

// >>> di

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

// >>> a = np.arange(16).reshape(4, 4)

// >>> a

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

// [ 4, 5, 6, 7],

// [ 8, 9, 10, 11],

// [12, 13, 14, 15]])

// >>> a[di] = 100

// >>> a

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

// [ 4, 100, 6, 7],

// [ 8, 9, 100, 11],

// [ 12, 13, 14, 100]])

//

#if TODO

var given= di = np.diag_indices(4);

given= di;

var expected=

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

Assert.AreEqual(expected, given.repr);

given= a = np.arange(16).reshape(4, 4);

given= a;

expected=

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

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

" [ 8, 9, 10, 11],\n" +

" [12, 13, 14, 15]])";

Assert.AreEqual(expected, given.repr);

given= a[di] = 100;

given= a;

expected=

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

" [ 4, 100, 6, 7],\n" +

" [ 8, 9, 100, 11],\n" +

" [ 12, 13, 14, 100]])";

Assert.AreEqual(expected, given.repr);

#endif

// Now, we create indices to manipulate a 3-D array:

// >>> d3 = np.diag_indices(2, 3)

// >>> d3

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

//

#if TODO

given= d3 = np.diag_indices(2, 3);

given= d3;

expected=

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

Assert.AreEqual(expected, given.repr);

#endif

// And use it to set the diagonal of an array of zeros to 1:

// >>> a = np.zeros((2, 2, 2), dtype=int)

// >>> a[d3] = 1

// >>> a

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

// [0, 0]],

// [[0, 0],

// [0, 1]]])

//

#if TODO

given= a = np.zeros((2, 2, 2), dtype=int);

given= a[d3] = 1;

given= a;

expected=

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

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

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

" [0, 1]]])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void mask_indicesTest()

{

// These are the indices that would allow you to access the upper triangular

// part of any 3x3 array:

// >>> iu = np.mask_indices(3, np.triu)

//

#if TODO

var given= iu = np.mask_indices(3, np.triu);

#endif

// For example, if a is a 3x3 array:

// >>> a = np.arange(9).reshape(3, 3)

// >>> a

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

// [3, 4, 5],

// [6, 7, 8]])

// >>> a[iu]

// array([0, 1, 2, 4, 5, 8])

//

#if TODO

given= a = np.arange(9).reshape(3, 3);

given= a;

var expected=

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

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

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

Assert.AreEqual(expected, given.repr);

given= a[iu];

expected=

"array([0, 1, 2, 4, 5, 8])";

Assert.AreEqual(expected, given.repr);

#endif

// An offset can be passed also to the masking function. This gets us the

// indices starting on the first diagonal right of the main one:

// >>> iu1 = np.mask_indices(3, np.triu, 1)

//

#if TODO

given= iu1 = np.mask_indices(3, np.triu, 1);

#endif

// with which we now extract only three elements:

// >>> a[iu1]

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

//

#if TODO

given= a[iu1];

expected=

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

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void tril_indicesTest()

{

// Compute two different sets of indices to access 4x4 arrays, one for the

// lower triangular part starting at the main diagonal, and one starting two

// diagonals further right:

// >>> il1 = np.tril_indices(4)

// >>> il2 = np.tril_indices(4, 2)

//

#if TODO

var given= il1 = np.tril_indices(4);

given= il2 = np.tril_indices(4, 2);

#endif

// Here is how they can be used with a sample array:

// >>> a = np.arange(16).reshape(4, 4)

// >>> a

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

// [ 4, 5, 6, 7],

// [ 8, 9, 10, 11],

// [12, 13, 14, 15]])

//

#if TODO

given= a = np.arange(16).reshape(4, 4);

given= a;

var expected=

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

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

" [ 8, 9, 10, 11],\n" +

" [12, 13, 14, 15]])";

Assert.AreEqual(expected, given.repr);

#endif

// Both for indexing:

// >>> a[il1]

// array([ 0, 4, 5, 8, 9, 10, 12, 13, 14, 15])

//

#if TODO

given= a[il1];

expected=

"array([ 0, 4, 5, 8, 9, 10, 12, 13, 14, 15])";

Assert.AreEqual(expected, given.repr);

#endif

// And for assigning values:

// >>> a[il1] = -1

// >>> a

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

// [-1, -1, 6, 7],

// [-1, -1, -1, 11],

// [-1, -1, -1, -1]])

//

#if TODO

given= a[il1] = -1;

given= a;

expected=

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

" [-1, -1, 6, 7],\n" +

" [-1, -1, -1, 11],\n" +

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

Assert.AreEqual(expected, given.repr);

#endif

// These cover almost the whole array (two diagonals right of the main one):

// >>> a[il2] = -10

// >>> a

// array([[-10, -10, -10, 3],

// [-10, -10, -10, -10],

// [-10, -10, -10, -10],

// [-10, -10, -10, -10]])

//

#if TODO

given= a[il2] = -10;

given= a;

expected=

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

" [-10, -10, -10, -10],\n" +

" [-10, -10, -10, -10],\n" +

" [-10, -10, -10, -10]])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void triu_indicesTest()

{

// Compute two different sets of indices to access 4x4 arrays, one for the

// upper triangular part starting at the main diagonal, and one starting two

// diagonals further right:

// >>> iu1 = np.triu_indices(4)

// >>> iu2 = np.triu_indices(4, 2)

//

#if TODO

var given= iu1 = np.triu_indices(4);

given= iu2 = np.triu_indices(4, 2);

#endif

// Here is how they can be used with a sample array:

// >>> a = np.arange(16).reshape(4, 4)

// >>> a

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

// [ 4, 5, 6, 7],

// [ 8, 9, 10, 11],

// [12, 13, 14, 15]])

//

#if TODO

given= a = np.arange(16).reshape(4, 4);

given= a;

var expected=

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

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

" [ 8, 9, 10, 11],\n" +

" [12, 13, 14, 15]])";

Assert.AreEqual(expected, given.repr);

#endif

// Both for indexing:

// >>> a[iu1]

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

//

#if TODO

given= a[iu1];

expected=

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

Assert.AreEqual(expected, given.repr);

#endif

// And for assigning values:

// >>> a[iu1] = -1

// >>> a

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

// [ 4, -1, -1, -1],

// [ 8, 9, -1, -1],

// [12, 13, 14, -1]])

//

#if TODO

given= a[iu1] = -1;

given= a;

expected=

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

" [ 4, -1, -1, -1],\n" +

" [ 8, 9, -1, -1],\n" +

" [12, 13, 14, -1]])";

Assert.AreEqual(expected, given.repr);

#endif

// These cover only a small part of the whole array (two diagonals right

// of the main one):

// >>> a[iu2] = -10

// >>> a

// array([[ -1, -1, -10, -10],

// [ 4, -1, -1, -10],

// [ 8, 9, -1, -1],

// [ 12, 13, 14, -1]])

//

#if TODO

given= a[iu2] = -10;

given= a;

expected=

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

" [ 4, -1, -1, -10],\n" +

" [ 8, 9, -1, -1],\n" +

" [ 12, 13, 14, -1]])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void takeTest()

{

// >>> a = [4, 3, 5, 7, 6, 8]

// >>> indices = [0, 1, 4]

// >>> np.take(a, indices)

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

//

#if TODO

var given= a = [4, 3, 5, 7, 6, 8];

given= indices = [0, 1, 4];

given= np.take(a, indices);

var expected=

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

Assert.AreEqual(expected, given.repr);

#endif

// In this example if a is an ndarray, “fancy” indexing can be used.

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

// >>> a[indices]

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

//

#if TODO

given= a = np.array(a);

given= a[indices];

expected=

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

Assert.AreEqual(expected, given.repr);

#endif

// If indices is not one dimensional, the output also has these dimensions.

// >>> np.take(a, [[0, 1], [2, 3]])

// array([[4, 3],

// [5, 7]])

//

#if TODO

given= np.take(a, {{0, 1}, {2, 3}});

expected=

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

" [5, 7]])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void take_along_axisTest()

{

// For this sample array

// >>> a = np.array([[10, 30, 20], [60, 40, 50]])

//

#if TODO

var given= a = np.array({{10, 30, 20}, {60, 40, 50}});

#endif

// We can sort either by using sort directly, or argsort and this function

// >>> np.sort(a, axis=1)

// array([[10, 20, 30],

// [40, 50, 60]])

// >>> ai = np.argsort(a, axis=1); ai

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

// [1, 2, 0]], dtype=int64)

// >>> np.take_along_axis(a, ai, axis=1)

// array([[10, 20, 30],

// [40, 50, 60]])

//

#if TODO

given= np.sort(a, axis=1);

var expected=

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

" [40, 50, 60]])";

Assert.AreEqual(expected, given.repr);

given= ai = np.argsort(a, axis=1); ai;

expected=

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

" [1, 2, 0]], dtype=int64)";

Assert.AreEqual(expected, given.repr);

given= np.take_along_axis(a, ai, axis=1);

expected=

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

" [40, 50, 60]])";

Assert.AreEqual(expected, given.repr);

#endif

// The same works for max and min, if you expand the dimensions:

// >>> np.expand_dims(np.max(a, axis=1), axis=1)

// array([[30],

// [60]])

// >>> ai = np.expand_dims(np.argmax(a, axis=1), axis=1)

// >>> ai

// array([[1],

// [0], dtype=int64)

// >>> np.take_along_axis(a, ai, axis=1)

// array([[30],

// [60]])

//

#if TODO

given= np.expand_dims(np.max(a, axis=1), axis=1);

expected=

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

" [60]])";

Assert.AreEqual(expected, given.repr);

given= ai = np.expand_dims(np.argmax(a, axis=1), axis=1);

given= ai;

expected=

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

" [0], dtype=int64)";

Assert.AreEqual(expected, given.repr);

given= np.take_along_axis(a, ai, axis=1);

expected=

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

" [60]])";

Assert.AreEqual(expected, given.repr);

#endif

// If we want to get the max and min at the same time, we can stack the

// indices first

// >>> ai_min = np.expand_dims(np.argmin(a, axis=1), axis=1)

// >>> ai_max = np.expand_dims(np.argmax(a, axis=1), axis=1)

// >>> ai = np.concatenate([ai_min, ai_max], axis=axis)

// >> ai

// array([[0, 1],

// [1, 0]], dtype=int64)

// >>> np.take_along_axis(a, ai, axis=1)

// array([[10, 30],

// [40, 60]])

//

#if TODO

given= ai_min = np.expand_dims(np.argmin(a, axis=1), axis=1);

given= ai_max = np.expand_dims(np.argmax(a, axis=1), axis=1);

given= ai = np.concatenate({ai_min, ai_max}, axis=axis);

expected=

">> ai\n" +

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

" [1, 0]], dtype=int64)";