Batch of tests added (#45)

* renamed a few test files.
tested the dropna function

* indexer tests

* subtraction

* Subtract, divide, and equals

* DataFrame operators - equality

* added pop test

* Sample test added.
Added support for sample with replace.

Author: brettwebst

src/Pandas.NET/DataFrames/DataFrame.cs

@@ -45,6 +45,12 @@ public DataFrame(List<Series> data, Series index = null, List<Column> columns =
                 index.size,
                 columns.Count
             };
+
+            foreach (var s in _data)
+            {
+                s.SetIndex(_index);
+            }
+
         }
     }
 }

src/Pandas.NET/DataFrames/DataFrame.sample.cs

@@ -1,28 +1,76 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection.PortableExecutable;
+using Tensorflow.Util;
 
 namespace PandasNet;
 
 public partial class DataFrame
 {
-    public DataFrame sample(float frac= 0.8f, int random_state = 0)
+    public DataFrame sample(int n = 0, float frac = 0, int random_state = 0, bool replace = false)
     {
-        var rnd = new Random(random_state);
-        var n = (int)Math.Ceiling((1 - frac) * _index.size);
-        var excludeRowIndexArray = new int[n];
-        for (int i = 0; i < n; i++)
+        if (n == 0 && frac == 0)
+        {
+            throw new ArgumentException("Either n or frac should be greater than 0");
+        }
+        if (n != 0 && frac != 0)
+        {
+            throw new ArgumentException("Only one of n or frac should be greater than 0");
+        }
+        if (frac > 0)
         {
-            excludeRowIndexArray[i] = rnd.Next(0, _index.size - 1);
+            n = (int)Math.Ceiling(frac * _index.size);
         }
+        if (n > _index.size)
+        {
+            throw new ArgumentException("n should be less than the size of the DataFrame");
+        }
+
+        // treat axis as 0 for now.  support for axis=1 should be added in the future
+        var rnd = new Random(random_state);
 
-        var data = new List<Series>();
+        // make a list that we can sample from
+        List<int> sampleIndex = null;
+        
+        if(!replace){
+            // randomize the index and take the first n elements, no duplicates
+            sampleIndex = Enumerable
+                .Range(0, _index.size)
+                .OrderBy(arg => rnd.Next())
+                .Take(n).ToList();
+        }
+        else{
+            // for each sample, randomly select an index allowing duplicates
+            var sampleIndexes = Enumerable.Range(0, _index.size);
+            for (int i = 0; i < n; i++)
+            {
+                sampleIndex.Add(sampleIndexes.ElementAt(rnd.Next(0, sampleIndexes.Count()-1)));
+            }
+        }
+
+        // initialize a dictionary to hold the data
+        Dictionary<Column, ArrayList> data = new Dictionary<Column, ArrayList>();
         foreach (var s in _data)
         {
-            var series = s.drop(excludeRowIndexArray);
-            data.Add(series);
+            // init the array based on the dtype
+            ArrayList array =new ArrayList();
+            data.Add(s.column, array);
+        }
+
+        // fill the arrays with the sampled data
+        for (int i = 0; i < sampleIndex.Count; i++)
+        {
+            foreach (var s in _data)
+            {
+                data[s.column].Add(s.data.GetValue(sampleIndex[i]));
+            }
         }
-        var index = _index.array<int>().Where(x => !excludeRowIndexArray.Contains(x)).ToArray();
-        return new DataFrame(data, columns: _columns, index: new Series(index));
+
+        // create a new DataFrame with the sampled data
+        DataFrame df = new DataFrame(data.Select(x => new Series(x.Value.ToArray(x.Key.DType), x.Key)).ToList(), index: new Series(sampleIndex.ToArray()));
+        return df;
+
     }
 }

test/Pandas.NET.Test/DataFrames/DataFrame.test.pop.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using PandasNet;
+using Tensorflow;
+
+namespace Pandas.Test;
+
+public class DataFramePopTest
+{
+    [Fact]
+    public void TestPopMethod()
+    {
+        // Arrange
+        var dataFrameData = new List<Series>();
+        dataFrameData.Add(new Series(new float[] { 1, 2, 3, 4, 5 }, new Column("column1", typeof(float))));
+        dataFrameData.Add(new Series(new float[] { 6, 7, 8, 9, 10 }, new Column("column2", typeof(float))));
+        var dataFrame = new DataFrame(dataFrameData);
+
+        // Act
+        var poppedSeries = dataFrame.pop("column1");
+
+        // Assert
+        Assert.True(poppedSeries.array<float>().SequenceEqual<float>([1, 2, 3, 4, 5]));
+        Assert.False(dataFrame.columns.Where(c => c.Name == "column1").Any());
+        Assert.True(dataFrame.columns.Where(c => c.Name == "column2").Any());
+    }
+}

test/Pandas.NET.Test/DataFrames/DataFrame.test.sample.cs

@@ -0,0 +1,73 @@
+using PandasNet;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Pandas.Test;
+public class DataFrameSampleTests
+{
+    [Fact]
+    public void TestSampleMethod()
+    {
+        // Arrange
+        List<Series> data = new List<Series>
+        {
+            new Series(new double[] { 1, 2, 3, 4, 5 }, new Column { Name = "column1", DType = typeof(double) }),
+            new Series(new double[] {6, 7, 8, 9, 10 }, new Column { Name = "column2", DType = typeof(double) })
+        };
+        var dataFrame = new DataFrame(data);
+
+        // Act
+        var sampledDataFrame = dataFrame.sample(n: 3, random_state: 1);
+
+        // Assert
+        Assert.Equal(3, sampledDataFrame.index.size);
+        Assert.True(sampledDataFrame.columns.Where(x => x.Name == "column1").Any());
+        Assert.True(sampledDataFrame.columns.Where(x => x.Name == "column2").Any());
+    }
+
+    [Fact]
+    public void TestSampleMethodWithFrac()
+    {
+        // Arrange
+        List<Series> data = new List<Series>
+        {
+            new Series(new double[] { 1, 2, 3, 4, 5 }, new Column { Name = "column1", DType = typeof(double) }),
+            new Series(new double[] {6, 7, 8, 9, 10 }, new Column { Name = "column2", DType = typeof(double) })
+        };
+        var dataFrame = new DataFrame(data);
+
+        // Act
+        var sampledDataFrame = dataFrame.sample(frac: 0.4f, random_state: 1);
+        var sampledDataFrame2 = dataFrame.sample(frac: 0.4f, random_state: 2);
+
+        // Assert
+        Assert.Equal(2, sampledDataFrame.index.size); // 40% of 5 is 2
+        Assert.True(sampledDataFrame.columns.Where(x => x.Name == "column1").Any());
+        Assert.True(sampledDataFrame.columns.Where(x => x.Name == "column2").Any());
+        Assert.Equal(2.0D, sampledDataFrame["column1"].GetValue(0));
+        Assert.Equal(7.0D, sampledDataFrame["column2"].GetValue(0));
+        
+        // assert for other state
+        Assert.Equal(2, sampledDataFrame2.index.size); // 40% of 5 is 2
+        Assert.Equal(5.0D, sampledDataFrame2["column1"].GetValue(0));
+        Assert.Equal(10.0D, sampledDataFrame2["column2"].GetValue(0));
+    }
+
+    [Fact]
+    public void TestSampleMethodThrowsException()
+    {
+        // Arrange
+        List<Series> data = new List<Series>
+        {
+            new Series(new double[] { 1, 2, 3, 4, 5 }, new Column { Name = "column1", DType = typeof(double) }),
+            new Series(new double[] {6, 7, 8, 9, 10 }, new Column { Name = "column2", DType = typeof(double) })
+        };
+        var dataFrame = new DataFrame(data);
+
+        // Act & Assert
+        Assert.Throws<ArgumentException>(() => dataFrame.sample());
+        Assert.Throws<ArgumentException>(() => dataFrame.sample(n: 3, frac: 0.4f));
+        Assert.Throws<ArgumentException>(() => dataFrame.sample(n: 6));
+    }
+}