Count

DnnAnalyzer.cs (1)

35for (int i = 0; i < schema.Count; i++)

DataFrame.IDataView.cs (2)

45var activeColumns = new bool[DataViewSchema.Count]; 82_getters = new Delegate[Schema.Count];

IDataView.Extension.cs (1)

48List<DataFrameColumn> dataFrameColumns = new List<DataFrameColumn>(schema.Count);

DataFrameIDataViewTests.cs (5)

104Assert.Equal(15, schema.Count); 108Assert.Equal(14, schema.Count); 113Assert.Equal(15, schema.Count); 258Assert.Equal(dfAsIDataView.Schema.Count, newDf.Columns.Count); 308Assert.Equal(dfAsIDataView.Schema.Count, newDf.Columns.Count);

ColumnInference\PurposeInference.cs (1)

248for (var i = 0; i < data.Schema.Count; i++)

DatasetDimensions\DatasetDimensionsApi.cs (2)

17var colDimensions = new ColumnDimensions[data.Schema.Count]; 19for (var i = 0; i < data.Schema.Count; i++)

Utils\DatasetColumnInfo.cs (1)

31var cols = new DatasetColumnInfo[data.Schema.Count];

Utils\UserInputValidationUtil.cs (2)

200throw new ArgumentException($"{schemaMismatchError} Train data has '{trainData.Schema.Count}' columns," + 201$"and validation data has '{validationData.Schema.Count}' columns.", nameof(validationData));

AutoFitTests.cs (3)

628Assert.Equal(31, resFull.Schema.Count); 629Assert.Equal(31, resTrainTest.Schema.Count); 630Assert.Equal(31, resCV.Schema.Count);

Data\AnnotationUtils.cs (3)

224for (int col = 0; col < schema.Count; col++) 248for (int col = 0; col < schema.Count; col++) 267for (int col = 0; col < schema.Count; col++)

Data\IEstimator.cs (1)

183for (int iCol = 0; iCol < schema.Count; iCol++)

Data\LinkedRowRootCursorBase.cs (2)

27Ch.Check(active == null || active.Length == schema.Count); 37Ch.Check(column.Index < Schema.Count);

Utilities\Utils.cs (3)

770Contracts.Check(schema.Count > 0, nameof(schema)); 774invMap = new int[schema.Count]; 775for (int c = 0; c < schema.Count; ++c)

UnitTests\CoreBaseTestClass.cs (8)

197Contracts.Assert(view1.Schema.Count == view2.Schema.Count); 246Contracts.Assert(curs1.Schema.Count == curs2.Schema.Count); 249int colLim = curs1.Schema.Count; 326Contracts.Assert(curs1.Schema.Count == view2.Schema.Count); 329int colLim = curs1.Schema.Count;

UnitTests\ScoreSchemaTest.cs (2)

58Assert.Equal(3, scoreMetadata.Schema.Count); 115Assert.Equal(2, scoreMetadata.Schema.Count);

UnitTests\TestEntryPoints.cs (5)

146Assert.Equal(4, scored1.Schema.Count); 1520Assert.Equal(4, scored1.Schema.Count); 4846Assert.Equal(5, schema.Count); 4848for (int i = 0; i < schema.Count; i++) 6574Assert.Equal(3, schema.Count);

UnitTests\TestModelLoad.cs (2)

32Assert.Equal(2, result.Schema.Count); 50Assert.Equal(3, result.Schema.Count);

Commands\DataCommand.cs (1)

163for (int currentIndex = 0; currentIndex < cursor.Schema.Count; currentIndex++)

Commands\SaveDataCommand.cs (2)

146for (int i = 0; i < data.Schema.Count; i++) 208for (int i = 0; i < view.Schema.Count; i++)

Commands\ScoreCommand.cs (1)

184for (int i = 0; i < loader.Schema.Count; i++)

Commands\ShowSchemaCommand.cs (6)

130int colLim = schema.Count; 187Contracts.Assert(0 <= col && col < schema.Count); 211Contracts.Assert(0 <= col && col < schema.Count); 231Contracts.Assert(0 <= col && col < schema.Count); 251Contracts.Assert(0 <= col && col < schema.Count); 270Contracts.Assert(0 <= col && col < schema.Count);

Data\DataViewUtils.cs (10)

181for (int col = 0; col < schema.Count; col++) 240for (int c = 0; c < schema.Count; ++c) 318_cachePools = new object[_schema.Count + (int)ExtraIndex._Lim]; 348if (Utils.Size(ourPools) != schema.Count) 349ourPools = new object[schema.Count + (int)ExtraIndex._Lim]; 536ch.Assert(0 <= activeToCol[c] && activeToCol[c] < _schema.Count); 643Contracts.Assert(0 <= col && col < _schema.Count); 653return CreateInPipeCore(_schema.Count + (int)ExtraIndex.Id, input.GetIdGetter()); 1037Ch.Assert(colToActive.Length == schema.Count); 1255Ch.Assert(col < cursor.Schema.Count);

Data\RowCursorUtils.cs (14)

DataDebuggerPreview.cs (2)

37int n = data.Schema.Count; 66=> $"{Schema.Count} columns, {RowView.Length} rows";

DataLoadSave\Binary\BinaryLoader.cs (3)

786_host.Assert(_outputSchema.Count == Utils.Size(_aliveColumns)); 874ch.Assert(_outputSchema.Count == Utils.Size(_aliveColumns)); 990var cols = Enumerable.Range(0, schema.Count)

DataLoadSave\Binary\BinarySaver.cs (1)

265_host.Assert(0 <= col && col < schema.Count);

DataLoadSave\Database\DatabaseLoader.cs (1)

723var active = Utils.BuildArray(_loader._bindings.OutputSchema.Count, columnsNeeded);

DataLoadSave\Database\DatabaseLoaderCursor.cs (2)

38Ch.Assert(active == null || active.Length == parent._bindings.OutputSchema.Count); 100Contracts.Assert(active == null || active.Length == parent._bindings.OutputSchema.Count);

DataLoadSave\LegacyCompositeDataLoader.cs (1)

605_host.CheckParam(0 <= col && col < Schema.Count, nameof(col));

DataLoadSave\Text\TextLoader.cs (2)

1665var active = Utils.BuildArray(_loader._bindings.OutputSchema.Count, columnsNeeded); 1672var active = Utils.BuildArray(_loader._bindings.OutputSchema.Count, columnsNeeded);

DataLoadSave\Text\TextLoaderCursor.cs (4)

51Contracts.Assert(active == null || active.Length == parent._bindings.OutputSchema.Count); 89Ch.Assert(active == null || active.Length == parent._bindings.OutputSchema.Count); 143Contracts.Assert(active == null || active.Length == parent._bindings.OutputSchema.Count); 160Contracts.Assert(active == null || active.Length == parent._bindings.OutputSchema.Count);

DataLoadSave\Text\TextSaver.cs (1)

401ch.Check(0 <= cols[i] && cols[i] < data.Schema.Count);

DataLoadSave\Transpose\TransposeLoader.cs (10)

254Host.CheckDecode(schema.Count == _parent._header.ColumnCount); 273Host.Assert(0 <= col && col < parent.Schema.Count); 296Host.CheckDecode(schema.Count == 1); 473ColumnCount = schemaView.Schema.Count 553env.Assert(Enumerable.Range(0, schema.Count).All(c => saver.IsColumnSavable(schema[c].Type))); 554ctx.SaveBinaryStream("Schema.idv", w => saver.SaveData(w.BaseStream, noRows, Utils.GetIdentityPermutation(schema.Count))); 681Ch.Assert(cursor.Schema.Count == 1); 733_host.Assert(view.Schema.Count == 1); 736_host.Assert(trans.Schema.Count == 1); 796Ch.Assert(0 <= col && col < Schema.Count);

DataLoadSave\Transpose\TransposeSaver.cs (1)

136_internalSaver.SaveData(substream, view, Utils.GetIdentityPermutation(view.Schema.Count));

DataView\AppendRowsDataView.cs (4)

110int colCount = Schema.Count; 113_host.Check(_sources.All(source => source.Schema.Count == colCount), errMsg); 177Getters = new Delegate[Schema.Count]; 206Ch.Check(column.Index < Schema.Count, "Column index is out of range");

DataView\ArrayDataViewBuilder.cs (5)

270Ch.Assert(view.Schema.Count >= 0); 273_active = new BitArray(view.Schema.Count); 278for (int i = 0; i < view.Schema.Count; ++i) 312Ch.Check(column.Index < Schema.Count); 325Ch.Check(column.Index < Schema.Count);

DataView\BatchDataViewMapperBase.cs (1)

142Ch.Check(column.Index < _parent.SchemaBindings.AsSchema.Count);

DataView\CacheDataView.cs (10)

100_caches = new ColumnCache[_subsetInput.Schema.Count]; 126if (prefetch.Length > 0 && (prefetch[0] < 0 || prefetch[prefetch.Length - 1] >= schema.Count)) 132for (int c = 0; c < schema.Count; ++c) 140inputToSubset = new int[schema.Count]; 184int inputIndexLim = _inputToSubsetColIndex == null ? _subsetInput.Schema.Count : _inputToSubsetColIndex.Length; 187_host.Assert(-1 <= result && result < _subsetInput.Schema.Count); 663int[] actives = Enumerable.Range(0, _parent.Schema.Count).Where(pred).ToArray(); 1163int colLim = Schema.Count; 1284host.Assert(0 <= srcCol && srcCol < input.Schema.Count); 1469Contracts.Assert(0 <= srcCol && srcCol < input.Schema.Count);

DataView\CompositeRowToRowMapper.cs (1)

62for (int c = 0; c < input.Schema.Count; ++c)

DataView\DataViewConstructionUtils.cs (3)

223Host.Assert(schema.Count == schemaDef.Columns.Length); 224Host.Assert(schema.Count == peeks.Length); 226_colCount = schema.Count;

DataView\EmptyDataView.cs (1)

57_active = Utils.BuildArray(Schema.Count, columnsNeeded);

DataView\LambdaFilter.cs (3)

91Host.Assert(0 <= colSrc && colSrc < Source.Schema.Count); 146active = new bool[Source.Schema.Count]; 147bool[] activeInput = new bool[Source.Schema.Count];

DataView\RowToRowMapperTransform.cs (5)

149int n = _bindings.Schema.Count; 154Contracts.Assert(activeInput.Length == _bindings.InputSchema.Count); 171Contracts.Assert(active.Length == _bindings.Schema.Count); 257var activeArr = new bool[OutputSchema.Count]; 382Ch.Check(column.Index < _bindings.Schema.Count);

DataView\SimpleRow.cs (1)

42Contracts.Check(Utils.Size(getters) == schema.Count);

DataView\Transposer.cs (13)

111_inputToTransposed = Utils.CreateArray(schema.Count, -1); 148ch.Assert(Enumerable.Range(0, slicerSchema.Count).All(c => saver.IsColumnSavable(slicerSchema[c].Type))); 227if (!(0 <= columns[c] && columns[c] < schema.Count)) 228throw host.ExceptParam(nameof(columns), "Column index {0} illegal for data with {1} column", columns[c], schema.Count); 235_host.CheckParam(0 <= col && col < _view.Schema.Count, nameof(col)); 309Ch.Assert(0 <= col && col < parent.Schema.Count); 327Ch.Assert(0 <= _col && _col < _parent.Schema.Count); 344Ch.Assert(0 <= col && col < parent.Schema.Count); 877bool isActive = pred == null || Enumerable.Range(offset, splitter.OutputSchema.Count).Any(c => pred(c)); 914Contracts.Assert(0 <= col && col < view.Schema.Count); 1300Ch.Check(column.Index < Schema.Count, nameof(column)); 1343Contracts.CheckParam(0 <= col && col < view.Schema.Count, nameof(col)); 1429_host.CheckParam(0 <= col && col < data.Schema.Count, nameof(col));

DataView\ZipBinding.cs (2)

35_cumulativeColCounts[i + 1] = _cumulativeColCounts[i] + schema.Count; 79Contracts.Assert(0 <= srcCol && srcCol < _sources[srcIndex].Count);

Dirty\ChooseColumnsByIndexTransform.cs (7)

89sources = Enumerable.Range(0, sourceSchema.Count).Except(selectedColumnIndexes).ToArray(); 112string fmt = string.Format("Column index {0} invalid for input with {1} columns", selectedIndex, _sourceSchema.Count); 113Contracts.Check(selectedIndex < _sourceSchema.Count, fmt); 155return Utils.BuildArray(OutputSchema.Count, predicate); 161var active = new bool[_sourceSchema.Count]; 287Ch.Assert(active == null || active.Length == bindings.OutputSchema.Count); 300Ch.Check(column.Index < _bindings.OutputSchema.Count);

Evaluators\EvaluatorUtils.cs (15)

170ectx.CheckParam(0 <= colScore && colScore < schema.Count, nameof(colScore)); 219ectx.CheckParam(0 <= col && col < schema.Count, nameof(col)); 295var colCount = schema.Count; 299for (int i = 0; i < schema.Count; i++) 399while (inputCol < input.Schema.Count && input.Schema[inputCol].IsHidden) 401env.Assert(inputCol < input.Schema.Count); 441while (inputCol < input.Schema.Count && input.Schema[inputCol].IsHidden) 443env.Assert(inputCol < input.Schema.Count); 825for (int i = 0; i < dv.Schema.Count; i++) 947for (int i = 0; i < schema.Count; i++) 996ch.Assert(Utils.Size(getters) == schema.Count); 997ch.Assert(Utils.Size(vBufferGetters) == schema.Count); 1004for (int i = 0; i < schema.Count; i++) 1097int colCount = data.Schema.Count; 1219int colCount = schema.Count;

Evaluators\MulticlassClassificationEvaluator.cs (1)

983for (int col = 0; col < idv.Schema.Count; col++)

Evaluators\MultiOutputRegressionEvaluator.cs (2)

676var colCount = fold.Schema.Count; 698for (int i = 0; i < fold.Schema.Count; i++)

Evaluators\QuantileRegressionEvaluator.cs (1)

514for (int i = 0; i < data.Schema.Count; i++)

Model\Pfa\BoundPfaContext.cs (2)

66for (int c = 0; c < schema.Count; ++c) 168_host.Assert(0 <= col && col < schema.Count);

Model\Pfa\SavePfaCommand.cs (1)

188for (int i = 0; i < end.Schema.Count; ++i)

Prediction\Calibrator.cs (3)

692var getters = new Delegate[OutputSchema.Count]; 697if (column.Index == OutputSchema.Count - 1) 707getters[OutputSchema.Count - 1] = GetProbGetter(predictorRow);

Scorers\FeatureContributionCalculation.cs (5)

194Contracts.Check(0 <= colSrc && colSrc < input.Schema.Count); 205Contracts.Check(0 <= colSrc && colSrc < input.Schema.Count); 368var totalColumnsCount = 1 + _outputGenericSchema.Count; 371if (activeColumns.Select(c => c.Index).Contains(_outputGenericSchema.Count)) 379for (var i = 0; i < _outputGenericSchema.Count; i++)

Scorers\MulticlassClassificationScorer.cs (1)

317for (int i = 0; i < partialSchema.Count; ++i)

Scorers\PredictedLabelScorerBase.cs (2)

185for (int i = 0; i < sch.Count; ++i) 404Host.Assert(Bindings.InfoCount == output.Schema.Count + 1);

Scorers\RowToRowScorerBase.cs (6)

94Contracts.Assert(activeInput.Length == bindings.Input.Count); 195var getters = new Delegate[row.Schema.Count]; 207Contracts.Assert(0 <= col && col < row.Schema.Count); 217Contracts.Assert(0 <= col && col < output.Schema.Count); 369int count = namesDerived.Length + schema.Count; 374for (int i = 0; i < schema.Count; i++)

Scorers\SchemaBindablePredictorWrapper.cs (4)

160Contracts.Assert(0 <= colSrc && colSrc < input.Schema.Count); 210Contracts.Assert(outputSchema.Count == 1); 612var active = Utils.BuildArray(OutputSchema.Count, activeColumns); 701Contracts.Assert(0 <= colSrc && colSrc < input.Schema.Count);

Transforms\ColumnBindingsBase.cs (12)

352colMap = new int[input.Count + names.Length]; 360Contracts.Check(0 <= colHidden && colHidden < input.Count); 380for (int colSrc = input.Count; --colSrc >= 0;) 429Contracts.Assert(index < Input.Count); 469Contracts.Assert(0 <= src && src < Input.Count); 607var active = new bool[Input.Count]; 611Contracts.Assert(-InfoCount <= src && src < Input.Count); 689for (int i = 0; i < input.Count; i++) 717Contracts.Assert(indices.Count == addedColumns.Length + input.Count); 759Contracts.Assert(index < InputSchema.Count); 774var active = new bool[InputSchema.Count]; 778Contracts.Assert(-AddedColumnIndices.Count <= src && src < InputSchema.Count);

Transforms\ColumnConcatenatingTransformer.cs (1)

859var active = new bool[InputSchema.Count];

Transforms\ColumnSelecting.cs (6)

555var columnCount = inputSchema.Count; 567for (int colIdx = 0; colIdx < inputSchema.Count; ++colIdx) 603for (int colIdx = 0; colIdx < inputSchema.Count; colIdx++) 688var active = Utils.BuildArray(_mapper.OutputSchema.Count, columnsNeeded); 701var active = Utils.BuildArray(_mapper.OutputSchema.Count, columnsNeeded); 718var active = new bool[_mapper.InputSchema.Count];

Transforms\GenerateNumberTransform.cs (1)

236Contracts.Assert(active.Length == Input.Count);

Transforms\Hashing.cs (1)

1002Contracts.Assert(0 <= srcCol && srcCol < input.Schema.Count);

Transforms\InvertHashUtils.cs (1)

38Contracts.Assert(0 <= col && col < schema.Count);

Transforms\MetadataDispatcher.cs (1)

162Contracts.Check(schemaSrc == null || (0 <= indexSrc && indexSrc < schemaSrc.Count), "indexSrc out of range");

Transforms\NAFilter.cs (2)

240active = new bool[Source.Schema.Count]; 241bool[] activeInput = new bool[Source.Schema.Count];

Transforms\OneToOneTransformerBase.cs (1)

111var active = new bool[InputSchema.Count];

Transforms\PerGroupTransformBase.cs (1)

66var active = new bool[Input.Count];

Transforms\RangeFilter.cs (2)

252active = new bool[Source.Schema.Count]; 253bool[] activeInput = new bool[Source.Schema.Count];

Transforms\RowShufflingTransformer.cs (3)

193for (int c = 0; c < schema.Count; ++c) 213for (int c = 0; c < schema.Count; ++c) 518int colLim = Schema.Count;

Transforms\SkipTakeFilter.cs (1)

216var activeColumns = Utils.BuildArray(OutputSchema.Count, columnsNeeded);

Transforms\TransformBase.cs (1)

436var active = new bool[Input.Count];

Transforms\ValueToKeyMappingEstimator.cs (2)

158if (keyData != null && keyData.Schema.Count != 1) 161$"containing the terms to map, but this had {keyData.Schema.Count} columns.");

Transforms\ValueToKeyMappingTransformer.cs (3)

460ch.Assert(keyData.Schema.Count == 1); 473if (keyData.Schema.Count != 1) 476$"had {keyData.Schema.Count} instead. Consider using {nameof(ColumnSelectingEstimator)} on that data first.");

Transforms\ValueToKeyMappingTransformerImpl.cs (1)

288Contracts.Assert(0 <= col && col < schema.Count);

Utilities\ColumnCursor.cs (4)

101Contracts.Assert(0 <= col && col < data.Schema.Count); 119Contracts.Assert(0 <= col && col < data.Schema.Count); 137Contracts.Assert(0 <= col && col < data.Schema.Count); 159Contracts.Assert(0 <= col && col < data.Schema.Count);

Utilities\ModelFileUtils.cs (1)

262saver.SaveData(entry.Stream, view, Utils.GetIdentityPermutation(view.Schema.Count));

DataViewSchema.cs (5)

73public override string ToString() => $"{Count} columns"; 121var annotationsString = (Annotations == null || Annotations.Schema.Count == 0) ? 198Debug.Assert(schema.Count == getters.Length); 200for (int i = 0; i < schema.Count; i++) 249Debug.Assert(0 <= index && index < Schema.Count);

SchemaDebuggerProxy.cs (1)

22Columns = Enumerable.Range(0, schema.Count).Select(x => schema[x]).ToArray();

CrossValidationMacro.cs (1)

396for (int col = 0; col < idv.Schema.Count; col++)

JsonUtils\ExecuteGraphCommand.cs (1)

244saver.SaveData(fs, idv, Utils.GetIdentityPermutation(idv.Schema.Count)

ScoreColumnSelector.cs (1)

32for (int i = 0; i < view.Schema.Count; i++)

Common.cs (1)

26Assert.Equal(toyClassProperties.Length, testTypeDataset.Schema.Count);

Debugging.cs (1)

117var columnNames = new string[outputSchema.Count];

ModelFiles.cs (5)

367Assert.True(loadedSchema.Count == 2 && 375Assert.True(schema.Count == 2 && 403Assert.True(expectedSchema.Count == 3); 432Assert.Equal(2, expectedInputSchema.Count); 468Assert.True(loadedSchema.Count == 2 &&

OnnxExportExtensions.cs (1)

29for (int i = 0; i < sink.Schema.Count; ++i)

SaveOnnxCommand.cs (2)

171for (int i = 0; i < inputData.Schema.Count; i++) 189for (int i = 0; i < outputData.Schema.Count; ++i)

ParquetLoader.cs (2)

427var allColumns = Enumerable.Range(0, Schema.Count).ToArray(); 460Utils.BuildSubsetMaps(Schema.Count, columnsNeeded, out _actives, out _colToActivesIndex);

PartitionedFileLoader.cs (10)

278var allColumns = Enumerable.Range(0, Schema.Count).ToArray(); 326if (subSchema.Count == 0) 397_active = Utils.BuildArray(Schema.Count, columnsNeeded); 399_colValues = new ReadOnlyMemory<char>[Schema.Count - SubColumnCount]; 449Ch.Check(column.Index < Schema.Count); 577Delegate[] getters = new Delegate[Schema.Count]; 646private int SubColumnCount => Schema.Count - _parent._srcDirIndex.Length; 662if (schema1.Count != schema2.Count) 667int colLim = schema1.Count;

PcaTransformer.cs (1)

408bool[] activeColumns = new bool[trainingData.Schema.Count];

TestTransposer.cs (1)

245saver.SaveData(mem, view, Utils.GetIdentityPermutation(view.Schema.Count));

MatrixFactorizationPredictor.cs (2)

395_env.Assert(Utils.Size(active) == OutputSchema.Count); 413var activeArray = Utils.BuildArray(OutputSchema.Count, activeColumns);

Dynamic\Transforms\SelectColumns.cs (1)

50Console.WriteLine($"There are {transformedData.Schema.Count} columns" +

Program.cs (1)

52var nColumns = data.Schema.Count;

FactorizationMachine\FieldAwareFactorizationMachineUtils.cs (1)

78Contracts.CheckParam(outputSchema.Count == 2, nameof(outputSchema));

TensorflowTests.cs (2)

580Assert.Equal(86, schema.Count); 642for (int i = 0; i < schema.Count; i++)

DataPipe\TestDataPipe.cs (1)

1191Assert.Equal(3, view.Schema.Count);

DataPipe\TestDataPipeBase.cs (16)

243if (pipe1.Schema.Count > 0) 384for (int c = 0; c < schema.Count; ++c) 407if (savable.Count < view.Schema.Count) 474for (int col = 0; col < sch.Count; col++) 531for (int c = 0; c < schema.Count; ++c) 547if (savable.Count < view.Schema.Count) 577for (int c = 0; c < schema.Count; ++c) 598if (savable.Count < view.Schema.Count) 654Contracts.Assert(view1.Schema.Count == view2.Schema.Count); 703Contracts.Assert(curs1.Schema.Count == curs2.Schema.Count); 706int colLim = curs1.Schema.Count; 784Contracts.Assert(curs1.Schema.Count == view2.Schema.Count); 787int colLim = curs1.Schema.Count;

TestCommon.cs (5)

90Assert.True(sch1.Count == sch2.Count, $"column count mismatch: {sch1.Count} vs {sch2.Count}"); 92for (int col = 0; col < sch1.Count; col++)

Scenarios\Api\TestApi.cs (4)

231Assert.True(idv.Schema[0].Annotations.Schema.Count == 2); 237Assert.True(idv.Schema[1].Annotations.Schema.Count == 3); 335Assert.Equal(fullInput.Schema.Count, split.Schema.Count);

TrainerEstimators\TreeEnsembleFeaturizerTest.cs (2)

84Assert.Equal(2, treeLeafIdsColumn.Annotations.Schema.Count); 107Assert.Equal(2, treePathIdsColumn.Annotations.Schema.Count);

Transformers\NormalizerTests.cs (1)

879Assert.Equal(3, result.Schema.Count);

Transformers\SelectColumnsTests.cs (5)

140Assert.Equal(2, result.Schema.Count); 163Assert.Equal(4, result.Schema.Count); 187Assert.Equal(2, result.Schema.Count); 207Assert.Equal(2, result.Schema.Count); 308Assert.Equal(6, result.Schema.Count);

Transformers\ValueMappingTests.cs (1)

702Assert.Equal(5, result.Schema.Count);

PredictionEngine.cs (1)

173for (int c = 0; c < input.Schema.Count; ++c)

SequentialTransformBase.cs (3)

403Ch.Assert(input.Schema.Count == parent.OutputSchema.Count); 414Ch.Check(column.Index < Schema.Count, nameof(column));

SequentialTransformerBase.cs (4)

698Ch.Assert(input.Schema.Count == parent.OutputSchema.Count); 709Ch.Check(column.Index < Schema.Count, nameof(column)); 936var activeArr = Utils.BuildArray(OutputSchema.Count, activeColumns);

NerTests.cs (3)

82Assert.Equal(5, transformerSchema.Count); 161Assert.Equal(5, transformerSchema.Count); 262Assert.Equal(5, transformerSchema.Count);

QATests.cs (1)

55Assert.Equal(6, transformerSchema.Count);

TextClassificationTests.cs (4)

113Assert.Equal(5, transformerSchema.Count); 249Assert.Equal(6, transformerSchema.Count); 333Assert.Equal(7, transformerSchema.Count); 399Assert.Equal(4, transformerSchema.Count);

CustomMappingFilter.cs (2)

46return GetRowCursorCore(input, Utils.BuildArray(Input.Schema.Count, inputCols)); 83var active = Utils.BuildArray(Input.Schema.Count, inputCols);

CustomMappingTransformer.cs (1)

192return Enumerable.Range(0, dstRow.Schema.Count).Select(x => new DataViewSchema.DetachedColumn(dstRow.Schema[x])).ToArray();

GroupTransform.cs (1)

522_active = Utils.BuildArray(binding.OutputSchema.Count, predicate);

StatefulCustomMappingTransformer.cs (2)

122var cols = Enumerable.Range(0, dstRow.Schema.Count).Select(x => new DataViewSchema.DetachedColumn(dstRow.Schema[x])).ToArray(); 276Ch.Assert(active == null || active.Length == parent.OutputSchema.Count);

StatefulFilterTransform.cs (2)

218Contracts.CheckParam(column.Index < Schema.Count, nameof(column)); 235Contracts.CheckParam(column.Index < Schema.Count, nameof(column));

SvmLight\SvmLightSaver.cs (1)

116_host.Check(col < data.Schema.Count);

Text\NgramHashingTransformer.cs (1)

658_srcTextGetters = new ValueMapper<uint, StringBuilder>[inputSchema.Count];

UngroupTransform.cs (4)

259public int InputColumnCount => _inputSchema.Count; 387var activeInput = Utils.BuildArray(_inputSchema.Count, predicate); 409_ectx.Assert(0 <= col && col < _inputSchema.Count); 421_ectx.Assert(0 <= col && col < _inputSchema.Count);