Rename Sort to OrderBy (dotnet#2814)

* Rename sort to orderby and add orderbydescending method

* Add doc strings

* Update bench mark test

* Update tests

* Update DataFrameColumn to use orderby

* Update doc comment

* Additions to sortby

* Revert "Additions to sortby"

This reverts commit 3931d4e2a72ce44a539be7c27b2592395f3efd35.

* Revert "Update doc comment"

This reverts commit 192f7797fe2b77625486637badf77046162fedbf.

* Revert "Update DataFrameColumn to use orderby"

This reverts commit 8f94664c5fd18570cd2b601535e816ca5dd5e3c4.

Author: jwood803

src/Microsoft.Data.Analysis/DataFrame.cs

@@ -254,19 +254,22 @@ public DataFrame Description()
             return ret;
         }
 
-        public DataFrame Sort(string columnName, bool ascending = true)
+        /// <summary>
+        /// Orders the data frame by a specified column.
+        /// </summary>
+        /// <param name="columnName">The column name to order by</param>
+        public DataFrame OrderBy(string columnName)
         {
-            DataFrameColumn column = this[columnName];
-            DataFrameColumn sortIndices = column.GetAscendingSortIndices();
-            List<DataFrameColumn> newColumns = new List<DataFrameColumn>(Columns.Count);
-            for (int i = 0; i < Columns.Count; i++)
-            {
-                DataFrameColumn oldColumn = Columns[i];
-                DataFrameColumn newColumn = oldColumn.Clone(sortIndices, !ascending, oldColumn.NullCount);
-                Debug.Assert(newColumn.NullCount == oldColumn.NullCount);
-                newColumns.Add(newColumn);
-            }
-            return new DataFrame(newColumns);
+            return Sort(columnName, isAscending: true);
+        }
+
+        /// <summary>
+        /// Orders the data frame by a specified column in descending order.
+        /// </summary>
+        /// <param name="columnName">The column name to order by</param>
+        public DataFrame OrderByDescending(string columnName)
+        {
+            return Sort(columnName, isAscending: false);
         }
 
         /// <summary>
@@ -578,6 +581,21 @@ private void OnColumnsChanged()
             _schema = null;
         }
 
+        private DataFrame Sort(string columnName, bool isAscending)
+        {
+            DataFrameColumn column = this[columnName];
+            DataFrameColumn sortIndices = column.GetAscendingSortIndices();
+            List<DataFrameColumn> newColumns = new List<DataFrameColumn>(Columns.Count);
+            for (int i = 0; i < Columns.Count; i++)
+            {
+                DataFrameColumn oldColumn = Columns[i];
+                DataFrameColumn newColumn = oldColumn.Clone(sortIndices, !isAscending, oldColumn.NullCount);
+                Debug.Assert(newColumn.NullCount == oldColumn.NullCount);
+                newColumns.Add(newColumn);
+            }
+            return new DataFrame(newColumns);
+        }
+
         public override string ToString()
         {
             StringBuilder sb = new StringBuilder();

tests/Microsoft.Data.Analysis.Tests/DataFrameTests.cs

@@ -841,35 +841,36 @@ public void TestComputations()
         }
 
         [Fact]
-        public void TestSort()
+        public void TestOrderBy()
         {
             DataFrame df = MakeDataFrameWithAllMutableColumnTypes(20);
             df["Int"][0] = 100;
             df["Int"][19] = -1;
             df["Int"][5] = 2000;
 
             // Sort by "Int" in ascending order
-            var sortedDf = df.Sort("Int");
+            var sortedDf = df.OrderBy("Int");
             Assert.Null(sortedDf["Int"][19]);
             Assert.Equal(-1, sortedDf["Int"][0]);
             Assert.Equal(100, sortedDf["Int"][17]);
             Assert.Equal(2000, sortedDf["Int"][18]);
 
             // Sort by "Int" in descending order
-            sortedDf = df.Sort("Int", false);
+            sortedDf = df.OrderByDescending("Int");
             Assert.Null(sortedDf["Int"][19]);
             Assert.Equal(-1, sortedDf["Int"][18]);
             Assert.Equal(100, sortedDf["Int"][1]);
             Assert.Equal(2000, sortedDf["Int"][0]);
 
             // Sort by "String" in ascending order
-            sortedDf = df.Sort("String");
+            sortedDf = df.OrderBy("String");
             Assert.Null(sortedDf["Int"][19]);
             Assert.Equal(1, sortedDf["Int"][1]);
             Assert.Equal(8, sortedDf["Int"][17]);
             Assert.Equal(9, sortedDf["Int"][18]);
 
-            sortedDf = df.Sort("String", false);
+            // Sort by "String" in descending order
+            sortedDf = df.OrderByDescending("String");
             Assert.Null(sortedDf["Int"][19]);
             Assert.Equal(8, sortedDf["Int"][1]);
             Assert.Equal(9, sortedDf["Int"][0]);
@@ -886,7 +887,7 @@ public void TestSplitAndSort()
             DataFrame dfTrain = SplitTrainTest(df, 0.8f, out dfTest);
 
             // Sort by "Int" in ascending order
-            var sortedDf = dfTrain.Sort("Int");
+            var sortedDf = dfTrain.OrderBy("Int");
             Assert.Null(sortedDf["Int"][sortedDf.Rows.Count - 1]);
             Assert.Equal(1, sortedDf["Int"][0]);
             Assert.Equal(100000, sortedDf["Int"][sortedDf.Rows.Count - 3]);