take_along_axis() doesn't return NDarray about numpy.net HOT 5 CLOSED

        [TestMethod]
        public void take_along_axisTest()
        {
            // For this sample array

            // >>> a = np.array([[10, 30, 20], [60, 40, 50]])
            var a=  np.array(new[,]{{10, 30, 20}, {60, 40, 50}});

            // 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]])
            // 
            
            var given=  np.sort(a, axis: 1);
            var expected=
                "array([[10, 20, 30],\n" +
                "       [40, 50, 60]])";
            Assert.AreEqual(expected, given.repr);
            var ai = np.argsort(a, axis: 1);
            given = 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);

            // 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]])
            // 

             given=  np.expand_dims(np.max(a, axis:new int[]{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);

            // 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]])
            // 

             var ai_min = np.expand_dims(np.argmin(a, axis:1), axis:1);
             var  ai_max = np.expand_dims(np.argmax(a, axis:1), axis:1);
             given=  ai = np.concatenate(new[]{ai_min, ai_max}, axis: 1);
             expected=
                "array([[0, 1],\n" +
                "       [1, 0]], dtype=int64)";
            Assert.AreEqual(expected, given.repr);
             given=  np.take_along_axis(a, ai, axis:1);
             expected=
                "array([[10, 30],\n" +
                "       [40, 60]])";
            Assert.AreEqual(expected, given.repr);
        }