Contracts

Commands\CrossValidationCommand.cs (1)

401Contracts.CheckValue(env, nameof(env));

Commands\DataCommand.cs (11)

79Contracts.CheckValue(env, nameof(env)); 99Contracts.CheckValue(impl, nameof(impl)); 100Contracts.AssertValue(impl.Host); 130Contracts.AssertValue(pipe); 143Contracts.AssertValue(pipe); 403Contracts.CheckValue(loader, nameof(loader)); 404Contracts.CheckValue(file, nameof(file)); 405Contracts.CheckParam(file.CanWrite, nameof(file), "Must be writable"); 418Contracts.CheckValue(loader, nameof(loader)); 419Contracts.CheckValue(stream, nameof(stream)); 420Contracts.CheckParam(stream.CanWrite, nameof(stream), "Must be writable");

Commands\EvaluateCommand.cs (3)

57Contracts.CheckValue(loadName, nameof(loadName)); 58Contracts.CheckValue(name, nameof(name)); 148Contracts.CheckValue(env, nameof(env));

Commands\SaveDataCommand.cs (3)

45Contracts.CheckNonEmpty(args.OutputDataFile, nameof(args.OutputDataFile)); 190Contracts.CheckValue(ch, nameof(ch)); 202Contracts.CheckValue(ch, nameof(ch));

Commands\SavePredictorCommand.cs (4)

60Contracts.CheckValue(env, nameof(env)); 123Contracts.CheckValue(env, nameof(env)); 145Contracts.CheckValue(ch, nameof(ch)); 209Contracts.CheckValue(env, nameof(env));

Commands\ScoreCommand.cs (6)

258Contracts.CheckValue(env, nameof(env)); 283Contracts.AssertValue(env); 306Contracts.CheckValue(environment, nameof(environment)); 307Contracts.AssertValue(mapper); 368Contracts.CheckValue(env, nameof(env)); 396Contracts.AssertValue(env);

Commands\ShowSchemaCommand.cs (37)

Commands\TrainCommand.cs (13)

Commands\TypeInfoCommand.cs (5)

37Contracts.CheckValue(env, nameof(env)); 58Contracts.AssertValueOrNull(x); 59Contracts.AssertValueOrNull(y); 67Contracts.AssertValueOrNull(obj); 142Contracts.AssertValue(ch);

Data\BufferBuilder.cs (33)

Data\Combiner.cs (1)

40Contracts.Check(IsDefault(dst));

Data\Conversion.cs (71)

Data\DataViewUtils.cs (49)

Data\RowCursorUtils.cs (55)

Data\SchemaDefinition.cs (20)

Data\SlotCursor.cs (2)

32Contracts.AssertValue(provider); 89Contracts.AssertValue(cursor);

DataDebuggerPreview.cs (2)

33Contracts.CheckValue(data, nameof(data)); 34Contracts.CheckParam(maxRows >= 0, nameof(maxRows));

DataLoadSave\Binary\BinaryLoader.cs (61)

DataLoadSave\Binary\BinaryLoaderSaverCatalog.cs (6)

26Contracts.CheckValue(fileSource, nameof(fileSource)); 49Contracts.CheckNonEmpty(path, nameof(path)); 52throw Contracts.ExceptParam(nameof(path), "File does not exist at path: {0}", path); 78Contracts.CheckValue(catalog, nameof(catalog)); 79Contracts.CheckValue(data, nameof(data)); 80Contracts.CheckValue(stream, nameof(stream));

DataLoadSave\Binary\BinarySaver.cs (11)

88Contracts.AssertValue(parent); 120Contracts.AssertValue(codec); 127Contracts.Assert(_writer == null); 134Contracts.Assert(_writer != null); 141Contracts.Assert(_writer != null); 192Contracts.CheckValue(env, nameof(env)); 214Contracts.AssertValue(exMarshaller); 232Contracts.Assert(tmp); 573Contracts.AssertValue(ch); 574Contracts.AssertValueOrNull(pch); 623Contracts.Assert(rows == (blockIndex + 1) * rowsPerBlock - remainingInBlock);

DataLoadSave\Binary\CodecFactory.cs (10)

37Contracts.AssertValue(env, "env"); 38Contracts.AssertValueOrNull(memPool); 88Contracts.Assert(!_loadNameToCodecCreator.ContainsKey(codec.LoadName)); 89Contracts.Assert(!_simpleCodecTypeMap.ContainsKey(codec.Type.RawType)); 96Contracts.Assert(!_loadNameToCodecCreator.ContainsKey(name)); 131Contracts.Check(mem.Length == output, "codec description length did not match stream length"); 132Contracts.Check(mem.Length <= int.MaxValue); // Is this even possible in the current implementation of MemoryStream? 156Contracts.AssertValue(definitionStream, "definitionStream"); 162Contracts.CheckDecode(!string.IsNullOrEmpty(signature), "Non-empty signature string expected"); 164Contracts.CheckDecode(ulen <= long.MaxValue, "Codec type definition read from stream too large");

DataLoadSave\Binary\Codecs.cs (80)

DataLoadSave\Binary\CompressionKind.cs (2)

43throw Contracts.Except("unrecognized compression codec {0}", compression); 62throw Contracts.Except("unrecognized compression codec {0}", compression);

DataLoadSave\Binary\MemoryStreamPool.cs (4)

34Contracts.Assert(mem.Position == 0); 35Contracts.Assert(mem.Length == 0); 61Contracts.CheckParam(0 <= maxSize, nameof(maxSize), "Must be positive"); 63Contracts.Assert(0 <= index && index < _pools.Length);

DataLoadSave\CompositeDataLoader.cs (5)

37Contracts.CheckValue(loader, nameof(loader)); 38Contracts.CheckValueOrNull(transformerChain); 53Contracts.CheckValue(env, nameof(env)); 86Contracts.CheckValue(transformer, nameof(transformer)); 93Contracts.CheckValue(ctx, nameof(ctx));

DataLoadSave\CompositeLoaderEstimator.cs (3)

20Contracts.CheckValue(start, nameof(start)); 21Contracts.CheckValueOrNull(estimatorChain); 52Contracts.CheckValue(estimator, nameof(estimator));

DataLoadSave\Database\DatabaseLoader.cs (40)

46Contracts.CheckValue(env, nameof(env)); 61Contracts.AssertValue(host, "host"); 71Contracts.CheckValue(env, nameof(env)); 135throw Contracts.Except($"Cannot specify both {nameof(LoadColumnAttribute)} and {nameof(LoadColumnNameAttribute)}"); 150throw Contracts.Except($"Field {memberInfo.Name} is of unsupported type."); 156throw Contracts.Except($"Property {memberInfo.Name} is of unsupported type."); 160Contracts.Assert(false); 161throw Contracts.ExceptNotSupp("Expected a FieldInfo or a PropertyInfo"); 218Contracts.CheckValue(name, nameof(name)); 219Contracts.CheckValue(source, nameof(source)); 265Contracts.CheckParam(index >= 0, nameof(index), "Must be non-negative"); 277Contracts.CheckValue(name, nameof(name)); 290Contracts.CheckParam(min >= 0, nameof(min), "Must be non-negative"); 291Contracts.CheckParam(max >= min, nameof(max), "Must be greater than or equal to " + nameof(min)); 335Contracts.Assert(range.Max.HasValue); 368Contracts.Assert(0 <= min && min < lim); 377Contracts.Assert(name != null); 399Contracts.AssertNonEmpty(name); 400Contracts.AssertValueOrNull(segs); 401Contracts.Assert(sizeBase > 0); 404Contracts.Assert(colType.GetItemType().GetRawKind() != 0); 412Contracts.AssertNonEmpty(name); 413Contracts.AssertValue(itemType); 414Contracts.AssertValueOrNull(segs); 432Contracts.Assert(segs[a].Min <= segs[b].Min); 436Contracts.ExceptUserArg(nameof(Column.Source), "Intervals specified for column '{0}' overlap", name) : 437Contracts.ExceptDecode("Intervals specified for column '{0}' overlap", name); 449Contracts.Assert(size >= segs.Length); 474Contracts.AssertNonEmpty(cols); 544Contracts.AssertValue(ctx); 561Contracts.CheckDecode(cinfo > 0); 570Contracts.CheckDecode(Enum.IsDefined(typeof(InternalDataKind), kind)); 575Contracts.CheckDecode(KeyDataViewType.IsValidDataType(kind.ToType())); 578Contracts.CheckDecode(0 < count); 595Contracts.CheckDecode(cseg > 0); 602Contracts.CheckDecode(0 <= min && min < lim); 619Contracts.AssertValue(ctx); 642Contracts.Assert((InternalDataKind)(byte)rawKind == rawKind); 685Contracts.CheckValue(keyCount, nameof(keyCount)); 689Contracts.CheckUserArg(KeyDataViewType.IsValidDataType(rawType), nameof(DatabaseLoader.Column.Type), "Bad item type for Key");

DataLoadSave\Database\DatabaseLoaderCursor.cs (5)

98Contracts.AssertValue(parent); 99Contracts.AssertValue(source); 100Contracts.Assert(active == null || active.Length == parent._bindings.OutputSchema.Count); 772Contracts.Check(segs.Length == 1); 778Contracts.Check(seg.Lim == (seg.Min + 1));

DataLoadSave\Database\DatabaseSource.cs (4)

31Contracts.CheckValue(providerFactory, nameof(providerFactory)); 32Contracts.CheckValue(connectionString, nameof(connectionString)); 33Contracts.CheckValue(commandText, nameof(commandText)); 34Contracts.CheckUserArg(commandTimeoutInSeconds >= 0, nameof(commandTimeoutInSeconds));

DataLoadSave\DataOperationsCatalog.cs (3)

49Contracts.AssertValue(env); 525Contracts.CheckValue(env, nameof(env)); 526Contracts.CheckValueOrNull(samplingKeyColumn);

DataLoadSave\EstimatorChain.cs (11)

29Contracts.AssertValueOrNull(env); 30Contracts.AssertValueOrNull(estimators); 31Contracts.AssertValueOrNull(scopes); 32Contracts.AssertValueOrNull(needCacheAfter); 33Contracts.Assert(Utils.Size(estimators) == Utils.Size(scopes)); 34Contracts.Assert(Utils.Size(estimators) == Utils.Size(needCacheAfter)); 42Contracts.Assert((_host != null) == _needCacheAfter.Any(x => x)); 43Contracts.Assert((_estimators.Length > 0) == (LastEstimator != null)); 75Contracts.AssertValue(_host); 94Contracts.CheckValue(estimator, nameof(estimator)); 110Contracts.CheckValue(env, nameof(env));

DataLoadSave\EstimatorExtensions.cs (15)

24Contracts.CheckValue(start, nameof(start)); 25Contracts.CheckValue(estimator, nameof(estimator)); 37Contracts.CheckValue(start, nameof(start)); 38Contracts.CheckValue(estimator, nameof(estimator)); 51Contracts.CheckValue(start, nameof(start)); 52Contracts.CheckValue(estimator, nameof(estimator)); 70Contracts.CheckValue(start, nameof(start)); 80Contracts.CheckValue(loader, nameof(loader)); 81Contracts.CheckValue(transformer, nameof(transformer)); 92Contracts.CheckValue(start, nameof(start)); 93Contracts.CheckValue(transformer, nameof(transformer)); 106Contracts.AssertValue(estimator); 107Contracts.AssertValue(onFit); 148Contracts.CheckValue(estimator, nameof(estimator)); 149Contracts.CheckValue(onFit, nameof(onFit));

DataLoadSave\LegacyCompositeDataLoader.cs (19)

50Contracts.AssertNonEmpty(tag); 51Contracts.AssertValueOrNull(argsString); 52Contracts.AssertValue(transform, "transform"); 96Contracts.CheckValue(env, nameof(env)); 115Contracts.CheckValue(env, nameof(env)); 126Contracts.AssertValue(host, "host"); 179Contracts.CheckValue(env, nameof(env)); 193Contracts.AssertValue(host, "host"); 278Contracts.CheckValue(env, nameof(env)); 295Contracts.CheckValue(env, nameof(env)); 324Contracts.CheckValue(env, nameof(env)); 349Contracts.CheckValue(env, nameof(env)); 424Contracts.AssertValue(host, "host"); 452Contracts.AssertValue(host, "host"); 522Contracts.CheckValue(env, nameof(env)); 540Contracts.AssertValue(ctx); 541Contracts.AssertValue(loaderSaveAction); 542Contracts.AssertValueOrNull(transforms); 565Contracts.AssertNonEmpty(transforms[i].Tag);

DataLoadSave\MultiFileSource.cs (8)

36Contracts.CheckValueOrNull(paths); 72Contracts.CheckParam(0 <= index && index < Count, nameof(index)); 78Contracts.CheckParam(0 <= index && index < Count, nameof(index)); 87throw Contracts.ExceptIO(e, "Could not open file '{0}'. Error is: {1}", path, e.Message); 106Contracts.CheckValue(file, nameof(file)); 107Contracts.CheckParam(file.CanRead, nameof(file), "File handle must be readable"); 118Contracts.CheckParam(0 <= index && index < Count, nameof(index)); 124Contracts.CheckParam(0 <= index && index < Count, nameof(index));

DataLoadSave\Text\BlockingQueue.cs (6)

45Contracts.Assert(boundedCapacity > 0); 68Contracts.Assert(!_itemsAvailable.Completed); 96Contracts.Assert(gotItem || _itemsAvailable.Completed); 146Contracts.Assert(initialCount >= 0); 181Contracts.Assert(_count >= 0); 209Contracts.Assert(_waiters >= 0);

DataLoadSave\Text\TextLoader.cs (49)

DataLoadSave\Text\TextLoaderCursor.cs (48)

DataLoadSave\Text\TextLoaderParser.cs (107)

DataLoadSave\Text\TextLoaderSaverCatalog.cs (5)

294Contracts.CheckValue(catalog, nameof(catalog)); 295Contracts.CheckValue(data, nameof(data)); 296Contracts.CheckValue(stream, nameof(stream)); 312Contracts.CheckNonEmpty(path, nameof(path)); 314throw Contracts.ExceptParam(nameof(path), "File or directory does not exist at path: {0}", path);

DataLoadSave\Text\TextSaver.cs (28)

DataLoadSave\TransformerChain.cs (11)

86Contracts.CheckValueOrNull(transformers); 87Contracts.CheckValueOrNull(scopes); 93Contracts.Check((_transformers.Length > 0) == (LastTransformer != null)); 94Contracts.Check(_transformers.Length == _scopes.Length); 104Contracts.CheckValueOrNull(transformers); 117Contracts.Check(LastTransformer != null); 129Contracts.CheckValue(inputSchema, nameof(inputSchema)); 147Contracts.CheckValue(input, nameof(input)); 183Contracts.CheckValue(transformer, nameof(transformer)); 242Contracts.CheckValue(inputSchema, nameof(inputSchema)); 243Contracts.Check(((ITransformer)this).IsRowToRowMapper, nameof(ITransformer.GetRowToRowMapper) + " method called despite " +

DataLoadSave\TransformWrapper.cs (3)

25Contracts.CheckValue(env, nameof(env)); 26Contracts.Check(xf is IDataTransform); 70Contracts.CheckValue(host, nameof(host));

DataLoadSave\Transpose\TransposeLoader.cs (12)

152Contracts.AssertValue(parent); 168Contracts.AssertValue(parent); 183Contracts.Check(stream.Position == _offset, "Unexpected position on substream"); 202/// should be handle with <see cref="Contracts.CheckDecode(bool)"/> or by throwing 203/// <see cref="Contracts.ExceptDecode()"/>, as we consider the views not adhering to 223Contracts.Assert(view != null); 397Contracts.CheckValue(env, nameof(env)); 427Contracts.CheckValue(host, nameof(host)); 460Contracts.CheckValue(host, nameof(host)); 487Contracts.CheckValue(env, nameof(env)); 540Contracts.AssertValue(env); 711Contracts.Assert(pos <= int.MaxValue);

DataLoadSave\Transpose\TransposeSaver.cs (1)

56Contracts.CheckValue(env, nameof(env));

DataLoadSave\TrivialEstimator.cs (1)

27Contracts.AssertValue(host);

DataView\AppendRowsDataView.cs (3)

58Contracts.CheckValue(env, nameof(env)); 70Contracts.CheckValue(env, nameof(env)); 419Contracts.AssertValue(context);

DataView\ArrayDataViewBuilder.cs (7)

38Contracts.CheckValue(env, nameof(env)); 210Contracts.AssertValue(env, "env"); 383Contracts.Assert(typeof(TOut) == type.RawType); 396Contracts.AssertValue(values); 413Contracts.Assert(0 <= index && index < _values.Length); 464Contracts.AssertValue(itemType); 465Contracts.Assert(itemType.RawType == typeof(TOut));

DataView\BatchDataViewMapperBase.cs (4)

23Contracts.CheckValue(env, nameof(env)); 48Contracts.Assert(active.Length == SchemaBindings.ColumnCount); 111Contracts.CheckParam(IsColumnActive(column), nameof(column), "requested column is not active"); 116Contracts.AssertValue(_input);

DataView\CacheDataView.cs (49)

DataView\CompositeRowToRowMapper.cs (8)

34Contracts.CheckValue(inputSchema, nameof(inputSchema)); 35Contracts.CheckValueOrNull(mappers); 54Contracts.CheckValue(input, nameof(input)); 55Contracts.CheckValue(activeColumns, nameof(activeColumns)); 56Contracts.CheckParam(input.Schema == InputSchema, nameof(input), "Schema did not match original schema"); 69throw Contracts.ExceptParam(nameof(input), $"Mapper required column '{input.Schema[c].Name}' active but it was not."); 96Contracts.AssertValue(row); 97Contracts.AssertValue(pred);

DataView\DataViewConstructionUtils.cs (31)

29Contracts.AssertValue(env); 42Contracts.AssertValue(env); 55Contracts.AssertValue(env); 64Contracts.AssertValue(env); 97Contracts.AssertValue(env); 112Contracts.AssertValue(env); 217Contracts.AssertValue(env); 434Contracts.AssertValue(getter); 464Contracts.AssertValue(env); 546Contracts.AssertValue(env); 694Contracts.CheckValue(data, nameof(data)); 774Contracts.Assert(_current != null, "The current object must be set prior to cursoring"); 808Contracts.AssertValue(schemaDefn); 844Contracts.AssertValueOrNull(annotationType); 845Contracts.AssertNonEmpty(kind); 878Contracts.Assert(value != null); 896throw Contracts.Except("Value inputted is supposed to be {0}, but type of Annotationinfo is {1}", 903throw Contracts.Except( 917Contracts.Assert(AnnotationType is VectorDataViewType); 918Contracts.Check(typeof(TDst).IsGenericType && typeof(TDst).GetGenericTypeDefinition() == typeof(VBuffer<>)); 925Contracts.Check(dstItemType == typeof(ReadOnlyMemory<char>)); 932Contracts.Check(itemType == dstItemType); 941Contracts.Assert(typeT.IsGenericType); 942Contracts.Check(typeof(TDst).IsGenericType); 943Contracts.Assert(typeT.GetGenericTypeDefinition() == typeof(VBuffer<>)); 944Contracts.Check(typeof(TDst).GetGenericTypeDefinition() == typeof(VBuffer<>)); 947Contracts.Assert(itemType == annotationVectorType.ItemType.RawType); 948Contracts.Check(itemType == dstItemType); 957Contracts.Assert(AnnotationType is TextDataViewType); 962Contracts.Assert(AnnotationType.RawType == typeT); 965throw Contracts.ExceptNotImpl("Type '{0}' is not yet supported.", typeT.FullName);

DataView\DataViewExtensions.cs (3)

23Contracts.AssertValue(columnsNeeded, $"The {nameof(columnsNeeded)} cannot be null. Pass an empty array, to indicate that no columns is needed."); 26Contracts.Assert(dv.Schema[col.Index].Equals(col), $"The requested column named: {col.Name}, with index: {col.Index} and type: {col.Type}" + 41Contracts.Assert(dv.Schema[columnNeeded.Index].Equals(columnNeeded), $"The requested column named: {columnNeeded.Name}, with index: {columnNeeded.Index} and type: {columnNeeded.Type}" +

DataView\EmptyDataView.cs (1)

25Contracts.CheckValue(env, nameof(env));

DataView\InternalSchemaDefinition.cs (30)

DataView\LambdaColumnMapper.cs (1)

24Contracts.CheckValue(env, nameof(env));

DataView\LambdaFilter.cs (1)

23Contracts.CheckValue(env, nameof(env));

DataView\RowToRowMapperTransform.cs (15)

98Contracts.CheckValue(mapper, nameof(mapper)); 99Contracts.CheckValueOrNull(mapperFactory); 106Contracts.CheckValue(inputSchema, nameof(inputSchema)); 107Contracts.CheckValue(mapper, nameof(mapper)); 123Contracts.CheckValue(env, nameof(env)); 151Contracts.Assert(active.Length == n); 154Contracts.Assert(activeInput.Length == _bindings.InputSchema.Count); 170Contracts.AssertValue(active); 171Contracts.Assert(active.Length == _bindings.Schema.Count); 176Contracts.Assert(0 <= col && col < _bindings.AddedColumnIndices.Count); 271Contracts.CheckValue(env, nameof(env)); 273Contracts.CheckValue(newSource, nameof(newSource)); 337Contracts.Assert(originFn != null); 340throw Contracts.Except($"Invalid TValue in GetGetter: '{typeof(TValue)}', " + 407throw Contracts.Except($"Invalid TValue in GetGetter: '{typeof(TValue)}', " +

DataView\SimpleRow.cs (8)

40Contracts.CheckValue(schema, nameof(schema)); 41Contracts.CheckValue(input, nameof(input)); 42Contracts.Check(Utils.Size(getters) == schema.Count); 43Contracts.CheckValueOrNull(disposer); 57Contracts.CheckParam(column.Index < _getters.Length, nameof(column), "Invalid col value in GetGetter"); 58Contracts.Check(IsColumnActive(column)); 61throw Contracts.Except("Unexpected TValue in GetGetter"); 69Contracts.Check(column.Index < _getters.Length);

DataView\Transposer.cs (44)

DataView\TypedCursor.cs (17)

DataView\ZipBinding.cs (5)

27Contracts.AssertNonEmpty(sources); 53Contracts.AssertValue(predicate); 69Contracts.CheckParam(0 <= col && col < _cumulativeColCounts[_cumulativeColCounts.Length - 1], nameof(col), "Column index out of range"); 77Contracts.Assert(0 <= srcIndex && srcIndex < _cumulativeColCounts.Length); 79Contracts.Assert(0 <= srcCol && srcCol < _sources[srcIndex].Count);

DataView\ZipDataView.cs (2)

34Contracts.CheckValue(env, nameof(env)); 47Contracts.AssertValue(host);

DebuggerExtensions.cs (4)

44Contracts.CheckValue(estimator, nameof(estimator)); 45Contracts.CheckValue(data, nameof(data)); 46Contracts.CheckParam(maxRows >= 0, nameof(maxRows)); 47Contracts.CheckParam(maxTrainingRows >= 0, nameof(maxTrainingRows));

Deprecated\Instances\HeaderSchema.cs (33)

Deprecated\Vector\GenericSpanSortHelper.cs (19)

Deprecated\Vector\VBufferMathUtils.cs (21)

117Contracts.Assert(length == count); 141Contracts.Check(src.Length == dst.Length, "Vectors must have the same dimensionality."); 169Contracts.Check(src.Length == dst.Length, "Vectors must have the same dimensionality."); 194Contracts.Check(src.Length == dst.Length, "Vectors must have the same dimensionality."); 205Contracts.Assert(length > 0); 224Contracts.Check(a.Length == b.Length, "Vectors must have the same dimensionality."); 242Contracts.CheckParam(0 <= offset && offset <= dst.Length, nameof(offset)); 243Contracts.CheckParam(src.Length <= dst.Length - offset, nameof(offset)); 270Contracts.Assert(dMin - dLim <= src.Length); 308Contracts.Assert(dLim < dstValues.Length); 325Contracts.Assert(iDD == iS + dMin); 327Contracts.Assert(iDD >= iD); 346Contracts.Assert(iDD >= iD); 418Contracts.Assert(-1 <= ind && ind < srcValues.Length); 426Contracts.Assert(srcIndices[ind] >= ind); 439Contracts.Assert(ind <= srcIndices.Length); 440Contracts.Assert(ind == srcIndices.Length || ind < srcIndices[ind]); 454Contracts.Assert(-1 <= ind && ind < srcValues.Length); 462Contracts.Assert(srcIndices[ind] >= ind); 475Contracts.Assert(ind <= srcIndices.Length); 476Contracts.Assert(ind == srcIndices.Length || ind < srcIndices[ind]);

Deprecated\Vector\VectorUtils.cs (36)

Dirty\ChooseColumnsByIndexTransform.cs (9)

64Contracts.AssertValue(options); 65Contracts.AssertValue(sourceSchema); 95Contracts.Check(sources.Length > 0, "Choose columns by index has no output column."); 113Contracts.Check(selectedIndex < _sourceSchema.Count, fmt); 124Contracts.AssertValue(ctx); 125Contracts.AssertValue(sourceSchema); 144Contracts.AssertValue(ctx); 160Contracts.AssertValue(predicate); 217Contracts.CheckValue(env, nameof(env));

Dirty\IniFileUtils.cs (2)

25throw Contracts.ExceptNotImpl("Need to make the replacing of Evaluators= more robust"); 42Contracts.Check(match.Success, "Unable to retrieve number of evaluators from ini");

Dirty\ModelParametersBase.cs (4)

26Contracts.CheckValue(env, nameof(env)); 34Contracts.CheckValue(env, nameof(env)); 61Contracts.AssertValue(ctx); 80Contracts.CheckValue(provider, nameof(provider));

Dirty\PredictionUtils.cs (2)

43Contracts.Assert(false); 48throw Contracts.Except(errorMsg);

Dirty\PredictorUtils.cs (5)

20Contracts.CheckValue(ch, nameof(ch)); 40Contracts.CheckValue(ch, nameof(ch)); 72Contracts.CheckValue(ch, nameof(ch)); 87Contracts.CheckValue(ch, nameof(ch)); 119Contracts.CheckValue(ch, nameof(ch));

EntryPoints\EntryPointNode.cs (29)

EntryPoints\InputBase.cs (1)

43Contracts.CheckValueOrNull(ectx);

EntryPoints\InputBuilder.cs (26)

EntryPoints\PredictorModelImpl.cs (11)

32Contracts.CheckValue(env, nameof(env)); 44Contracts.CheckValue(env, nameof(env)); 62Contracts.AssertValue(transformModel); 63Contracts.AssertValue(predictor); 64Contracts.AssertValue(roleMappings); 72Contracts.CheckValue(env, nameof(env)); 92Contracts.CheckValue(env, nameof(env)); 95Contracts.AssertValue(newTransformModel); 101Contracts.CheckValue(env, nameof(env)); 111Contracts.CheckValue(env, nameof(env)); 140Contracts.CheckValue(env, nameof(env));

EntryPoints\SchemaManipulation.cs (3)

20Contracts.CheckValue(env, nameof(env)); 32Contracts.CheckValue(env, nameof(env)); 44Contracts.CheckValue(env, nameof(env));

EntryPoints\SelectRows.cs (4)

21Contracts.CheckValue(env, nameof(env)); 34Contracts.CheckValue(env, nameof(env)); 46Contracts.CheckValue(env, nameof(env)); 58Contracts.CheckValue(env, nameof(env));

EntryPoints\SummarizePredictor.cs (1)

34Contracts.CheckValue(env, nameof(env));

EntryPoints\TransformModelImpl.cs (8)

62Contracts.CheckValue(env, nameof(env)); 73Contracts.AssertValue(env); 86Contracts.CheckValue(env, nameof(env)); 110Contracts.CheckValue(env, nameof(env)); 138Contracts.CheckValue(env, nameof(env)); 148Contracts.CheckValue(env, nameof(env)); 171Contracts.CheckValue(env, nameof(env)); 205Contracts.CheckValue(ectx, nameof(ectx));

Evaluators\AnomalyDetectionEvaluator.cs (5)

244Contracts.Assert(!Single.IsNaN(label)); 282Contracts.Assert(truePositives <= NumAnomalies); 570Contracts.Assert(!IsActive()); 724Contracts.Assert(hasStrat == hasStratVals); 816Contracts.CheckValue(env, nameof(env));

Evaluators\AucAggregator.cs (14)

Evaluators\BinaryClassifierEvaluator.cs (8)

193Contracts.CheckValue(schema, nameof(schema)); 194Contracts.CheckParam(schema.Label != null, nameof(schema), "Could not find the label column"); 702Contracts.Assert(!IsActive()); 1108Contracts.CheckValue(env, nameof(env)); 1117Contracts.CheckValue(ctx, nameof(ctx)); 1129Contracts.Assert(FloatUtils.IsFinite(_threshold)); 1131Contracts.Assert(!string.IsNullOrEmpty(_probCol) || _useRaw); 1505Contracts.CheckValue(env, nameof(env));

Evaluators\ClusteringEvaluator.cs (5)

329Contracts.Assert(features.HasValue); 339Contracts.Assert(Utils.Size(scores) == _numClusters); 340Contracts.Assert(Utils.Size(indices) == _numClusters); 623Contracts.CheckValue(env, nameof(env)); 860Contracts.CheckValue(env, nameof(env));

Evaluators\EvaluatorBase.cs (13)

27Contracts.CheckValue(env, nameof(env)); 250Contracts.AssertValue(env); 350Contracts.AssertValue(schema); 351Contracts.AssertNonWhiteSpace(stratCol); 352Contracts.AssertValue(createAgg); 367Contracts.AssertNonWhiteSpace(stratCol); 368Contracts.AssertValue(createAgg); 372throw Contracts.ExceptUserArg(nameof(MamlEvaluatorBase.ArgumentsBase.StratColumns), 409Contracts.Assert(stratType.RawType == typeof(TStrat)); 417Contracts.Assert(col.HasValue); 419Contracts.AssertValue(_stratGetter); 481Contracts.AssertValue(env); 482Contracts.AssertNonEmpty(scoreCol);

Evaluators\EvaluatorUtils.cs (46)

Evaluators\MamlEvaluator.cs (1)

98Contracts.CheckValue(env, nameof(env));

Evaluators\Metrics\ConfusionMatrix.cs (1)

68Contracts.AssertValue(host);

Evaluators\MulticlassClassificationEvaluator.cs (2)

670Contracts.CheckValue(env, nameof(env)); 1093Contracts.CheckValue(env, nameof(env));

Evaluators\MultiOutputRegressionEvaluator.cs (14)

240Contracts.AssertValue(lossFunction); 241Contracts.Assert(size > 0); 250Contracts.Assert(length == _l1Loss.Length); 251Contracts.Assert(score.Length >= length); 252Contracts.Assert(label.Length >= length); 304Contracts.Assert(PassNum < 1); 305Contracts.Assert(schema.Label.HasValue); 311Contracts.AssertValue(_labelGetter); 312Contracts.AssertValue(_scoreGetter); 321Contracts.Check(_label.Length == _size); 323Contracts.Check(_score.Length == _size); 421Contracts.CheckValue(env, nameof(env)); 430Contracts.CheckValue(ctx, nameof(ctx)); 776Contracts.CheckValue(env, nameof(env));

Evaluators\QuantileRegressionEvaluator.cs (8)

125Contracts.Assert(size > 0); 140Contracts.Check(score.Length == TotalL1Loss.Length, "Vectors must have the same dimensionality."); 172Contracts.Check(loss.Length == TotalL1Loss.Length, "Vectors must have the same dimensionality."); 193Contracts.Assert(SumWeights > 0); 194Contracts.Assert(src.IsDense); 319Contracts.CheckValue(env, nameof(env)); 328Contracts.CheckValue(ctx, nameof(ctx)); 561Contracts.CheckValue(env, nameof(env));

Evaluators\RankingEvaluator.cs (17)

Evaluators\RegressionEvaluator.cs (4)

74Contracts.CheckParam(schema.Label.HasValue, nameof(schema), "Could not find the label column"); 237Contracts.CheckValue(env, nameof(env)); 246Contracts.CheckValue(ctx, nameof(ctx)); 388Contracts.CheckValue(env, nameof(env));

Evaluators\RegressionEvaluatorBase.cs (4)

202Contracts.Assert(PassNum < 1); 203Contracts.Assert(schema.Label.HasValue); 209Contracts.AssertValue(_labelGetter); 210Contracts.AssertValue(_scoreGetter);

Model\ModelOperationsCatalog.cs (1)

27Contracts.AssertValue(env);

Model\Pfa\BoundPfaContext.cs (1)

47Contracts.CheckValue(env, nameof(env));

Model\Pfa\ModelUtils.cs (3)

27Contracts.Assert(1 < firstNonUpper && firstNonUpper <= name.Length); 36Contracts.CheckNonEmpty(name, nameof(name)); 37Contracts.CheckValue(contains, nameof(contains));

Model\Pfa\PfaContext.cs (5)

100Contracts.CheckValue(env, nameof(env)); 186Contracts.CheckValue(name, nameof(name)); 188throw Contracts.ExceptParam(nameof(name), $"Cell {name} already exists"); 189Contracts.CheckValue(type, nameof(type)); 190Contracts.CheckValue(init, nameof(init));

Model\Pfa\PfaUtils.cs (24)

Model\Pfa\SavePfaCommand.cs (2)

169Contracts.CheckUserArg(_loadPredictor != true, 176Contracts.CheckUserArg(_loadPredictor != true,

Prediction\Calibrator.cs (36)

Prediction\CalibratorCatalog.cs (4)

173: base(Contracts.CheckRef(env, nameof(env)).Register(nameof(CalibratorTransformer<TICalibrator>))) 182: base(Contracts.CheckRef(env, nameof(env)).Register(nameof(CalibratorTransformer<TICalibrator>))) 184Contracts.AssertValue(ctx); 214Contracts.AssertValue(ctx);

Prediction\PredictionEngine.cs (3)

24Contracts.AssertValue(env); 75Contracts.CheckValue(example, nameof(example)); 111Contracts.CheckValue(env, nameof(env));

Scorers\BinaryClassifierScorer.cs (14)

57Contracts.CheckValue(env, nameof(env)); 89Contracts.AssertValue(mapper); 90Contracts.AssertValue(labelNameType); 107Contracts.AssertValue(env); 128Contracts.CheckRef(args, nameof(args)).ThresholdColumn, OutputTypeMatches, GetPredColType) 130Contracts.CheckValue(args, nameof(args)); 131Contracts.CheckValue(data, nameof(data)); 132Contracts.CheckValue(mapper, nameof(mapper)); 146Contracts.AssertValue(ctx); 154Contracts.CheckDecode(cbFloat == sizeof(float)); 160Contracts.CheckValue(env, nameof(env)); 171Contracts.AssertValue(ctx); 226Contracts.CheckValue(env, nameof(env)); 285Contracts.CheckParam(Utils.Size(mapperOutputs) >= 1, nameof(mapperOutputs));

Scorers\ClusteringScorer.cs (10)

65Contracts.CheckValue(env, nameof(env)); 76Contracts.AssertValue(ctx); 87Contracts.CheckValue(env, nameof(env)); 88Contracts.CheckValue(newSource, nameof(newSource)); 95Contracts.AssertValue(output); 96Contracts.Assert(output.Schema == Bindings.RowMapper.OutputSchema); 97Contracts.Assert(output.IsColumnActive(output.Schema[Bindings.ScoreColumnIndex])); 110Contracts.Check(score.Length == scoreLength); 121Contracts.Check(score.Length == scoreLength); 131Contracts.Assert(Utils.Size(mapperOutputs) == 1);

Scorers\FeatureContributionCalculation.cs (22)

Scorers\GenericScorer.cs (20)

Scorers\MulticlassClassificationScorer.cs (28)

Scorers\PredictedLabelScorerBase.cs (19)

56Contracts.AssertNonEmpty(scoreColumnKind); 57Contracts.Assert(DerivedColumnCount == 1); 77Contracts.Assert(trainLabelColVecType.Size > 0); 86Contracts.AssertValue(meta); 87Contracts.Assert(metaCol.Type.RawType == typeof(T)); 96Contracts.AssertValue(input); 97Contracts.AssertValue(mapper); 98Contracts.AssertValueOrNull(suffix); 99Contracts.AssertNonEmpty(scoreColKind); 107Contracts.AssertValue(env); 129Contracts.AssertValue(env); 160Contracts.AssertValue(ctx); 173Contracts.Assert(0 <= iinfo && iinfo < InfoCount); 181Contracts.Assert(0 <= iinfo && iinfo < InfoCount); 204Contracts.Assert(0 <= iinfo && iinfo < InfoCount); 248Contracts.Assert(0 <= iinfo && iinfo < InfoCount); 255Contracts.Assert(0 <= iinfo && iinfo < DerivedColumnCount); 261Contracts.Assert(DerivedColumnCount == 1); 285: base(env, data, registrationName, Contracts.CheckRef(mapper, nameof(mapper)).Bindable)

Scorers\PredictionTransformer.cs (24)

Scorers\QuantileRegressionScorer.cs (5)

42Contracts.CheckValue(env, nameof(env)); 55Contracts.CheckUserArg(quantiles != null, nameof(Arguments.Quantiles), "Quantiles are required"); 61throw Contracts.ExceptUserArg(nameof(Arguments.Quantiles), "Cannot parse quantile '{0}' as double.", v); 62Contracts.CheckUserArg(0 <= q && q <= 1, nameof(Arguments.Quantiles), "Quantile must be between 0 and 1."); 65Contracts.CheckUserArg(quantilesArray.Length > 0, nameof(Arguments.Quantiles), "There must be at least one quantile.");

Scorers\RowToRowScorerBase.cs (32)

Scorers\SchemaBindablePredictorWrapper.cs (81)

Scorers\ScoreSchemaFactory.cs (7)

25Contracts.CheckValue(scoreType, nameof(scoreType)); 26Contracts.CheckNonEmpty(scoreColumnKindValue, nameof(scoreColumnKindValue)); 82Contracts.CheckValue(scoreType, nameof(scoreType)); 83Contracts.CheckValue(scoreType as PrimitiveDataViewType, nameof(scoreType)); 84Contracts.AssertValue(quantiles); 119Contracts.CheckValue(scoreType, nameof(scoreType)); 120Contracts.CheckValue(scoreColumnKindValue, nameof(scoreColumnKindValue));

TrainCatalog.cs (1)

137Contracts.CheckValue(env, nameof(env));

Training\TrainerEstimatorBase.cs (2)

63Contracts.CheckValue(host, nameof(host)); 135Contracts.CheckParam(labelCol.IsValid, nameof(labelCol), "not initialized properly");

Training\TrainerUtils.cs (70)

Transforms\BootstrapSamplingTransformer.cs (2)

155Contracts.CheckValue(env, nameof(env)); 256Contracts.CheckValue(env, nameof(env));

Transforms\CatalogUtils.cs (1)

15public static IHostEnvironment GetEnvironment(this IInternalCatalog catalog) => Contracts.CheckRef(catalog, nameof(catalog)).Environment;

Transforms\ColumnBindingsBase.cs (71)

Transforms\ColumnConcatenatingEstimator.cs (1)

53Contracts.CheckValue(env, nameof(env));

Transforms\ColumnConcatenatingTransformer.cs (55)

Transforms\ColumnCopying.cs (6)

64: base(Contracts.CheckRef(env, nameof(env)).Register(nameof(ColumnCopyingEstimator)), new ColumnCopyingTransformer(env, columns)) 116: base(Contracts.CheckRef(env, nameof(env)).Register(nameof(ColumnCopyingTransformer)), columns) 124Contracts.AssertNonEmpty(str); 134Contracts.AssertValue(sb); 149Contracts.CheckValue(env, nameof(env)); 159Contracts.CheckValue(env, nameof(env));

Transforms\ColumnSelecting.cs (11)

98: base(Contracts.CheckRef(env, nameof(env)).Register(nameof(ColumnSelectingEstimator)), 227_host = Contracts.CheckRef(env, nameof(env)).Register(nameof(ColumnSelectingTransformer)); 279Contracts.CheckDecode(count > 0); 285Contracts.CheckDecode(names.Add(name)); 345Contracts.Assert(Enum.IsDefined(typeof(HiddenColumnOption), hiddenOption)); 350Contracts.CheckDecode(count >= 0); 357Contracts.CheckDecode(names.Add(dst)); 361Contracts.Assert(Enum.IsDefined(typeof(HiddenColumnOption), colHiddenOption)); 404Contracts.CheckValue(env, nameof(env)); 436Contracts.CheckValue(env, nameof(env)); 661_host = Contracts.CheckRef(env, nameof(env)).Register(nameof(SelectColumnsDataTransform));

Transforms\ExtensionsCatalog.cs (1)

38Contracts.CheckNonEmpty(outputColumnName, nameof(outputColumnName));

Transforms\FeatureContributionCalculationTransformer.cs (12)

90: base(Contracts.CheckRef(env, nameof(env)).Register(nameof(FeatureContributionCalculatingTransformer)), new[] { (name: DefaultColumnNames.FeatureContributions, source: featureColumnName) }) 110: base(Contracts.CheckRef(env, nameof(env)).Register(nameof(FeatureContributionCalculatingTransformer)), ctx) 123Contracts.CheckDecode(0 <= Top); 125Contracts.CheckDecode(0 <= Bottom); 143Contracts.Assert(0 <= Top); 145Contracts.Assert(0 <= Bottom); 153Contracts.CheckValue(env, nameof(env)); 206Contracts.CheckValue(input, nameof(input)); 215Contracts.AssertValue(input); 216Contracts.AssertValue(_parent._predictor); 327: base(Contracts.CheckRef(env, nameof(env)).Register(nameof(FeatureContributionCalculatingTransformer)), 369Contracts.CheckValue(env, nameof(env));

Transforms\GenerateNumberTransform.cs (16)

Transforms\Hashing.cs (39)

Transforms\InvertHashUtils.cs (25)

Transforms\KeyToValue.cs (10)

51Contracts.AssertValue(sb); 94: base(Contracts.CheckRef(env, nameof(env)).Register(nameof(KeyToValueMappingTransformer)), columns) 104Contracts.CheckValue(env, nameof(env)); 118Contracts.CheckValue(env, nameof(env)); 228Contracts.Assert(types[iinfo] == null); 291Contracts.AssertValue(mapper); 464Contracts.AssertValue(ctx); 465Contracts.AssertValue(srcToken); 621: base(Contracts.CheckRef(env, nameof(env)).Register(nameof(KeyToValueMappingEstimator)), new KeyToValueMappingTransformer(env, outputColumnName, inputColumnName ?? outputColumnName)) 626: base(Contracts.CheckRef(env, nameof(env)).Register(nameof(KeyToValueMappingEstimator)), new KeyToValueMappingTransformer(env, columns))

Transforms\KeyToVector.cs (18)

50Contracts.AssertValue(sb); 58Contracts.AssertValue(sb); 59Contracts.AssertNonEmpty(extra); 71Contracts.AssertNonEmpty(str); 81Contracts.AssertValue(sb); 103Contracts.CheckValue(columns, nameof(columns)); 123base(Contracts.CheckRef(env, nameof(env)).Register(RegistrationName), GetColumnPairs(columns)) 163Contracts.CheckValue(env, nameof(env)); 195Contracts.CheckValue(env, nameof(env)); 378Contracts.AssertValue(inputMetadata); 405Contracts.Assert(slot == (long)kvpSlot.Key * keyCount); 662Contracts.AssertValue(ctx); 663Contracts.Assert(0 <= iinfo && iinfo < _infos.Length); 664Contracts.Assert(_infos[iinfo] == info); 665Contracts.AssertValue(srcToken); 666Contracts.Assert(CanSavePfa); 792Contracts.CheckNonWhiteSpace(name, nameof(name)); 810: base(Contracts.CheckRef(env, nameof(env)).Register(nameof(KeyToVectorMappingEstimator)), transformer)

Transforms\LabelConvertTransform.cs (14)

31Contracts.AssertNonEmpty(str); 41Contracts.AssertValue(sb); 83: base(env, RegistrationName, Contracts.CheckRef(args, nameof(args)).Columns, input, RowCursorUtils.TestGetLabelGetter) 85Contracts.AssertNonEmpty(Infos); 86Contracts.Assert(Infos.Length == Utils.Size(args.Columns)); 93Contracts.AssertValue(ctx); 104Contracts.CheckValue(env, nameof(env)); 139Contracts.Assert(0 <= iinfo && iinfo < Infos.Length); 161Contracts.AssertNonEmpty(kind); 162Contracts.Assert(0 <= iinfo && iinfo < Infos.Length); 172Contracts.AssertValueOrNull(ch); 173Contracts.AssertValue(input); 174Contracts.Assert(0 <= iinfo && iinfo < Infos.Length); 179Contracts.Assert(RowCursorUtils.TestGetLabelGetter(typeSrc) == null);

Transforms\LabelIndicatorTransform.cs (6)

54Contracts.AssertNonEmpty(str); 64Contracts.AssertValue(sb); 81Contracts.CheckValue(env, nameof(env)); 92Contracts.CheckValue(env, nameof(env)); 134: base(env, LoadName, Contracts.CheckRef(options, nameof(options)).Columns, 233Contracts.CheckValue(env, nameof(env));

Transforms\MetadataDispatcher.cs (42)

Transforms\NAFilter.cs (17)

Transforms\NopTransform.cs (7)

46Contracts.CheckValue(env, nameof(env)); 72Contracts.CheckValue(env, nameof(env)); 82Contracts.AssertValue(host, "host"); 134Contracts.CheckValue(input, nameof(input)); 135Contracts.CheckValue(activeColumns, nameof(activeColumns)); 136Contracts.CheckParam(input.Schema == Source.Schema, nameof(input), "Schema of input row must be the same as the schema the mapper is bound to"); 147Contracts.CheckValue(env, nameof(env));

Transforms\NormalizeColumn.cs (39)

Transforms\NormalizeColumnDbl.cs (102)

Transforms\NormalizeColumnSng.cs (104)

Transforms\Normalizer.cs (27)

Transforms\NormalizeUtils.cs (5)

82Contracts.CheckValue(env, nameof(env)); 94Contracts.CheckValue(env, nameof(env)); 106Contracts.CheckValue(env, nameof(env)); 118Contracts.CheckValue(env, nameof(env)); 130Contracts.CheckValue(env, nameof(env));

Transforms\OneToOneTransformerBase.cs (4)

30throw Contracts.ExceptParam(nameof(columns), $"Name of the result column '{column.outputColumnName}' specified multiple times"); 76Contracts.AssertValue(inputSchema); 77Contracts.Assert(0 <= col && col < ColumnPairs.Length); 98Contracts.AssertValue(parent);

Transforms\PerGroupTransformBase.cs (7)

57Contracts.ExceptDecode("Group column '{0}' does not exist", groupCol); 64Contracts.AssertValue(predicate); 104Contracts.CheckValue(env, nameof(env)); 119Contracts.CheckValue(env, nameof(env)); 187Contracts.Assert(active.Length == bindings.ColumnCount); 293Contracts.CheckParam(IsColumnActive(column), nameof(column), "requested column is not active"); 299Contracts.AssertValue(_input);

Transforms\RangeFilter.cs (3)

169Contracts.CheckValue(env, nameof(env)); 335Contracts.Assert(filter._type is KeyDataViewType); 343Contracts.Assert(filter._type is KeyDataViewType);

Transforms\RowShufflingTransformer.cs (11)

Transforms\RowToRowTransformerBase.cs (4)

21Contracts.AssertValue(host); 66Contracts.CheckValue(host, nameof(host)); 67Contracts.CheckValue(inputSchema, nameof(inputSchema)); 84Contracts.Assert(input.Schema == InputSchema);

Transforms\SkipTakeFilter.cs (4)

125Contracts.CheckValue(env, nameof(env)); 136Contracts.CheckValue(env, nameof(env)); 144Contracts.CheckValue(env, nameof(env)); 153Contracts.CheckValue(env, nameof(env));

Transforms\SlotsDroppingTransformer.cs (36)

Transforms\TrainAndScoreTransformer.cs (5)

80Contracts.CheckValue(env, nameof(env)); 184Contracts.CheckValue(env, nameof(env)); 204Contracts.CheckValue(env, nameof(env)); 216Contracts.CheckValue(env, nameof(env)); 228Contracts.AssertValue(env, nameof(env));

Transforms\TransformBase.cs (16)

Transforms\TransformsCatalog.cs (1)

39Contracts.AssertValue(env);

Transforms\TypeConverting.cs (11)

39Contracts.CheckValue(env, nameof(env)); 80Contracts.AssertNonEmpty(str); 97Contracts.AssertValue(sb); 180Contracts.CheckNonEmpty(columns, nameof(columns)); 201: base(Contracts.CheckRef(env, nameof(env)).Register(nameof(TypeConvertingTransformer)), GetColumnPairs(columns)) 238Contracts.CheckValue(env, nameof(env)); 297Contracts.CheckValue(env, nameof(env)); 469Contracts.AssertValue(input); 470Contracts.Assert(0 <= iinfo && iinfo < _parent.ColumnPairs.Length); 590throw Contracts.ExceptUserArg(nameof(type), $"Unsupported type {type}."); 614base(Contracts.CheckRef(env, nameof(env)).Register(nameof(TypeConvertingEstimator)), new TypeConvertingTransformer(env, columns))

Transforms\ValueMapping.cs (8)

79: base(Contracts.CheckRef(env, nameof(env)).Register(nameof(ValueMappingEstimator)), 403Contracts.AssertValue(sb); 433: base(Contracts.CheckRef(env, nameof(env)).Register(nameof(ValueMappingTransformer)), columns) 604Contracts.CheckValue(env, nameof(env)); 712Contracts.CheckValue(env, nameof(env)); 747Contracts.AssertValue(ectx); 778throw Contracts.Except($"Unsupported type {type} used in mapping."); 985Contracts.AssertValue(host);

Transforms\ValueToKeyMappingEstimator.cs (3)

97Contracts.CheckNonWhiteSpace(outputColumnName, nameof(outputColumnName)); 154Contracts.CheckValue(env, nameof(env)); 198Contracts.Assert(kv.IsValid);

Transforms\ValueToKeyMappingTransformer.cs (16)

Transforms\ValueToKeyMappingTransformerImpl.cs (48)

Utilities\ApplyTransformUtils.cs (2)

28Contracts.CheckValue(env, nameof(env)); 70Contracts.CheckValue(env, nameof(env));

Utilities\ColumnCursor.cs (13)

Utilities\ComponentCreation.cs (17)

Utilities\LocalEnvironment.cs (16)

68Contracts.AssertValue(rand); 69Contracts.AssertValueOrNull(parentFullName); 70Contracts.AssertNonEmpty(shortName); 71Contracts.Assert(source == this || source is Host); 77Contracts.AssertValue(parent); 78Contracts.Assert(parent is LocalEnvironment); 79Contracts.AssertNonEmpty(name); 85Contracts.AssertValue(parent); 86Contracts.Assert(parent is LocalEnvironment); 87Contracts.AssertNonEmpty(name); 101Contracts.AssertValue(parent); 102Contracts.Assert(parent is Host); 103Contracts.AssertNonEmpty(name); 109Contracts.AssertValue(parent); 110Contracts.Assert(parent is Host); 111Contracts.AssertNonEmpty(name);

Utilities\ModelFileUtils.cs (26)

Utilities\SlotDropper.cs (17)

40Contracts.CheckValue(slotsMin, nameof(slotsMin)); 41Contracts.CheckValue(slotsMax, nameof(slotsMax)); 42Contracts.CheckNonEmpty(slotsMin, nameof(slotsMin)); 43Contracts.CheckNonEmpty(slotsMax, nameof(slotsMax)); 44Contracts.CheckParam(slotsMin.Length == slotsMax.Length, 52Contracts.Check(SlotsMin.Length == _lengthReduction.Length); 64Contracts.Assert(dstLength >= 0); 75Contracts.Assert(SlotsMin[i] > prevLim); 76Contracts.Assert(SlotsMin[i] <= SlotsMax[i]); 119Contracts.Assert(newLength < src.Length); 136Contracts.Assert(iDst <= iSrc); 143Contracts.Assert(iDst <= iSrc); 146Contracts.Assert(iDst == newLength); 157Contracts.Assert(newCount <= src.Length); 179Contracts.Assert(iiDst <= iiSrc); 200Contracts.Assert(iRange == SlotsMax.Length || 214Contracts.Assert(index <= max);

Utilities\TimerScope.cs (1)

25Contracts.AssertValue(ch);

Utilities\TypeParsingUtils.cs (10)

29Contracts.CheckValue(str, nameof(str)); 57Contracts.CheckValue(keyCount, nameof(keyCount)); 61Contracts.CheckUserArg(KeyDataViewType.IsValidDataType(rawType), nameof(TextLoader.Column.Type), "Bad item type for Key"); 90throw Contracts.ExceptParam(nameof(count), "The cardinality of valid values of a " 103Contracts.AssertValue(str); 113Contracts.AssertValue(str); 128throw Contracts.ExceptDecode("The minimum logical value of a " + nameof(KeyDataViewType) + " is required to be zero."); 145Contracts.CheckDecode(Count == null || Count > 0); 151Contracts.AssertValue(sb); 152Contracts.Assert(Count == null || Count > 0);

Utils\ApiUtils.cs (5)

60throw Contracts.ExceptNotSupp("Type '{0}' is not supported.", t.FullName); 83Contracts.Assert(false); 84throw Contracts.ExceptNotSupp("Expected a FieldInfo or a PropertyInfo"); 151Contracts.Assert(false); 152throw Contracts.ExceptNotSupp("Expected a FieldInfo or a PropertyInfo");

Utils\LossFunctions.cs (3)

337Contracts.CheckParam(smoothingConstant >= 0, nameof(smoothingConstant), "Must be non-negative."); 598Contracts.CheckUserArg(1 <= options.Index && options.Index <= 2, nameof(options.Index), "Must be in the range [1, 2]"); 611Contracts.CheckParam(1 <= index && index <= 2, nameof(index), "Must be in the range [1, 2]");

Utils\SequencePool.cs (37)