146ret.Columns.Insert(ret.Columns.Count, dataFrameColumn); 177int columnCount = Columns.Count; 180DataFrameColumn column = Columns[i]; 197DataFrameColumn column = Columns[i]; 202DataFrameColumn column = Columns[i];

18if (values.Count != Columns.Count) 24for (int i = 0; i < Columns.Count; i++) 29retDataFrame.Columns[i] = newColumn; 31retDataFrame.Columns.Insert(i, newColumn); 43for (int i = 0; i < Columns.Count; i++) 48retDataFrame.Columns[i] = newColumn; 50retDataFrame.Columns.Insert(i, newColumn); 57if (values.Count != Columns.Count) 63for (int i = 0; i < Columns.Count; i++) 68retDataFrame.Columns[i] = newColumn; 70retDataFrame.Columns.Insert(i, newColumn); 82for (int i = 0; i < Columns.Count; i++) 87retDataFrame.Columns[i] = newColumn; 89retDataFrame.Columns.Insert(i, newColumn); 96if (values.Count != Columns.Count) 102for (int i = 0; i < Columns.Count; i++) 107retDataFrame.Columns[i] = newColumn; 109retDataFrame.Columns.Insert(i, newColumn); 121for (int i = 0; i < Columns.Count; i++) 126retDataFrame.Columns[i] = newColumn; 128retDataFrame.Columns.Insert(i, newColumn); 135if (values.Count != Columns.Count) 141for (int i = 0; i < Columns.Count; i++) 146retDataFrame.Columns[i] = newColumn; 148retDataFrame.Columns.Insert(i, newColumn); 160for (int i = 0; i < Columns.Count; i++) 165retDataFrame.Columns[i] = newColumn; 167retDataFrame.Columns.Insert(i, newColumn); 174if (values.Count != Columns.Count) 180for (int i = 0; i < Columns.Count; i++) 185retDataFrame.Columns[i] = newColumn; 187retDataFrame.Columns.Insert(i, newColumn); 199for (int i = 0; i < Columns.Count; i++) 204retDataFrame.Columns[i] = newColumn; 206retDataFrame.Columns.Insert(i, newColumn); 212if (values.Count != Columns.Count) 218for (int i = 0; i < Columns.Count; i++) 223retDataFrame.Columns[i] = newColumn; 225retDataFrame.Columns.Insert(i, newColumn); 236for (int i = 0; i < Columns.Count; i++) 241retDataFrame.Columns[i] = newColumn; 243retDataFrame.Columns.Insert(i, newColumn); 249if (values.Count != Columns.Count) 255for (int i = 0; i < Columns.Count; i++) 260retDataFrame.Columns[i] = newColumn; 262retDataFrame.Columns.Insert(i, newColumn); 273for (int i = 0; i < Columns.Count; i++) 278retDataFrame.Columns[i] = newColumn; 280retDataFrame.Columns.Insert(i, newColumn); 286if (values.Count != Columns.Count) 292for (int i = 0; i < Columns.Count; i++) 297retDataFrame.Columns[i] = newColumn; 299retDataFrame.Columns.Insert(i, newColumn); 310for (int i = 0; i < Columns.Count; i++) 315retDataFrame.Columns[i] = newColumn; 317retDataFrame.Columns.Insert(i, newColumn); 328for (int i = 0; i < Columns.Count; i++) 333retDataFrame.Columns[i] = newColumn; 335retDataFrame.Columns.Insert(i, newColumn); 346for (int i = 0; i < Columns.Count; i++) 351retDataFrame.Columns[i] = newColumn; 353retDataFrame.Columns.Insert(i, newColumn); 360if (values.Count != Columns.Count) 366for (int i = 0; i < Columns.Count; i++) 370retDataFrame.Columns.Insert(i, newColumn); 382for (int i = 0; i < Columns.Count; i++) 386retDataFrame.Columns.Insert(i, newColumn); 393if (values.Count != Columns.Count) 399for (int i = 0; i < Columns.Count; i++) 403retDataFrame.Columns.Insert(i, newColumn); 415for (int i = 0; i < Columns.Count; i++) 419retDataFrame.Columns.Insert(i, newColumn); 426if (values.Count != Columns.Count) 432for (int i = 0; i < Columns.Count; i++) 436retDataFrame.Columns.Insert(i, newColumn); 448for (int i = 0; i < Columns.Count; i++) 452retDataFrame.Columns.Insert(i, newColumn); 459if (values.Count != Columns.Count) 465for (int i = 0; i < Columns.Count; i++) 469retDataFrame.Columns.Insert(i, newColumn); 481for (int i = 0; i < Columns.Count; i++) 485retDataFrame.Columns.Insert(i, newColumn); 492if (values.Count != Columns.Count) 498for (int i = 0; i < Columns.Count; i++) 502retDataFrame.Columns.Insert(i, newColumn); 514for (int i = 0; i < Columns.Count; i++) 518retDataFrame.Columns.Insert(i, newColumn); 525if (values.Count != Columns.Count) 531for (int i = 0; i < Columns.Count; i++) 535retDataFrame.Columns.Insert(i, newColumn); 547for (int i = 0; i < Columns.Count; i++) 551retDataFrame.Columns.Insert(i, newColumn); 563for (int i = 0; i < Columns.Count; i++) 568retDataFrame.Columns[i] = newColumn; 570retDataFrame.Columns.Insert(i, newColumn); 581for (int i = 0; i < Columns.Count; i++) 586retDataFrame.Columns[i] = newColumn; 588retDataFrame.Columns.Insert(i, newColumn); 599for (int i = 0; i < Columns.Count; i++) 604retDataFrame.Columns[i] = newColumn; 606retDataFrame.Columns.Insert(i, newColumn); 617for (int i = 0; i < Columns.Count; i++) 622retDataFrame.Columns[i] = newColumn; 624retDataFrame.Columns.Insert(i, newColumn); 635for (int i = 0; i < Columns.Count; i++) 640retDataFrame.Columns[i] = newColumn; 642retDataFrame.Columns.Insert(i, newColumn); 652for (int i = 0; i < Columns.Count; i++) 657retDataFrame.Columns[i] = newColumn; 659retDataFrame.Columns.Insert(i, newColumn); 669for (int i = 0; i < Columns.Count; i++) 674retDataFrame.Columns[i] = newColumn; 676retDataFrame.Columns.Insert(i, newColumn); 686for (int i = 0; i < Columns.Count; i++) 691retDataFrame.Columns[i] = newColumn; 693retDataFrame.Columns.Insert(i, newColumn);

161get => Columns[columnName]; 162set => Columns[columnName] = value; 200List<DataFrameColumn> newColumns = new List<DataFrameColumn>(Columns.Count); 201for (int i = 0; i < Columns.Count; i++) 203newColumns.Add(Columns[i].Clone(mapIndices)); 216foreach (DataFrameColumn column in Columns) 224ret.Columns.Add(strColumn); 226ret.Columns.Add(column.Info()); 239foreach (DataFrameColumn column in Columns) 253ret.Columns.Add(stringColumn); 255ret.Columns.Add(column.Description()); 292for (int i = 0; i < ret.Columns.Count; i++) 294DataFrameColumn column = ret.Columns[i]; 307for (int i = 0; i < df.Columns.Count; i++) 309DataFrameColumn column = df.Columns[i]; 322for (int i = 0; i < df.Columns.Count; i++) 324DataFrameColumn column = df.Columns[i]; 400for (int i = 0; i < Columns.Count; i++) 402if (Columns[i].Length != rowCount) 403throw new ArgumentException(String.Format("{0} {1}", Strings.MismatchedRowCount, Columns[i].Name)); 421foreach (var column in Columns) 441foreach (var column in Columns) 468for (int i = 0; i < ret.Columns.Count; i++) 470ret.Columns[i].FillNulls(value, inPlace: true); 483if (values.Count != Columns.Count) 487for (int i = 0; i < ret.Columns.Count; i++) 489Columns[i].FillNulls(values[i], inPlace: true); 536IEnumerator<DataFrameColumn> columnEnumerator = ret.Columns.GetEnumerator(); 575throw new ArgumentException(string.Format(Strings.ExceedsNumberOfColumns, Columns.Count), nameof(row)); 578columnEnumerator = ret.Columns.GetEnumerator(); 600ret.Columns.RowCount++; 628int index = ret.Columns.IndexOf(columnName); 634DataFrameColumn column = ret.Columns[index]; 651int index = ret.Columns.IndexOf(columnName); 653DataFrameColumn column = ret.Columns[index]; 659foreach (DataFrameColumn column in ret.Columns) 666ret.Columns.RowCount++; 680DataFrameColumn column = Columns[columnName]; 683List<DataFrameColumn> newColumns = new List<DataFrameColumn>(Columns.Count); 684for (int i = 0; i < Columns.Count; i++) 686DataFrameColumn oldColumn = Columns[i]; 709for (int i = 0; i < Columns.Count; i++) 711longestColumnName = Math.Max(longestColumnName, Columns[i].Name.Length); 715for (int i = 0; i < Columns.Count; i++) 718sb.Append(string.Format(Columns[i].Name.PadRight(padding)));

29for (int i = 0; i < Columns.Count; i++) 31DataFrameColumn baseColumn = Columns[i]; 110DataFrameColumn column = _dataFrame.Columns[col];

144var columnsCount = Columns.Count; 148foreach (var column in Columns) 159if (table.Columns[c].DataType != Columns[c].DataType) 478ret.Columns.Insert(0, indexColumn); 676SaveHeader(csvFile, dataFrame.Columns.GetColumnNames(), separator);

32DataFrameColumn existingColumn = dataFrame.Columns[index]; 52for (int i = 0; i < Columns.Count; i++) 54DataFrameColumn newColumn = Columns[i].Clone(); 55ret.Columns.Insert(ret.Columns.Count, newColumn); 63for (int i = 0; i < other.Columns.Count; i++) 68newColumn = other.Columns[i].Clone(numberOfNullsToAppend: Rows.Count - other.Rows.Count); 72newColumn = other.Columns[i].Clone(mapIndices); 75ret.Columns.Insert(ret.Columns.Count, newColumn); 86for (int i = 0; i < Columns.Count; i++) 91newColumn = Columns[i].Clone(numberOfNullsToAppend: other.Rows.Count - Rows.Count); 95newColumn = Columns[i].Clone(mapIndices); 97ret.Columns.Insert(ret.Columns.Count, newColumn); 99for (int i = 0; i < other.Columns.Count; i++) 101DataFrameColumn newColumn = other.Columns[i].Clone(); 103ret.Columns.Insert(ret.Columns.Count, newColumn); 110for (int i = 0; i < Columns.Count; i++) 112DataFrameColumn newColumn = Columns[i].Clone(numberOfNullsToAppend: numberOfNulls); 113ret.Columns.Insert(ret.Columns.Count, newColumn); 116for (int i = 0; i < other.Columns.Count; i++) 118DataFrameColumn newColumn = other.Columns[i].Clone(numberOfNullsToAppend: numberOfNulls); 120ret.Columns.Insert(ret.Columns.Count, newColumn); 131for (int i = 0; i < Columns.Count; i++) 133DataFrameColumn newColumn = Columns[i].Clone(mapIndices); 134ret.Columns.Insert(ret.Columns.Count, newColumn); 136for (int i = 0; i < other.Columns.Count; i++) 138DataFrameColumn newColumn = other.Columns[i].Clone(mapIndices); 140ret.Columns.Insert(ret.Columns.Count, newColumn); 204DataFrameColumn shrinkedRetainedColumn = retainedDataFrame.Columns[retainedJoinColumnNames[colNameIndex]]; 228DataFrameColumn supplementaryColumn = supplementaryDataFrame.Columns[supplemetaryJoinColumnNames[colNameIndex]]; 285var retainJoinColumns = retainedJoinColumnNames.Select(name => retainedDataFrame.Columns[name]).ToArray(); 287for (long i = 0; i < retainedDataFrame.Columns.RowCount; i++) 388for (long i = 0; i < supplementaryDataFrame.Columns.RowCount; i++) 390var columns = supplementaryJoinColumns.Select(name => supplementaryDataFrame.Columns[name]).ToArray(); 410for (int i = 0; i < this.Columns.Count; i++) 412ret.Columns.Insert(i, this.Columns[i].Clone(mapIndicesLeft)); 416for (int i = 0; i < other.Columns.Count; i++) 418DataFrameColumn column = other.Columns[i].Clone(mapIndicesRight); 421ret.Columns.Insert(ret.Columns.Count, column);

24Debug.Assert(rowIndex < df.Columns.RowCount); 34foreach (DataFrameColumn column in _dataFrame.Columns) 42return _dataFrame.Columns.Select(col => new KeyValuePair<string, object>(col.Name, col[_rowIndex])); 54return _dataFrame.Columns[index][_rowIndex]; 58_dataFrame.Columns[index][_rowIndex] = value;

52public long Count => _dataFrame.Columns.RowCount;

110if (dataFrame.Columns.Count < groupByColumnIndex || groupByColumnIndex < 0) 133int columnIndex = _dataFrame.Columns.IndexOf(columnName); 146DataFrameColumn firstColumn = _dataFrame.Columns[_groupByColumnIndex].Clone(empty); 147ret.Columns.Insert(ret.Columns.Count, firstColumn); 157DataFrameColumn column = _dataFrame.Columns[columnIndex]; 168ret.Columns.Insert(ret.Columns.Count, retColumn); 173retColumn = ret.Columns[column.Name]; 189DataFrameColumn firstColumn = _dataFrame.Columns[_groupByColumnIndex].Clone(empty); 190ret.Columns.Insert(ret.Columns.Count, firstColumn); 202DataFrameColumn column = _dataFrame.Columns[columnIndex]; 209ret.Columns.Insert(ret.Columns.Count, retColumn); 214retColumn = ret.Columns[column.Name]; 231DataFrameColumn firstColumn = _dataFrame.Columns[_groupByColumnIndex].Clone(empty); 232ret.Columns.Insert(ret.Columns.Count, firstColumn); 242DataFrameColumn column = _dataFrame.Columns[columnIndex]; 254ret.Columns.Insert(ret.Columns.Count, retColumn); 259retColumn = ret.Columns[column.Name]; 285DataFrameColumn firstColumn = _dataFrame.Columns[_groupByColumnIndex].Clone(empty); 286ret.Columns.Insert(ret.Columns.Count, firstColumn); 296DataFrameColumn column = _dataFrame.Columns[columnIndex]; 310ret.Columns.Insert(ret.Columns.Count, retColumn); 315retColumn = ret.Columns[column.Name]; 339DataFrameColumn column = _dataFrame.Columns[columnIndex]; 344ret.Columns.Insert(ret.Columns.Count, retColumn); 349retColumn = ret.Columns[column.Name]; 359DataFrameColumn firstColumn = _dataFrame.Columns[_groupByColumnIndex].Clone(empty); 360ret.Columns.Insert(ret.Columns.Count, firstColumn); 373retColumn[rowIndex] = _dataFrame.Columns[columnIndex].Max(rowEnumerable); 387DataFrameColumn firstColumn = _dataFrame.Columns[_groupByColumnIndex].Clone(empty); 388ret.Columns.Insert(ret.Columns.Count, firstColumn); 401retColumn[rowIndex] = _dataFrame.Columns[columnIndex].Min(rowEnumerable); 415DataFrameColumn firstColumn = _dataFrame.Columns[_groupByColumnIndex].Clone(empty); 416ret.Columns.Insert(ret.Columns.Count, firstColumn); 429retColumn[rowIndex] = _dataFrame.Columns[columnIndex].Product(rowEnumerable); 443DataFrameColumn firstColumn = _dataFrame.Columns[_groupByColumnIndex].Clone(empty); 444ret.Columns.Insert(ret.Columns.Count, firstColumn); 457retColumn[rowIndex] = _dataFrame.Columns[columnIndex].Sum(rowEnumerable); 471DataFrameColumn firstColumn = _dataFrame.Columns[_groupByColumnIndex].Clone(empty); 472ret.Columns.Insert(ret.Columns.Count, firstColumn); 486retColumn[rowIndex] = (double)Convert.ChangeType(_dataFrame.Columns[columnIndex].Sum(rowEnumerable), typeof(double)) / rowEnumerable.Count;

48header.AddRange(df.Columns.Select(c => (IHtmlContent)th(c.Name))); 101tfoot(tr(td[colspan: df.Columns.Count + 1, style: "text-align: center;"](footer)))

42dataFrame.Columns.Add(new DoubleDataFrameColumn(fieldDescriptor.Name, column.Select(Convert.ToDouble))); 45dataFrame.Columns.Add(new Int64DataFrameColumn(fieldDescriptor.Name, column.Select(Convert.ToInt64))); 48dataFrame.Columns.Add(new BooleanDataFrameColumn(fieldDescriptor.Name, column.Select(Convert.ToBoolean))); 51dataFrame.Columns.Add(new StringDataFrameColumn(fieldDescriptor.Name, column.Select(Convert.ToString)));

30dataFrame.Columns.Insert(0, dataFrameColumn1); 31dataFrame.Columns.Insert(1, dataFrameColumn2); 92Assert.Equal(dataFrame.Columns.Select(c => c.Name).ToArray(), new[] { "TrueOrFalse", "Integer", "Double", "Text" });

166Assert.Equal(1, df.Columns["Column1"][1]); 167df.Columns["Column1"][1] = 100; 168Assert.Equal(100, df.Columns["Column1"][1]); 169Assert.Equal(0, df.Columns["Column1"].NullCount); 188Assert.Equal(0, df.Columns["EmptyNullBitMapColumn"].NullCount); 189Assert.Equal(10, df.Columns["EmptyNullBitMapColumn"].Length); 190df.Columns["EmptyNullBitMapColumn"][9] = null; 191Assert.Equal(1, df.Columns["EmptyNullBitMapColumn"].NullCount); 192Assert.Equal(10, df.Columns["EmptyDataColumn"].NullCount); 193Assert.Equal(10, df.Columns["EmptyDataColumn"].Length); 194df.Columns["EmptyDataColumn"][9] = 9; 195Assert.Equal(9, df.Columns["EmptyDataColumn"].NullCount); 196Assert.Equal(10, df.Columns["EmptyDataColumn"].Length); 199Assert.Equal(i, (int)df.Columns["EmptyNullBitMapColumn"][i]); 200Assert.Null(df.Columns["EmptyDataColumn"][i]); 207Assert.Equal(0, emptyDataFrame.Columns["EmptyDataAndNullColumns"].Length); 208Assert.Equal(0, emptyDataFrame.Columns["EmptyDataAndNullColumns"].NullCount);

27foreach (DataFrameColumn column in df.Columns) 138Assert.Equal(7, df.Columns.Count); 139Assert.Equal(verifyCMT, df.Columns["vendor_id"][3]); 150Assert.Equal(7, reducedRows.Columns.Count); 151Assert.Equal(verifyCMT, reducedRows.Columns["vendor_id"][2]); 172Assert.Equal(7, df.Columns.Count); 222Assert.Equal(9, df.Columns.Count); 223Assert.Equal("CMT", df.Columns["vendor_id"][3]); 225Assert.Equal("payment_type", df.Columns[5].Name); 226Assert.Equal("payment_type.1", df.Columns[6].Name); 227Assert.Equal("payment_type.2", df.Columns[7].Name); 229Assert.Equal("CRD", df.Columns["payment_type"][0]); 230Assert.Equal("CRD_1", df.Columns["payment_type.1"][0]); 231Assert.Equal("Test", df.Columns["payment_type.2"][0]); 251Assert.Equal(7, df.Columns.Count); 252Assert.Equal(verifyCMT, df.Columns["Column0"][3]); 264Assert.Equal(7, reducedRows.Columns.Count); 265Assert.Equal(verifyCMT, reducedRows.Columns["Column0"][2]); 290Assert.Equal(7, df.Columns.Count); 291Assert.Equal(verifyCMT, df.Columns["Column0"][3]); 303Assert.Equal(7, reducedRows.Columns.Count); 304Assert.Equal(verifyCMT, reducedRows.Columns["Column0"][2]); 317Assert.Equal(7, df.Columns.Count); 321Assert.True(typeof(string) == df.Columns[0].DataType); 322Assert.True(typeof(short) == df.Columns[1].DataType); 323Assert.True(typeof(int) == df.Columns[2].DataType); 324Assert.True(typeof(long) == df.Columns[3].DataType); 325Assert.True(typeof(float) == df.Columns[4].DataType); 326Assert.True(typeof(string) == df.Columns[5].DataType); 327Assert.True(typeof(double) == df.Columns[6].DataType); 332Assert.Equal("vendor_id", df.Columns[0].Name); 333Assert.Equal("rate_code", df.Columns[1].Name); 334Assert.Equal("passenger_count", df.Columns[2].Name); 335Assert.Equal("trip_time_in_secs", df.Columns[3].Name); 336Assert.Equal("trip_distance", df.Columns[4].Name); 337Assert.Equal("payment_type", df.Columns[5].Name); 338Assert.Equal("fare_amount", df.Columns[6].Name); 343foreach (var column in df.Columns) 430Assert.Equal(7, df.Columns.Count); 432Assert.True(typeof(string) == df.Columns[0].DataType); 433Assert.True(typeof(short) == df.Columns[1].DataType); 434Assert.True(typeof(int) == df.Columns[2].DataType); 435Assert.True(typeof(long) == df.Columns[3].DataType); 436Assert.True(typeof(float) == df.Columns[4].DataType); 437Assert.True(typeof(string) == df.Columns[5].DataType); 438Assert.True(typeof(double) == df.Columns[6].DataType); 440Assert.Equal("vendor_id", df.Columns[0].Name); 441Assert.Equal("rate_code", df.Columns[1].Name); 442Assert.Equal("passenger_count", df.Columns[2].Name); 443Assert.Equal("trip_time_in_secs", df.Columns[3].Name); 444Assert.Equal("trip_distance", df.Columns[4].Name); 445Assert.Equal("payment_type", df.Columns[5].Name); 446Assert.Equal("fare_amount", df.Columns[6].Name); 449foreach (var column in df.Columns) 489Assert.Equal(8, df.Columns.Count); 493Assert.True(typeof(string) == df.Columns[0].DataType); 494Assert.True(typeof(short) == df.Columns[1].DataType); 495Assert.True(typeof(int) == df.Columns[2].DataType); 496Assert.True(typeof(long) == df.Columns[3].DataType); 497Assert.True(typeof(float) == df.Columns[4].DataType); 498Assert.True(typeof(string) == df.Columns[5].DataType); 499Assert.True(typeof(double) == df.Columns[6].DataType); 500Assert.True(typeof(DateTime) == df.Columns[7].DataType); 503Assert.Equal("vendor_id", df.Columns[0].Name); 504Assert.Equal("rate_code", df.Columns[1].Name); 505Assert.Equal("passenger_count", df.Columns[2].Name); 506Assert.Equal("trip_time_in_secs", df.Columns[3].Name); 507Assert.Equal("trip_distance", df.Columns[4].Name); 508Assert.Equal("payment_type", df.Columns[5].Name); 509Assert.Equal("fare_amount", df.Columns[6].Name); 510Assert.Equal("date", df.Columns[7].Name); 513foreach (var column in df.Columns) 534var dateTimeColumn = df.Columns["date"]; 566Assert.Equal(7, df.Columns.Count); 567Assert.Equal("CMT", df.Columns["vendor_id"][4]); 572Assert.Equal(7, reducedRows.Columns.Count); 573Assert.Equal("CMT", reducedRows.Columns["vendor_id"][2]); 605Assert.Equal(7, df.Columns.Count); 606Assert.Equal("CMT", df.Columns["vendor_id"][4]); 611Assert.Equal(7, reducedRows.Columns.Count); 612Assert.Equal("CMT", reducedRows.Columns["vendor_id"][2]); 643Assert.Equal(7, df.Columns.Count); 644Assert.Equal("CMT", df.Columns["vendor_id"][3]); 649Assert.Equal(7, reducedRows.Columns.Count); 650Assert.Equal("CMT", reducedRows.Columns["vendor_id"][2]); 670var columnName = df.Columns.Select(c => c.Name); 685var columnName = df.Columns.Select(c => c.Name); 709Assert.Equal(2, dataFrame.Columns.Count); 710Assert.Equal("IndexColumn", dataFrame.Columns[0].Name); 711Assert.Equal(3, dataFrame.Columns[0].Length); 713for (long i = 0; i < dataFrame.Columns[0].Length; i++) 714Assert.Equal(i, dataFrame.Columns[0][i]); 742Assert.Equal(6, df.Columns.Count); 743Assert.Equal("CMT", df.Columns["vendor_id"][3]); 748Assert.Equal(6, reducedRows.Columns.Count); 749Assert.Equal("CMT", reducedRows.Columns["vendor_id"][2]); 773Assert.Equal(4, df.Columns.Count); 775Assert.True(typeof(string) == df.Columns[0].DataType); 776Assert.True(typeof(string) == df.Columns[1].DataType); 777Assert.True(typeof(string) == df.Columns[2].DataType); 778Assert.True(typeof(string) == df.Columns[3].DataType); 780Assert.Equal("vendor_id", df.Columns[0].Name); 781Assert.Equal("rate_code", df.Columns[1].Name); 782Assert.Equal("passenger_count", df.Columns[2].Name); 783Assert.Equal("trip_time_in_secs", df.Columns[3].Name); 786foreach (var column in df.Columns) 816Assert.Equal(4, df.Columns.Count); 818Assert.True(typeof(string) == df.Columns[0].DataType); 819Assert.True(typeof(short) == df.Columns[1].DataType); 820Assert.True(typeof(int) == df.Columns[2].DataType); 821Assert.True(typeof(long) == df.Columns[3].DataType); 823Assert.Equal("vendor_id", df.Columns[0].Name); 824Assert.Equal("rate_code", df.Columns[1].Name); 825Assert.Equal("passenger_count", df.Columns[2].Name); 826Assert.Equal("trip_time_in_secs", df.Columns[3].Name); 829foreach (var column in df.Columns) 878Assert.Equal(4, df.Columns.Count); 880Assert.True(typeof(string) == df.Columns[0].DataType); 881Assert.True(typeof(float) == df.Columns[1].DataType); 882Assert.True(typeof(float) == df.Columns[2].DataType); 883Assert.True(typeof(float) == df.Columns[3].DataType); 885Assert.Equal("vendor_id", df.Columns[0].Name); 886Assert.Equal("rate_code", df.Columns[1].Name); 887Assert.Equal("passenger_count", df.Columns[2].Name); 888Assert.Equal("trip_time_in_secs", df.Columns[3].Name); 891foreach (var column in df.Columns) 947Assert.Equal(dataFrame.Columns.Count, readIn.Columns.Count); 949Assert.Equal(typeof(string), readIn.Columns[0].DataType); 967Assert.Equal(dataFrame.Columns.Count, readIn.Columns.Count); 998Assert.Equal(dataFrame.Columns.Count, readIn.Columns.Count); 1031Assert.Equal(dataFrame.Columns.Count, readIn.Columns.Count); 1069Assert.Equal(dataFrame.Columns.Count, readIn.Columns.Count); 1096Assert.Equal(dataFrame.Columns.Count, readIn.Columns.Count); 1123Assert.Equal(2, df.Columns.Count); 1125Assert.True(typeof(string) == df.Columns[0].DataType); 1126Assert.True(typeof(string) == df.Columns[1].DataType); 1128Assert.Equal("vendor_id", df.Columns[0].Name); 1129Assert.Equal("empty", df.Columns[1].Name); 1131Assert.Equal(2, df.Columns[0].NullCount); 1132Assert.Equal(0, df.Columns[1].NullCount); 1143StringDataFrameColumn emptyColumn = (StringDataFrameColumn)df.Columns[1]; 1203var resColumns = dataFrame.Columns.Select(column => (column.Name, column.DataType)).ToArray(); 1284Assert.Equal(_columnCount, df.Columns.Count); 1288Assert.True(_columnTypes[j] == df.Columns[j].DataType); 1289Assert.Equal(_columnNames[j], df.Columns[j].Name);

68int numberColumnsCount = df.Columns.Count - 2; //except "Parity" and "Tens" columns 109df.Columns.Insert(df.Columns.Count, parityColumn); 110df.Columns.Insert(df.Columns.Count, tensColumn);

106df.Columns.Remove("Bool"); 111df.Columns.Insert(0, boolColumn); 118df.Columns[1] = boolClone; 254df.Columns.Remove("Char"); // Because chars are returned as uint16 by IDataView, so end up comparing CharDataFrameColumn to UInt16DataFrameColumn and fail asserts 258Assert.Equal(dfAsIDataView.Schema.Count, newDf.Columns.Count); 259for (int i = 0; i < df.Columns.Count; i++) 261Assert.True(df.Columns[i].ElementwiseEquals(newDf.Columns[i]).All()); 272Assert.Equal(2, newDf.Columns.Count); 273Assert.True(df.Columns["Int"].ElementwiseEquals(newDf.Columns["Int"]).All()); 274Assert.True(df.Columns["Double"].ElementwiseEquals(newDf.Columns["Double"]).All()); 284df.Columns.Remove("Char"); // Because chars are returned as uint16 by DataViewSchema, so end up comparing CharDataFrameColumn to UInt16DataFrameColumn and fail asserts 285df.Columns.Remove("Decimal"); // Because decimal is returned as double by DataViewSchema, so end up comparing DecimalDataFrameColumn to DoubleDataFrameColumn and fail asserts 302Assert.Equal(df.Columns.Count, newDf.Columns.Count); 303for (int i = 0; i < newDf.Columns.Count; i++) 305Assert.Equal(rowSize, newDf.Columns[i].Length); 306Assert.Equal(df.Columns[i].Name, newDf.Columns[i].Name); 308Assert.Equal(dfAsIDataView.Schema.Count, newDf.Columns.Count); 309for (int c = 0; c < df.Columns.Count; c++) 313Assert.Equal(df.Columns[c][r], newDf.Columns[c][r]); 325for (int i = 0; i < newDf.Columns.Count; i++) 327Assert.Equal(5, newDf.Columns[i].Length); 329Assert.Equal(2, newDf.Columns.Count); 332Assert.Equal(df.Columns["Int"][r], newDf.Columns["Int"][r]); 333Assert.Equal(df.Columns["Double"][r], newDf.Columns["Double"][r]); 373Assert.Equal(value, df.Columns[columnName][cc++]); 383Assert.Equal(3, df.Columns.Count); 384foreach (var column in df.Columns) 400Assert.Equal(2, df.Columns.Count); 401foreach (var column in df.Columns) 418Assert.Equal(3, df.Columns.Count); 419foreach (var column in df.Columns) 435Assert.Equal(2, df.Columns.Count); 436foreach (var column in df.Columns) 485Assert.Equal(12, df.Columns.Count);

96for (int i = 0; i < df1.Columns.Count; i++) 98newColumn = df1.Columns[df1.Columns[i].Name] + df2.Columns[df2.Columns[i].Name]; 99verify = newColumn.ElementwiseEquals(df1.Columns[i] * 2); 102newColumn = df1.Columns[df1.Columns[i].Name] - df2.Columns[df2.Columns[i].Name]; 106newColumn = df1.Columns[df1.Columns[i].Name] * df2.Columns[df2.Columns[i].Name]; 107verify = newColumn.ElementwiseEquals(df1.Columns[i] * df1.Columns[i]); 110var df1Column = df1.Columns[i] + 1; 111var df2Column = df2.Columns[i] + 1; 120verify = df1.Columns[df1.Columns[i].Name].ElementwiseEquals(df2.Columns[df2.Columns[i].Name]); 123verify = df1.Columns[df1.Columns[i].Name].ElementwiseNotEquals(df2.Columns[df2.Columns[i].Name]); 126verify = df1.Columns[df1.Columns[i].Name].ElementwiseGreaterThanOrEqual(df2.Columns[df2.Columns[i].Name]); 129verify = df1.Columns[df1.Columns[i].Name].ElementwiseLessThanOrEqual(df2.Columns[df2.Columns[i].Name]); 132verify = df1.Columns[df1.Columns[i].Name].ElementwiseGreaterThan(df2.Columns[df2.Columns[i].Name]); 135verify = df1.Columns[df1.Columns[i].Name].ElementwiseLessThan(df2.Columns[df2.Columns[i].Name]); 147var dtype = dfd.Columns[0].DataType; 152dtype = dfm.Columns[0].DataType; 159df.Columns[0] = dataFrameColumn1; 170df.Columns.Insert(0, dataFrameColumn1); 171df.Columns.Insert(1, dataFrameColumn2); 204df.Columns.Insert(0, dataFrameColumn1); 205df.Columns.Insert(1, dataFrameColumn2); 250df.Columns.Insert(0, stringColumn); 299df.Columns.Insert(0, stringColumn); 363Assert.True(typeof(decimal) == tempDf.Columns["Int"].DataType); 369Assert.True(typeof(decimal) == tempDf.Columns["Int"].DataType); 375Assert.True(typeof(decimal) == tempDf.Columns["Int"].DataType); 381Assert.True(typeof(decimal) == tempDf.Columns["Int"].DataType); 387Assert.True(typeof(decimal) == tempDf.Columns["Int"].DataType); 395Assert.True(typeof(decimal) == tempDf.Columns["Int"].DataType); 401Assert.True(typeof(decimal) == tempDf.Columns["Int"].DataType); 407Assert.True(typeof(decimal) == tempDf.Columns["Int"].DataType); 416Assert.True(typeof(decimal) == tempDf.Columns["Int"].DataType); 422Assert.True(typeof(decimal) == tempDf.Columns["Int"].DataType); 442Int32DataFrameColumn ints = df.Columns["Int"] as Int32DataFrameColumn; 468BooleanDataFrameColumn bools = df.Columns["Bool"] as BooleanDataFrameColumn;

21Assert.Equal(-10, df.Columns["Int"][0]); 23DataFrameColumn absColumn = df.Columns["Int"].Abs(); 25Assert.Equal(-10, df.Columns["Int"][0]); 26df.Columns["Int"].Abs(true); 27Assert.Equal(10, df.Columns["Int"][0]); 29Assert.Throws<NotSupportedException>(() => df.Columns["Byte"].All()); 30Assert.Throws<NotSupportedException>(() => df.Columns["Byte"].Any()); 31Assert.Throws<NotSupportedException>(() => df.Columns["Char"].All()); 32Assert.Throws<NotSupportedException>(() => df.Columns["Char"].Any()); 33Assert.Throws<NotSupportedException>(() => df.Columns["DateTime"].All()); 34Assert.Throws<NotSupportedException>(() => df.Columns["DateTime"].Any()); 35Assert.Throws<NotSupportedException>(() => df.Columns["Decimal"].All()); 36Assert.Throws<NotSupportedException>(() => df.Columns["Decimal"].Any()); 37Assert.Throws<NotSupportedException>(() => df.Columns["Double"].All()); 38Assert.Throws<NotSupportedException>(() => df.Columns["Double"].Any()); 39Assert.Throws<NotSupportedException>(() => df.Columns["Float"].All()); 40Assert.Throws<NotSupportedException>(() => df.Columns["Float"].Any()); 41Assert.Throws<NotSupportedException>(() => df.Columns["Int"].All()); 42Assert.Throws<NotSupportedException>(() => df.Columns["Int"].Any()); 43Assert.Throws<NotSupportedException>(() => df.Columns["Long"].All()); 44Assert.Throws<NotSupportedException>(() => df.Columns["Long"].Any()); 45Assert.Throws<NotSupportedException>(() => df.Columns["Sbyte"].All()); 46Assert.Throws<NotSupportedException>(() => df.Columns["Sbyte"].Any()); 47Assert.Throws<NotSupportedException>(() => df.Columns["Short"].All()); 48Assert.Throws<NotSupportedException>(() => df.Columns["Short"].Any()); 49Assert.Throws<NotSupportedException>(() => df.Columns["Uint"].All()); 50Assert.Throws<NotSupportedException>(() => df.Columns["Uint"].Any()); 51Assert.Throws<NotSupportedException>(() => df.Columns["Ulong"].All()); 52Assert.Throws<NotSupportedException>(() => df.Columns["Ulong"].Any()); 53Assert.Throws<NotSupportedException>(() => df.Columns["Ushort"].All()); 54Assert.Throws<NotSupportedException>(() => df.Columns["Ushort"].Any()); 56bool any = df.Columns["Bool"].Any(); 57bool all = df.Columns["Bool"].All(); 62df.Columns["Double"][0] = 100.0; 63DataFrameColumn doubleColumn = df.Columns["Double"].CumulativeMax(); 71Assert.Equal(1.0, df.Columns["Double"][1]); 72df.Columns["Double"].CumulativeMax(true); 73for (int i = 0; i < df.Columns["Double"].Length; i++) 76Assert.Null(df.Columns["Double"][i]); 78Assert.Equal(100.0, (double)df.Columns["Double"][i]); 81df.Columns["Float"][0] = -10.0f; 82DataFrameColumn floatColumn = df.Columns["Float"].CumulativeMin(); 90Assert.Equal(9.0f, df.Columns["Float"][9]); 91df.Columns["Float"].CumulativeMin(true); 92for (int i = 0; i < df.Columns["Float"].Length; i++) 95Assert.Null(df.Columns["Float"][i]); 97Assert.Equal(-10.0f, (float)df.Columns["Float"][i]); 100DataFrameColumn uintColumn = df.Columns["Uint"].CumulativeProduct(); 102Assert.Equal((uint)8, df.Columns["Uint"][8]); 103df.Columns["Uint"].CumulativeProduct(true); 104Assert.Equal((uint)0, df.Columns["Uint"][9]); 106DataFrameColumn ushortColumn = df.Columns["Ushort"].CumulativeSum(); 108Assert.Equal((ushort)9, df.Columns["Ushort"][9]); 109df.Columns["Ushort"].CumulativeSum(true); 110Assert.Equal((ushort)40, df.Columns["Ushort"][9]); 112Assert.Equal(100.0, df.Columns["Double"].Max()); 113Assert.Equal(-10.0f, df.Columns["Float"].Min()); 114Assert.Equal((uint)0, df.Columns["Uint"].Product()); 115Assert.Equal((ushort)130, df.Columns["Ushort"].Sum()); 117df.Columns["Double"][0] = 100.1; 118Assert.Equal(100.1, df.Columns["Double"][0]); 119DataFrameColumn roundColumn = df.Columns["Double"].Round(); 121Assert.Equal(100.1, df.Columns["Double"][0]); 122df.Columns["Double"].Round(true); 123Assert.Equal(100.0, df.Columns["Double"][0]); 126for (int i = 0; i < df.Columns.Count; i++) 128DataFrameColumn column = df.Columns[i]; 183Assert.Equal(-10, df.Columns["Int"][0]); 185DataFrameColumn absColumn = df.Columns["Int"].Abs(); 187Assert.Equal(-10, df.Columns["Int"][0]); 188df.Columns["Int"].Abs(true); 189Assert.Equal(10, df.Columns["Int"][0]); 191Assert.Throws<NotSupportedException>(() => df.Columns["Byte"].All()); 192Assert.Throws<NotSupportedException>(() => df.Columns["Byte"].Any()); 193Assert.Throws<NotSupportedException>(() => df.Columns["Char"].All()); 194Assert.Throws<NotSupportedException>(() => df.Columns["Char"].Any()); 195Assert.Throws<NotSupportedException>(() => df.Columns["Decimal"].All()); 196Assert.Throws<NotSupportedException>(() => df.Columns["Decimal"].Any()); 197Assert.Throws<NotSupportedException>(() => df.Columns["Double"].All()); 198Assert.Throws<NotSupportedException>(() => df.Columns["Double"].Any()); 199Assert.Throws<NotSupportedException>(() => df.Columns["Float"].All()); 200Assert.Throws<NotSupportedException>(() => df.Columns["Float"].Any()); 201Assert.Throws<NotSupportedException>(() => df.Columns["Int"].All()); 202Assert.Throws<NotSupportedException>(() => df.Columns["Int"].Any()); 203Assert.Throws<NotSupportedException>(() => df.Columns["Long"].All()); 204Assert.Throws<NotSupportedException>(() => df.Columns["Long"].Any()); 205Assert.Throws<NotSupportedException>(() => df.Columns["Sbyte"].All()); 206Assert.Throws<NotSupportedException>(() => df.Columns["Sbyte"].Any()); 207Assert.Throws<NotSupportedException>(() => df.Columns["Short"].All()); 208Assert.Throws<NotSupportedException>(() => df.Columns["Short"].Any()); 209Assert.Throws<NotSupportedException>(() => df.Columns["Uint"].All()); 210Assert.Throws<NotSupportedException>(() => df.Columns["Uint"].Any()); 211Assert.Throws<NotSupportedException>(() => df.Columns["Ulong"].All()); 212Assert.Throws<NotSupportedException>(() => df.Columns["Ulong"].Any()); 213Assert.Throws<NotSupportedException>(() => df.Columns["Ushort"].All()); 214Assert.Throws<NotSupportedException>(() => df.Columns["Ushort"].Any()); 215Assert.Throws<NotSupportedException>(() => df.Columns["DateTime"].All()); 216Assert.Throws<NotSupportedException>(() => df.Columns["DateTime"].Any()); 220df.Columns["DateTime"][0] = maxDate; 221DataFrameColumn dateTimeColumn = df.Columns["DateTime"].CumulativeMax(); 231df.Columns["Double"][0] = 100.0; 232DataFrameColumn doubleColumn = df.Columns["Double"].CumulativeMax(); 240Assert.Equal(1.0, df.Columns["Double"][1]); 241df.Columns["Double"].CumulativeMax(true); 242for (int i = 0; i < df.Columns["Double"].Length; i++) 245Assert.Null(df.Columns["Double"][i]); 247Assert.Equal(100.0, (double)df.Columns["Double"][i]); 250df.Columns["Float"][0] = -10.0f; 251DataFrameColumn floatColumn = df.Columns["Float"].CumulativeMin(); 259Assert.Equal(9.0f, df.Columns["Float"][9]); 260df.Columns["Float"].CumulativeMin(true); 261for (int i = 0; i < df.Columns["Float"].Length; i++) 264Assert.Null(df.Columns["Float"][i]); 266Assert.Equal(-10.0f, (float)df.Columns["Float"][i]); 269DataFrameColumn uintColumn = df.Columns["Uint"].CumulativeProduct(); 271Assert.Equal((uint)8, df.Columns["Uint"][8]); 272df.Columns["Uint"].CumulativeProduct(true); 273Assert.Equal((uint)0, df.Columns["Uint"][9]); 275DataFrameColumn ushortColumn = df.Columns["Ushort"].CumulativeSum(); 277Assert.Equal((ushort)9, df.Columns["Ushort"][9]); 278df.Columns["Ushort"].CumulativeSum(true); 279Assert.Equal((ushort)40, df.Columns["Ushort"][9]); 281Assert.Equal(100.0, df.Columns["Double"].Max()); 282Assert.Equal(-10.0f, df.Columns["Float"].Min()); 283Assert.Equal((uint)0, df.Columns["Uint"].Product()); 284Assert.Equal((ushort)130, df.Columns["Ushort"].Sum()); 286df.Columns["Double"][0] = 100.1; 287Assert.Equal(100.1, df.Columns["Double"][0]); 288DataFrameColumn roundColumn = df.Columns["Double"].Round(); 290Assert.Equal(100.1, df.Columns["Double"][0]); 291df.Columns["Double"].Round(true); 292Assert.Equal(100.0, df.Columns["Double"][0]); 295for (int i = 0; i < df.Columns.Count; i++) 297DataFrameColumn column = df.Columns[i]; 422var byteColumn = (PrimitiveDataFrameColumn<byte>)df.Columns["Byte"]; 423var decimalColumn = (PrimitiveDataFrameColumn<decimal>)df.Columns["Decimal"]; 424var doubleColumn = (PrimitiveDataFrameColumn<double>)df.Columns["Double"]; 425var floatColumn = (PrimitiveDataFrameColumn<float>)df.Columns["Float"]; 426var intColumn = (PrimitiveDataFrameColumn<int>)df.Columns["Int"]; 427var longColumn = (PrimitiveDataFrameColumn<long>)df.Columns["Long"]; 428var sbyteColumn = (PrimitiveDataFrameColumn<sbyte>)df.Columns["Sbyte"]; 429var shortColumn = (PrimitiveDataFrameColumn<short>)df.Columns["Short"]; 430var uintColumn = (PrimitiveDataFrameColumn<uint>)df.Columns["Uint"]; 431var ulongColumn = (PrimitiveDataFrameColumn<ulong>)df.Columns["Ulong"]; 432var ushortColumn = (PrimitiveDataFrameColumn<ushort>)df.Columns["Ushort"];

24Assert.Equal(2, dataFrame.Columns.Count); 25Assert.Equal("Int1", dataFrame.Columns[0].Name); 52df.Columns.Insert(0, dc0); 53var dc = df.Columns["a1"]; 64dataFrame.Columns.Insert(0, intColumn); 65dataFrame.Columns.Insert(1, floatColumn); 67Assert.Equal(2, dataFrame.Columns.Count); 68Assert.Equal(2, dataFrame.Columns.LongCount()); 69Assert.Equal(rowCount, dataFrame.Columns[0].Length); 70Assert.Equal("IntColumn", dataFrame.Columns[0].Name); 71Assert.Equal(rowCount, dataFrame.Columns[1].Length); 72Assert.Equal("FloatColumn", dataFrame.Columns[1].Name); 76Assert.Throws<ArgumentException>(() => dataFrame.Columns.Insert(2, bigColumn)); 77Assert.Throws<ArgumentException>(() => dataFrame.Columns.Add(bigColumn)); 81Assert.Throws<ArgumentException>(() => dataFrame.Columns.Insert(2, smallColumn)); 82Assert.Throws<ArgumentException>(() => dataFrame.Columns.Add(smallColumn)); 86Assert.Throws<ArgumentException>(() => dataFrame.Columns.Insert(2, repeatedName)); 90var columnCount = dataFrame.Columns.Count; 91Assert.Throws<ArgumentOutOfRangeException>(() => dataFrame.Columns.Insert(columnCount + 1, repeatedName)); 93Assert.Equal(2, dataFrame.Columns.Count); 95Assert.Throws<ArgumentException>(() => dataFrame.Columns[1] = intColumnCopy); 98dataFrame.Columns[1] = differentIntColumn; 99Assert.True(object.ReferenceEquals(differentIntColumn, dataFrame.Columns[1])); 101dataFrame.Columns.RemoveAt(1); 102Assert.Single(dataFrame.Columns); 103Assert.True(ReferenceEquals(intColumn, dataFrame.Columns[0])); 107Assert.Equal(2, dataFrame1.Columns.Count); 108Assert.Equal(intColumn, dataFrame1.Columns[0]); 109Assert.Equal(floatColumn, dataFrame1.Columns[1]); 118int columnCount = dataFrame.Columns.Count; 119DataFrameColumn originalLastColumn = dataFrame.Columns[columnCount - 1]; 122dataFrame.Columns.Insert(columnCount, intColumn); 123Assert.Equal(columnCount + 1, dataFrame.Columns.Count); 126dataFrame.Columns.RemoveAt(0); 127Assert.Equal(columnCount, dataFrame.Columns.Count); 130DataFrameColumn intColumn_1 = dataFrame.Columns["NewIntColumn"]; 134DataFrameColumn lastColumn_1 = dataFrame.Columns[originalLastColumn.Name]; 138int newIndex = dataFrame.Columns.IndexOf("NewIntColumn"); 142int newIndexForOriginalLastColumn = dataFrame.Columns.IndexOf(originalLastColumn.Name); 152dataFrame.Columns.Add(intColumn); 153Assert.Single(dataFrame.Columns); 156dataFrame.Columns.Remove(intColumn); 157Assert.Empty(dataFrame.Columns); 168dataFrame.Columns.Clear(); 171Assert.Empty(dataFrame.Columns); 174Assert.Equal(0, dataFrame.Columns.LongCount()); 205dataframe.Columns.RenameColumn("City", "Town"); 229df["Int3"] = df.Columns["Int1"] * 2 + df.Columns["Int2"]; 230Assert.Equal(16, df.Columns["Int3"][2]); 237df.Columns["Int"][0] = 100; 238df.Columns["Int"][19] = -1; 239df.Columns["Int"][5] = 2000; 243Assert.Null(sortedDf.Columns["Int"][19]); 244Assert.Equal(-1, sortedDf.Columns["Int"][0]); 245Assert.Equal(100, sortedDf.Columns["Int"][17]); 246Assert.Equal(2000, sortedDf.Columns["Int"][18]); 250Assert.Null(sortedDf.Columns["Int"][19]); 251Assert.Equal(-1, sortedDf.Columns["Int"][18]); 252Assert.Equal(100, sortedDf.Columns["Int"][1]); 253Assert.Equal(2000, sortedDf.Columns["Int"][0]); 257Assert.Null(sortedDf.Columns["Int"][0]); 258Assert.Equal(-1, sortedDf.Columns["Int"][1]); 259Assert.Equal(100, sortedDf.Columns["Int"][18]); 260Assert.Equal(2000, sortedDf.Columns["Int"][19]); 264Assert.Null(sortedDf.Columns["Int"][0]); 265Assert.Equal(-1, sortedDf.Columns["Int"][19]); 266Assert.Equal(100, sortedDf.Columns["Int"][2]); 267Assert.Equal(2000, sortedDf.Columns["Int"][1]); 271Assert.Null(sortedDf.Columns["Int"][19]); 272Assert.Equal(1, sortedDf.Columns["Int"][1]); 273Assert.Equal(8, sortedDf.Columns["Int"][17]); 274Assert.Equal(9, sortedDf.Columns["Int"][18]); 278Assert.Null(sortedDf.Columns["Int"][19]); 279Assert.Equal(8, sortedDf.Columns["Int"][1]); 280Assert.Equal(9, sortedDf.Columns["Int"][0]); 284Assert.Null(sortedDf.Columns["Int"][0]); 285Assert.Equal(1, sortedDf.Columns["Int"][2]); 286Assert.Equal(8, sortedDf.Columns["Int"][18]); 287Assert.Equal(9, sortedDf.Columns["Int"][19]); 291Assert.Null(sortedDf.Columns["Int"][0]); 292Assert.Equal(8, sortedDf.Columns["Int"][2]); 293Assert.Equal(9, sortedDf.Columns["Int"][1]); 302Assert.Equal((long)5, count.Columns["Int"][0]); 303Assert.Equal((long)4, count.Columns["Decimal"][1]); 306for (int c = 1; c < count.Columns.Count; c++) 308Assert.Equal((long)(r == 0 ? 5 : 4), count.Columns[c][r]); 316for (int c = 0; c < count.Columns.Count; c++) 318DataFrameColumn originalColumn = df.Columns[c]; 319DataFrameColumn firstColumn = first.Columns[originalColumn.Name]; 328for (int c = 0; c < count.Columns.Count; c++) 330DataFrameColumn originalColumn = df.Columns[c]; 331DataFrameColumn headColumn = head.Columns[originalColumn.Name]; 335for (int c = 0; c < count.Columns.Count; c++) 337DataFrameColumn originalColumn = df.Columns[c]; 340DataFrameColumn headColumn = head.Columns[originalColumn.Name]; 351for (int c = 0; c < count.Columns.Count; c++) 353DataFrameColumn originalColumn = df.Columns[c]; 354DataFrameColumn tailColumn = tail.Columns[originalColumn.Name]; 363for (int c = 0; c < count.Columns.Count; c++) 365DataFrameColumn originalColumn = df.Columns[c]; 368DataFrameColumn maxColumn = max.Columns[originalColumn.Name]; 386for (int c = 0; c < count.Columns.Count; c++) 388DataFrameColumn originalColumn = df.Columns[c]; 391DataFrameColumn minColumn = min.Columns[originalColumn.Name]; 394DataFrameColumn productColumn = product.Columns[originalColumn.Name]; 397DataFrameColumn sumColumn = sum.Columns[originalColumn.Name]; 403Assert.Equal(2, columnSum.Columns.Count); 404Assert.Equal(20, columnSum.Columns["Int"][0]); 405Assert.Equal(20, columnSum.Columns["Int"][1]); 407Assert.Equal(2, columnMax.Columns.Count); 408Assert.Equal(8, columnMax.Columns["Int"][0]); 409Assert.Equal(9, columnMax.Columns["Int"][1]); 411Assert.Equal(2, columnProduct.Columns.Count); 412Assert.Equal(0, columnProduct.Columns["Int"][0]); 413Assert.Equal(0, columnProduct.Columns["Int"][1]); 415Assert.Equal(2, columnMin.Columns.Count); 416Assert.Equal(0, columnMin.Columns["Int"][0]); 417Assert.Equal(1, columnMin.Columns["Int"][1]); 420Assert.Equal(2, countIntColumn.Columns.Count); 422Assert.Equal((long)5, countIntColumn.Columns["Int"][0]); 423Assert.Equal((long)4, countIntColumn.Columns["Int"][1]); 426Assert.Equal(2, firstDecimalColumn.Columns.Count); 428Assert.Equal((decimal)0, firstDecimalColumn.Columns["Decimal"][0]); 429Assert.Equal((decimal)1, firstDecimalColumn.Columns["Decimal"][1]); 484for (int i = 0; i < df.Columns.Count; i++) 486DataFrameColumn baseColumn = df.Columns[i]; 492Assert.Equal(10 * df.Columns.Count, totalValueCount); 496StringDataFrameColumn stringColumn = (StringDataFrameColumn)df.Columns["String"]; 511ArrowStringDataFrameColumn arrowStringColumn = (ArrowStringDataFrameColumn)df.Columns["ArrowString"]; 526SingleDataFrameColumn floatColumn = (SingleDataFrameColumn)df.Columns["Float"]; 541Int32DataFrameColumn intColumn = (Int32DataFrameColumn)df.Columns["Int"]; 562DataFrameColumn clamped = df.Columns["Int"].Clamp(3, 7); 564Assert.Equal(0, df.Columns["Int"][0]); 566Assert.Equal(1, df.Columns["Int"][1]); 568Assert.Equal(2, df.Columns["Int"][2]); 570Assert.Equal(3, df.Columns["Int"][3]); 572Assert.Equal(4, df.Columns["Int"][4]); 574Assert.Null(df.Columns["Int"][5]); 576Assert.Equal(6, df.Columns["Int"][6]); 578Assert.Equal(7, df.Columns["Int"][7]); 580Assert.Equal(8, df.Columns["Int"][8]); 582Assert.Equal(9, df.Columns["Int"][9]); 585df.Columns["Int"].Clamp(3, 7, true); 586Assert.Equal(3, df.Columns["Int"][0]); 587Assert.Equal(3, df.Columns["Int"][1]); 588Assert.Equal(3, df.Columns["Int"][2]); 589Assert.Equal(3, df.Columns["Int"][3]); 590Assert.Equal(4, df.Columns["Int"][4]); 591Assert.Null(df.Columns["Int"][5]); 592Assert.Equal(6, df.Columns["Int"][6]); 593Assert.Equal(7, df.Columns["Int"][7]); 594Assert.Equal(7, df.Columns["Int"][8]); 595Assert.Equal(7, df.Columns["Int"][9]); 608Assert.Equal(df.Columns.Count, clampedColumn.Columns.Count); 610for (int c = 0; c < df.Columns.Count; c++) 612DataFrameColumn column = clampedColumn.Columns[c]; 631var colD = df.Columns[c][i]; 633Assert.Equal(df.Columns[c][i], column[i]); 645Assert.Equal(i, df.Columns["Int"][i]); 647Assert.Null(df.Columns["Int"][5]); 707Assert.Equal(df.Columns.Count, sampled.Columns.Count); 711foreach (int? value in sampled.Columns["Int"]) 727DataFrameColumn descriptionColumn = description.Columns[0]; 733for (int i = 1; i < description.Columns.Count - 1; i++) 735DataFrameColumn column = description.Columns[i]; 736Assert.Equal(df.Columns[i - 1].Name, column.Name); 745DataFrameColumn dateTimeColumn = description.Columns[description.Columns.Count - 1]; 765df.Columns.Add(dateTimes); 768DataFrameColumn infoColumn = Info.Columns[0]; 773for (int i = 1; i < Info.Columns.Count; i++) 775DataFrameColumn column = Info.Columns[i]; 776Assert.Equal(df.Columns[i - 1].DataType.ToString(), column[0].ToString()); 800df.Columns.Insert(0, dataFrameColumn1); 804Assert.Throws<ArgumentException>(() => df.Columns.Insert(1, new Int32DataFrameColumn("Int2", Enumerable.Range(0, 5).Select(x => x)))); 859DataFrame valueCounts = df.Columns["Bool"].ValueCounts(); 861Assert.Equal((long)5, valueCounts.Columns["Counts"][0]); 862Assert.Equal((long)5, valueCounts.Columns["Counts"][1]); 870Int32DataFrameColumn column = df.Columns["Int1"] as Int32DataFrameColumn; 915Int32DataFrameColumn intColumn = intDf.Columns["Int1"] as Int32DataFrameColumn; 918Assert.Equal(df.Columns.Count, clone.Columns.Count); 919for (int i = 0; i < df.Columns.Count; i++) 921DataFrameColumn dfColumn = df.Columns[i]; 922DataFrameColumn cloneColumn = clone.Columns[i]; 934BooleanDataFrameColumn bigInts = new BooleanDataFrameColumn("BigInts", df.Columns["Int"].ElementwiseGreaterThan(5)); 948IReadOnlyList<DataFrameColumn> columns = df.Columns; 950Assert.Equal(columns.Count, df.Columns.Count); 953Assert.Equal(dataFrameColumn, df.Columns[i++]); 973Assert.Equal(df.Columns[columnIndex][rowCount], value); 981int intColumnIndex = df.Columns.IndexOf("Int"); 982Assert.Equal(1, df.Columns[intColumnIndex].NullCount); 984Assert.Equal(0, df.Columns[intColumnIndex].NullCount); 986Assert.Equal(1, df.Columns[intColumnIndex].NullCount); 997for (int i = 0; i < df.Columns.Count; i++) 999DataFrameColumn column = df.Columns[i]; 1004foreach (var column in df.Columns) 1019Assert.Equal(1, df.Columns[0].NullCount); 1020Assert.Equal(1, df.Columns[1].NullCount); 1024Assert.Equal(1, df.Columns[0].NullCount); 1025Assert.Equal(1, df.Columns[1].NullCount); 1032Assert.Equal(2, ret.Columns[0].NullCount); 1033Assert.Equal(2, ret.Columns[1].NullCount); 1037for (int j = 0; j < check1.Columns.Count; j++) 1072Assert.Equal(3, resultDataFrame.Columns.Count); 1091Assert.Equal(1, df.Columns[0].NullCount); 1092Assert.Equal(1, df.Columns[1].NullCount); 1096Assert.Equal(1, ret.Columns[0].NullCount); 1097Assert.Equal(1, ret.Columns[1].NullCount); 1101Assert.Equal(1, df.Columns[0].NullCount); 1102Assert.Equal(2, df.Columns[1].NullCount); 1106Assert.Equal(1, ret.Columns[0].NullCount); 1107Assert.Equal(3, ret.Columns[1].NullCount); 1111Assert.Equal(2, df.Columns[0].NullCount); 1112Assert.Equal(3, df.Columns[1].NullCount); 1115Assert.Equal(3, ret.Columns[0].NullCount); 1116Assert.Equal(4, ret.Columns[1].NullCount); 1120Assert.Equal(2, df.Columns[0].NullCount); 1121Assert.Equal(3, df.Columns[1].NullCount); 1124Assert.Equal(2, ret.Columns[0].NullCount); 1125Assert.Equal(3, ret.Columns[1].NullCount); 1130Assert.Equal(15, df.Columns["Column1"].Length); 1131Assert.Equal(15, df.Columns["Column2"].Length); 1132Assert.Equal(2, df.Columns[0].NullCount); 1133Assert.Equal(4, df.Columns[1].NullCount); 1137Assert.Equal(16, ret.Columns["Column1"].Length); 1138Assert.Equal(16, ret.Columns["Column2"].Length); 1139Assert.Equal(2, ret.Columns[0].NullCount); 1140Assert.Equal(5, ret.Columns[1].NullCount); 1144Assert.Equal(16, df.Columns["Column1"].Length); 1145Assert.Equal(16, df.Columns["Column2"].Length); 1146Assert.Equal(3, df.Columns[0].NullCount); 1147Assert.Equal(4, df.Columns[1].NullCount); 1150Assert.Equal(17, ret.Columns["Column1"].Length); 1151Assert.Equal(17, ret.Columns["Column2"].Length); 1152Assert.Equal(4, ret.Columns[0].NullCount); 1153Assert.Equal(4, ret.Columns[1].NullCount); 1157Assert.Equal(17, df.Columns["Column1"].Length); 1158Assert.Equal(17, df.Columns["Column2"].Length); 1159Assert.Equal(4, df.Columns[0].NullCount); 1160Assert.Equal(5, df.Columns[1].NullCount); 1163Assert.Equal(18, ret.Columns["Column1"].Length); 1164Assert.Equal(18, ret.Columns["Column2"].Length); 1165Assert.Equal(5, ret.Columns[0].NullCount); 1166Assert.Equal(6, ret.Columns[1].NullCount); 1175Assert.Equal(18, df.Columns["Column1"].Length); 1176Assert.Equal(18, df.Columns["Column2"].Length); 1177Assert.Equal(5, df.Columns[0].NullCount); 1178Assert.Equal(6, df.Columns[1].NullCount); 1182Assert.Equal(18, df.Columns["Column1"].Length); 1183Assert.Equal(18, df.Columns["Column2"].Length); 1184Assert.Equal(5, df.Columns[0].NullCount); 1185Assert.Equal(6, df.Columns[1].NullCount); 1187Assert.Equal(19, ret.Columns["Column1"].Length); 1188Assert.Equal(19, ret.Columns["Column2"].Length); 1189Assert.Equal(6, ret.Columns[0].NullCount); 1190Assert.Equal(7, ret.Columns[1].NullCount); 1199Assert.Equal(2, df.Columns[0].NullCount); 1200Assert.Equal(1, df.Columns[1].NullCount); 1203df.Columns.Add(column); 1207Assert.Equal(2, df.Columns[0].NullCount); 1208Assert.Equal(1, df.Columns[1].NullCount); 1209Assert.Equal(0, df.Columns[2].NullCount); 1213Assert.Equal(1, df.Columns[2].NullCount); 1278PrimitiveDataFrameColumn<int> primitiveInts = dataFrame.Columns.GetPrimitiveColumn<int>("Int"); 1280Assert.Throws<ArgumentException>(() => dataFrame.Columns.GetPrimitiveColumn<float>("Int")); 1282StringDataFrameColumn strings = dataFrame.Columns.GetStringColumn("String"); 1284Assert.Throws<ArgumentException>(() => dataFrame.Columns.GetStringColumn("ArrowString")); 1286ArrowStringDataFrameColumn arrowStrings = dataFrame.Columns.GetArrowStringColumn("ArrowString"); 1288Assert.Throws<ArgumentException>(() => dataFrame.Columns.GetArrowStringColumn("String")); 1290ByteDataFrameColumn bytes = dataFrame.Columns.GetByteColumn("Byte"); 1292Assert.Throws<ArgumentException>(() => dataFrame.Columns.GetSingleColumn("Byte")); 1294Int32DataFrameColumn ints = dataFrame.Columns.GetInt32Column("Int"); 1296Assert.Throws<ArgumentException>(() => dataFrame.Columns.GetSingleColumn("Int")); 1298BooleanDataFrameColumn bools = dataFrame.Columns.GetBooleanColumn("Bool"); 1300Assert.Throws<ArgumentException>(() => dataFrame.Columns.GetSingleColumn("Bool")); 1302CharDataFrameColumn chars = dataFrame.Columns.GetCharColumn("Char"); 1304Assert.Throws<ArgumentException>(() => dataFrame.Columns.GetSingleColumn("Char")); 1306DecimalDataFrameColumn decimals = dataFrame.Columns.GetDecimalColumn("Decimal"); 1308Assert.Throws<ArgumentException>(() => dataFrame.Columns.GetSingleColumn("Decimal")); 1310DoubleDataFrameColumn doubles = dataFrame.Columns.GetDoubleColumn("Double"); 1312Assert.Throws<ArgumentException>(() => dataFrame.Columns.GetSingleColumn("Double")); 1314SingleDataFrameColumn singles = dataFrame.Columns.GetSingleColumn("Float"); 1316Assert.Throws<ArgumentException>(() => dataFrame.Columns.GetDoubleColumn("Float")); 1318Int64DataFrameColumn longs = dataFrame.Columns.GetInt64Column("Long"); 1320Assert.Throws<ArgumentException>(() => dataFrame.Columns.GetSingleColumn("Long")); 1322SByteDataFrameColumn sbytes = dataFrame.Columns.GetSByteColumn("Sbyte"); 1324Assert.Throws<ArgumentException>(() => dataFrame.Columns.GetSingleColumn("Sbyte")); 1326Int16DataFrameColumn shorts = dataFrame.Columns.GetInt16Column("Short"); 1328Assert.Throws<ArgumentException>(() => dataFrame.Columns.GetSingleColumn("Short")); 1330UInt32DataFrameColumn uints = dataFrame.Columns.GetUInt32Column("Uint"); 1332Assert.Throws<ArgumentException>(() => dataFrame.Columns.GetSingleColumn("Uint")); 1334UInt64DataFrameColumn ulongs = dataFrame.Columns.GetUInt64Column("Ulong"); 1336Assert.Throws<ArgumentException>(() => dataFrame.Columns.GetSingleColumn("Ulong")); 1338UInt16DataFrameColumn ushorts = dataFrame.Columns.GetUInt16Column("Ushort"); 1340Assert.Throws<ArgumentException>(() => dataFrame.Columns.GetSingleColumn("Ushort")); 1368Assert.True(filteredNullDf.Columns.IndexOf("col") >= 0); 1369Assert.Equal(3, filteredNullDf.Columns["col"].Length); 1371Assert.Equal("One", filteredNullDf.Columns["col"][0]); 1372Assert.Equal("Two", filteredNullDf.Columns["col"][1]); 1373Assert.Equal("Three", filteredNullDf.Columns["col"][2]); 1385Assert.True(filteredNullDf.Columns.IndexOf("col") >= 0); 1386Assert.True(filteredNullDf.Columns.IndexOf("index") >= 0); 1390Assert.Equal(2, filteredNullDf.Columns["index"][0]); 1391Assert.Equal(5, filteredNullDf.Columns["index"][1]);

20DataFrameColumn filtered = df.Columns["Int"].Filter(3, 7); 32DataFrame boolColumnFiltered = df[df.Columns["Bool"].ElementwiseEquals(true)]; 35for (int i = 0; i < boolColumnFiltered.Columns.Count; i++) 37DataFrameColumn column = boolColumnFiltered.Columns[i]; 48Assert.Equal(intEnumerableFiltered.Columns.Count, df.Columns.Count); 49Assert.Equal(boolEnumerableFiltered.Columns.Count, df.Columns.Count); 50Assert.Equal(longEnumerableFiltered.Columns.Count, df.Columns.Count); 51for (int i = 0; i < intEnumerableFiltered.Columns.Count; i++) 53DataFrameColumn intFilteredColumn = intEnumerableFiltered.Columns[i]; 54DataFrameColumn dfColumn = df.Columns[i]; 55DataFrameColumn boolFilteredColumn = boolEnumerableFiltered.Columns[i]; 56DataFrameColumn longFilteredColumn = longEnumerableFiltered.Columns[i];

26Assert.Equal(join.Columns.Count, left.Columns.Count + right.Columns.Count); 27Assert.Null(join.Columns["Int_right"][6]); 33Assert.Equal(join.Columns.Count, left.Columns.Count + right.Columns.Count); 34Assert.Equal(join.Columns["Int_right"][3], right.Columns["Int"][3]); 35Assert.Null(join.Columns["Int_right"][2]); 41Assert.Equal(join.Columns.Count, left.Columns.Count + right.Columns.Count); 42Assert.Null(join.Columns["Int_right"][6]); 48Assert.Equal(join.Columns.Count, left.Columns.Count + right.Columns.Count); 49Assert.Equal(join.Columns["Int_right"][3], right.Columns["Int"][3]); 50Assert.Null(join.Columns["Int_right"][2]); 58Assert.Equal(join.Columns.Count, left.Columns.Count + right.Columns.Count); 59Assert.Equal(join.Columns["Int_right"][6], right.Columns["Int"][6]); 65Assert.Equal(join.Columns.Count, left.Columns.Count + right.Columns.Count); 66Assert.Equal(join.Columns["Int_right"][2], right.Columns["Int"][2]); 67Assert.Null(join.Columns["Int_left"][12]); 73Assert.Equal(join.Columns.Count, left.Columns.Count + right.Columns.Count); 74Assert.Null(join.Columns["Int_left"][12]); 80Assert.Equal(join.Columns.Count, left.Columns.Count + right.Columns.Count); 81Assert.Equal(join.Columns["Int_right"][2], right.Columns["Int"][2]); 92for (int i = 0; i < join.Columns.Count; i++) 94DataFrameColumn joinColumn = join.Columns[i]; 99if (i < left.Columns.Count) 101DataFrameColumn leftColumn = left.Columns[i]; 106int columnIndex = i - left.Columns.Count; 107DataFrameColumn rightColumn = right.Columns[columnIndex]; 114if (i < left.Columns.Count) 116DataFrameColumn leftColumn = left.Columns[i]; 122int columnIndex = i - left.Columns.Count; 123DataFrameColumn rightColumn = right.Columns[columnIndex]; 129if (i < left.Columns.Count) 131DataFrameColumn leftColumn = left.Columns[i]; 136int columnIndex = i - left.Columns.Count; 137DataFrameColumn rightColumn = right.Columns[columnIndex]; 143if (i < left.Columns.Count) 145DataFrameColumn leftColumn = left.Columns[i]; 150int columnIndex = i - left.Columns.Count; 151DataFrameColumn rightColumn = right.Columns[columnIndex];

23left.Columns.Insert(left.Columns.Count, leftStringColumn); 27right.Columns.Insert(right.Columns.Count, rightStringColumn); 31Assert.Equal("Left", (string)merge.Columns["String_left"][0]); 32Assert.Equal("Right", (string)merge.Columns["String_right"][0]); 45Assert.Equal(merge.Columns.Count, left.Columns.Count + right.Columns.Count); 46Assert.Null(merge.Columns["Int_right"][6]); 47Assert.Null(merge.Columns["Int_left"][5]); 53Assert.Equal(merge.Columns.Count, left.Columns.Count + right.Columns.Count); 54Assert.Equal(merge.Columns["Int_right"][3], right.Columns["Int"][3]); 55Assert.Null(merge.Columns["Int_right"][2]); 61Assert.Equal(merge.Columns.Count, left.Columns.Count + right.Columns.Count); 62Assert.Null(merge.Columns["Int_right"][6]); 68Assert.Equal(merge.Columns.Count, left.Columns.Count + right.Columns.Count); 69Assert.Equal(merge.Columns["Int_right"][2], right.Columns["Int"][3]); 70Assert.Null(merge.Columns["Int_right"][4]); 78Assert.Equal(merge.Columns.Count, left.Columns.Count + right.Columns.Count); 79Assert.Equal(merge.Columns["Int_right"][6], right.Columns["Int"][6]); 85Assert.Equal(merge.Columns.Count, left.Columns.Count + right.Columns.Count); 86Assert.Equal(merge.Columns["Int_right"][2], right.Columns["Int"][2]); 87Assert.Null(merge.Columns["Int_left"][12]); 93Assert.Equal(merge.Columns.Count, left.Columns.Count + right.Columns.Count); 94Assert.Null(merge.Columns["Int_left"][12]); 95Assert.Null(merge.Columns["Int_left"][15]); 101Assert.Equal(merge.Columns.Count, left.Columns.Count + right.Columns.Count); 102Assert.Equal(merge.Columns["Int_right"][2], right.Columns["Int"][2]); 108Assert.Equal(merge.Columns.Count, left.Columns.Count + right.Columns.Count); 114if (columnIndex < left.Columns.Count) 123int rightColumnIndex = columnIndex - left.Columns.Count; 152Assert.Equal(merge.Columns.Count, left.Columns.Count + right.Columns.Count); 210Assert.Equal(merge.Columns.Count, left.Columns.Count + right.Columns.Count); 260Assert.Equal(merge.Columns.Count, left.Columns.Count + right.Columns.Count); 299left.Columns.Add(new Int32DataFrameColumn("Index", new[] { 0, 1, 2, 3, 4, 5 })); 300left.Columns.Add(new Int32DataFrameColumn("G1", new[] { 0, 1, 1, 2, 2, 3 })); 301left.Columns.Add(new Int32DataFrameColumn("G2", new[] { 3, 1, 2, 1, 2, 1 })); 304right.Columns.Add(new Int32DataFrameColumn("Index", new[] { 0, 1, 2, 3 })); 305right.Columns.Add(new Int32DataFrameColumn("G1", new[] { 1, 1, 1, 2 })); 306right.Columns.Add(new Int32DataFrameColumn("G2", new[] { 1, 2, 1, 1 })); 349Assert.Equal(merge.Columns.Count, left.Columns.Count + right.Columns.Count); 365left.Columns.Add(new Int32DataFrameColumn("Index", new[] { 0, 1, 2 })); 366left.Columns.Add(new Int32DataFrameColumn("G1", new[] { 1, 1, 3 })); 367left.Columns.Add(new Int32DataFrameColumn("G2", new[] { 1, 1, 3 })); 370right.Columns.Add(new Int32DataFrameColumn("Index", new[] { 0, 1, 2 })); 371right.Columns.Add(new Int32DataFrameColumn("G1", new[] { 1, 1, 0 })); 372right.Columns.Add(new Int32DataFrameColumn("G2", new[] { 1, 1, 0 })); 408Assert.Equal(merge.Columns.Count, left.Columns.Count + right.Columns.Count); 423left.Columns.Add(new Int32DataFrameColumn("Index", new[] { 0, 1, 2 })); 424left.Columns.Add(new Int32DataFrameColumn("G1", new[] { 1, 1, 3 })); 425left.Columns.Add(new Int32DataFrameColumn("G2", new[] { 1, 1, 3 })); 428right.Columns.Add(new Int32DataFrameColumn("Index", new[] { 0, 1, 2 })); 429right.Columns.Add(new Int32DataFrameColumn("G1", new[] { 1, 1, 0 })); 430right.Columns.Add(new Int32DataFrameColumn("G2", new[] { 1, 1, 0 })); 466Assert.Equal(merge.Columns.Count, left.Columns.Count + right.Columns.Count); 481left.Columns.Add(new Int32DataFrameColumn("Index", new[] { 0, 1, 2 })); 482left.Columns.Add(new Int32DataFrameColumn("G1", new[] { 1, 1, 3 })); 483left.Columns.Add(new Int32DataFrameColumn("G2", new[] { 1, 1, 3 })); 486right.Columns.Add(new Int32DataFrameColumn("Index", new[] { 0, 1, 2 })); 487right.Columns.Add(new Int32DataFrameColumn("G1", new[] { 1, 1, 0 })); 488right.Columns.Add(new Int32DataFrameColumn("G2", new[] { 1, 1, 0 })); 522Assert.Equal(merge.Columns.Count, left.Columns.Count + right.Columns.Count); 537left.Columns.Add(new Int32DataFrameColumn("Index", new[] { 0, 1, 2 })); 538left.Columns.Add(new Int32DataFrameColumn("G1", new[] { 1, 1, 3 })); 539left.Columns.Add(new Int32DataFrameColumn("G2", new[] { 1, 1, 3 })); 542right.Columns.Add(new Int32DataFrameColumn("Index", new[] { 0, 1, 2 })); 543right.Columns.Add(new Int32DataFrameColumn("G1", new[] { 1, 1, 0 })); 544right.Columns.Add(new Int32DataFrameColumn("G2", new[] { 1, 1, 0 })); 582Assert.Equal(merge.Columns.Count, left.Columns.Count + right.Columns.Count); 597left.Columns.Add(new Int32DataFrameColumn("Index", new[] { 0, 1, 2 })); 598left.Columns.Add(new Int32DataFrameColumn("G1", new[] { 1, 1, 2 })); 599left.Columns.Add(new Int32DataFrameColumn("G2", new[] { 1, 2, 1 })); 600left.Columns.Add(new StringDataFrameColumn("G3", new[] { "A", "B", "C" })); 603right.Columns.Add(new Int32DataFrameColumn("Index", new[] { 0, 1, 2 })); 604right.Columns.Add(new Int32DataFrameColumn("G1", new[] { 0, 1, 1 })); 605right.Columns.Add(new Int32DataFrameColumn("G2", new[] { 1, 1, 2 })); 606right.Columns.Add(new StringDataFrameColumn("G3", new[] { "Z", "Y", "B" })); 638Assert.Equal(merge.Columns.Count, left.Columns.Count + right.Columns.Count); 653left.Columns.Add(new Int32DataFrameColumn("Index", new[] { 0, 1, 2 })); 654left.Columns.Add(new Int32DataFrameColumn("G1", new[] { 1, 1, 2 })); 655left.Columns.Add(new Int32DataFrameColumn("G2", new[] { 1, 2, 1 })); 656left.Columns.Add(new StringDataFrameColumn("G3", new[] { "A", "B", "C" })); 659right.Columns.Add(new Int32DataFrameColumn("Index", new[] { 0, 1, 2 })); 660right.Columns.Add(new Int32DataFrameColumn("G1", new[] { 0, 1, 1 })); 661right.Columns.Add(new Int32DataFrameColumn("G2", new[] { 1, 1, 2 })); 662right.Columns.Add(new StringDataFrameColumn("G3", new[] { "Z", "Y", "B" })); 694Assert.Equal(merge.Columns.Count, left.Columns.Count + right.Columns.Count); 711Assert.Equal(0, (int)merge.Columns["Int_left"][0]); 712Assert.Equal(1, (int)merge.Columns["Int_left"][1]); 726Assert.NotNull(merge.Columns.GetBooleanColumn("Bool_left")); 727Assert.NotNull(merge.Columns.GetBooleanColumn("Bool_right")); 729Assert.NotNull(merge.Columns.GetDecimalColumn("Decimal_left")); 730Assert.NotNull(merge.Columns.GetDecimalColumn("Decimal_right")); 732Assert.NotNull(merge.Columns.GetSingleColumn("Float_left")); 733Assert.NotNull(merge.Columns.GetSingleColumn("Float_right")); 735Assert.NotNull(merge.Columns.GetDoubleColumn("Double_left")); 736Assert.NotNull(merge.Columns.GetDoubleColumn("Double_right")); 738Assert.NotNull(merge.Columns.GetByteColumn("Byte_left")); 739Assert.NotNull(merge.Columns.GetByteColumn("Byte_right")); 741Assert.NotNull(merge.Columns.GetCharColumn("Char_left")); 742Assert.NotNull(merge.Columns.GetCharColumn("Char_right")); 744Assert.NotNull(merge.Columns.GetInt16Column("Short_left")); 745Assert.NotNull(merge.Columns.GetInt16Column("Short_right")); 747Assert.NotNull(merge.Columns.GetUInt16Column("Ushort_left")); 748Assert.NotNull(merge.Columns.GetUInt16Column("Ushort_right")); 750Assert.NotNull(merge.Columns.GetInt32Column("Int_left")); 751Assert.NotNull(merge.Columns.GetInt32Column("Int_right")); 753Assert.NotNull(merge.Columns.GetUInt32Column("Uint_left")); 754Assert.NotNull(merge.Columns.GetUInt32Column("Uint_right")); 756Assert.NotNull(merge.Columns.GetInt64Column("Long_left")); 757Assert.NotNull(merge.Columns.GetInt64Column("Long_right")); 759Assert.NotNull(merge.Columns.GetUInt64Column("Ulong_left")); 760Assert.NotNull(merge.Columns.GetUInt64Column("Ulong_right")); 762Assert.NotNull(merge.Columns.GetDateTimeColumn("DateTime_left")); 763Assert.NotNull(merge.Columns.GetDateTimeColumn("DateTime_right")); 771for (int i = 0; i < merge.Columns["Int_left"].Length; i++) 773if (merge.Columns["Int_left"][i] == null) 775intersection.Add((int)merge.Columns["Int_left"][i]); 777for (int i = 0; i < left.Columns["Int"].Length; i++) 779if (left.Columns["Int"][i] != null && intersection.Contains((int)left.Columns["Int"][i])) 780intersection.Remove((int)left.Columns["Int"][i]); 787for (int i = 0; i < merge.Columns["Int_right"].Length; i++) 789if (merge.Columns["Int_right"][i] == null) 791intersection.Add((int)merge.Columns["Int_right"][i]); 793for (int i = 0; i < right.Columns["Int"].Length; i++) 795if (right.Columns["Int"][i] != null && intersection.Contains((int)right.Columns["Int"][i])) 796intersection.Remove((int)right.Columns["Int"][i]);

20df.Columns["Int"][0] = 100000; 21df.Columns["Int"][df.Rows.Count - 1] = -1; 22df.Columns["Int"][5] = 200000; 28Assert.Null(sortedDf.Columns["Int"][sortedDf.Rows.Count - 1]); 29Assert.Equal(1, sortedDf.Columns["Int"][0]); 30Assert.Equal(100000, sortedDf.Columns["Int"][sortedDf.Rows.Count - 3]); 31Assert.Equal(200000, sortedDf.Columns["Int"][sortedDf.Rows.Count - 2]); 119for (int i = 0; i < sortedDataFrame.Columns.Count; i++) 121string columnName = sortedDataFrame.Columns[i].Name;

27dataFrame.Columns.Insert(0, dataFrameColumn1); 28dataFrame.Columns.Insert(1, dataFrameColumn2); 88df.Columns.Insert(df.Columns.Count, vBufferColumn); 97df.Columns.Insert(df.Columns.Count, arrowStringColumn); 106df.Columns.Insert(df.Columns.Count, boolColumn); 118df.Columns.Insert(df.Columns.Count, boolColumn); 130df.Columns.Insert(df.Columns.Count, stringColumn); 137df.Columns.Insert(df.Columns.Count, charColumn); 151df.Columns.Insert(df.Columns.Count, dateTimeColumn); 194for (var i = 0; i < dataFrame.Columns.Count; i++) 196dataFrame.Columns[i][length / 2] = null; 213for (int i = 0; i < dataFrame.Columns.Count; i++) 215dataFrame.Columns[i][length / 2] = null;

497Assert.True(filteredNullDf.Columns.IndexOf("col") >= 0); 498Assert.Equal(3, filteredNullDf.Columns["col"].Length); 500Assert.Equal(1.23, filteredNullDf.Columns["col"][0]); 501Assert.Equal(2.0, filteredNullDf.Columns["col"][1]); 502Assert.Equal(3.0, filteredNullDf.Columns["col"][2]); 514Assert.True(filteredNullDf.Columns.IndexOf("col") >= 0); 515Assert.True(filteredNullDf.Columns.IndexOf("index") >= 0); 519Assert.Equal(2, filteredNullDf.Columns["index"][0]); 520Assert.Equal(5, filteredNullDf.Columns["index"][1]);