Assert

Commands\ShowSchemaCommand.cs (9)

187Contracts.Assert(0 <= col && col < schema.Count); 211Contracts.Assert(0 <= col && col < schema.Count); 214Contracts.Assert(!(type is VectorDataViewType)); 231Contracts.Assert(0 <= col && col < schema.Count); 234Contracts.Assert(!(type is VectorDataViewType)); 235Contracts.Assert(type.RawType == typeof(T)); 251Contracts.Assert(0 <= col && col < schema.Count); 270Contracts.Assert(0 <= col && col < schema.Count); 273Contracts.Assert(type.ItemType.RawType == typeof(T));

Data\BufferBuilder.cs (29)

Data\Conversion.cs (26)

462Contracts.Assert(typeSrc is KeyDataViewType || typeSrc.IsStandardScalar()); 463Contracts.Assert(typeDst is KeyDataViewType || typeDst.IsStandardScalar()); 548Contracts.Assert(_tryParseDelegates.ContainsKey(typeDst.RawType)); 554Contracts.Assert(key.RawType == typeof(TDst)); 581Contracts.Assert(key.RawType == typeof(TDst)); 654Contracts.Assert(del is InPredicate<T>); 668Contracts.Assert(_isDefaultDelegates.ContainsKey(t.RawType)); 677Contracts.Assert(del != null); 691Contracts.Assert(_hasZeroDelegates.ContainsKey(t.RawType)); 742Contracts.Assert(!((InPredicate<T>)isDefPred)(in res)); 1088Contracts.Assert(offset == src.Length); 1103Contracts.Assert(!span.IsEmpty); 1162Contracts.Assert(max < U8.MaxValue); 1226Contracts.Assert(res.HasValue); 1245Contracts.Assert(res.HasValue); 1264Contracts.Assert(res.HasValue); 1283Contracts.Assert(res.HasValue); 1297Contracts.Assert(res >= 0); 1328Contracts.Assert(max > 0); 1329Contracts.Assert((max & (max + 1)) == 0); 1346Contracts.Assert(val >= 0); 1348Contracts.Assert(long.MinValue <= result && result <= 0); 1359Contracts.Assert(sVal >= 0); 1367Contracts.Assert(0 <= result && result <= long.MaxValue); 1680Contracts.Assert(value.Equals(default(UG))); 1706Contracts.Assert(!value);

Data\DataViewUtils.cs (19)

643Contracts.Assert(0 <= col && col < _schema.Count); 658Contracts.Assert(0 <= poolIdx && poolIdx < _cachePools.Length); 737Contracts.Assert(typeof(T) == type.RawType); 754Contracts.Assert(count > 0); 765Contracts.Assert(Utils.Size(values) >= count); 800Contracts.Assert(count > 0); 801Contracts.Assert(batchId >= 0); 802Contracts.Assert(batchColumns.All(bc => bc.Count == count)); 808Contracts.Assert(!HasException); 819Contracts.Assert(HasException); 833Contracts.Assert(Utils.Size(pipes) == _batchColumns.Length); 871Contracts.Assert(type is PrimitiveDataViewType); 902Contracts.Assert(_index < _count); 913Contracts.Assert(pool is MadeObjectPool<T[]>); 920Contracts.Assert(getter is ValueGetter<T>); 927Contracts.Assert(batchCol is BatchColumn.Impl<T>); 931Contracts.Assert(_count == 0 || (_index == _count - 1)); 939Contracts.Assert(_count <= Utils.Size(Values)); 944Contracts.Assert(_index <= _count);

Data\RowCursorUtils.cs (10)

92Contracts.Assert(typeof(TSrc) == typeSrc.RawType); 93Contracts.Assert(typeof(TDst) == typeDst.RawType); 100Contracts.Assert(typeof(TSrc) == typeof(TDst)); 134Contracts.Assert(typeof(TSrc) == typeSrc.RawType); 257Contracts.Assert(typeof(TSrc) == typeSrc.ItemType.RawType); 258Contracts.Assert(typeof(TDst) == typeDst.RawType); 266Contracts.Assert(typeof(TSrc) == typeof(TDst)); 378Contracts.Assert(type != NumberDataViewType.Single && type != NumberDataViewType.Double); 396Contracts.Assert(TestGetLabelGetter(type) == null); 425Contracts.Assert(TestGetLabelGetter(type) == null);

Data\SchemaDefinition.cs (2)

195Contracts.Assert(false); 372Contracts.Assert(false);

DataLoadSave\Binary\BinaryLoader.cs (30)

486Contracts.Assert(Header.HeaderSize <= blockOffset); 487Contracts.Assert(0 <= blockSize); 530Contracts.Assert((codec == null) || !Enum.IsDefined(typeof(CompressionKind), compression)); 965Contracts.Assert(threads >= 0); 967Contracts.Assert(0 <= shuffleBlocks); 1366Contracts.Assert(ex.CancellationToken == _exMarshaller.Token); 1368Contracts.Assert(false); 1538Contracts.Assert(blockSequence >= 0); 1539Contracts.Assert(0 <= min && min <= lim); 1540Contracts.Assert(lim - min <= int.MaxValue); 1544Contracts.Assert(!IsSentinel); 1553Contracts.Assert(blockSequence >= 0); 1556Contracts.Assert(IsSentinel); 1721Contracts.Assert(decompressedLength > 0); 1722Contracts.Assert(blockIndex >= 0); 1723Contracts.Assert(blockSequence >= 0); 1724Contracts.Assert(rows >= 0); 1731Contracts.Assert(!IsSentinel); 1740Contracts.Assert(blockSequence >= 0); 1743Contracts.Assert(IsSentinel); 1758Contracts.Assert(rows > 0); 1813Contracts.Assert(tmp); 1818Contracts.Assert(lookup.BlockOffset + lookup.BlockLength == _stream.Position); 1862Contracts.Assert(!_toRead.IsAddingCompleted); 1894Contracts.Assert(tmp); 1910Contracts.Assert(_remaining >= 0); 1911Contracts.Assert(_remaining == 0 || _curr != null); 1927Contracts.Assert(_remaining > 0); 1989Contracts.Assert(ex.CancellationToken == _exMarshaller.Token); 2006Contracts.Assert(false);

DataLoadSave\Binary\BinarySaver.cs (5)

127Contracts.Assert(_writer == null); 134Contracts.Assert(_writer != null); 141Contracts.Assert(_writer != null); 232Contracts.Assert(tmp); 623Contracts.Assert(rows == (blockIndex + 1) * rowsPerBlock - remainingInBlock);

DataLoadSave\Binary\CodecFactory.cs (3)

88Contracts.Assert(!_loadNameToCodecCreator.ContainsKey(codec.LoadName)); 89Contracts.Assert(!_simpleCodecTypeMap.ContainsKey(codec.Type.RawType)); 96Contracts.Assert(!_loadNameToCodecCreator.ContainsKey(name));

DataLoadSave\Binary\Codecs.cs (20)

98Contracts.Assert(0 <= index && index <= Utils.Size(values)); 99Contracts.Assert(0 <= count && count <= Utils.Size(values) - index); 125Contracts.Assert(type.RawType == typeof(T)); 250Contracts.Assert(_remaining > 0); 262Contracts.Assert(0 <= index && index <= Utils.Size(values)); 263Contracts.Assert(0 <= count && count <= Utils.Size(values) - index); 264Contracts.Assert(_remaining >= count); 383Contracts.Assert(_index < _entries); 437Contracts.Assert(0 <= _currentIndex && _currentIndex < 8); 501Contracts.Assert(_currentIndex < 8); 554Contracts.Assert(_currentSlot < 16); 693Contracts.Assert(Utils.Size(_offsets) == Utils.Size(_ticks)); 737Contracts.Assert(!_disposed); 743Contracts.Assert(!_disposed); 791Contracts.Assert(type.RawType == typeof(VBuffer<T>)); 792Contracts.Assert(innerCodec.Type == type.ItemType); 1191Contracts.Assert(type.RawType == typeof(T)); 1192Contracts.Assert(innerCodec.Type.RawType == type.RawType); 1288Contracts.Assert(type.RawType == typeof(T)); 1289Contracts.Assert(innerCodec.Type.RawType == type.RawType);

DataLoadSave\Binary\MemoryStreamPool.cs (3)

34Contracts.Assert(mem.Position == 0); 35Contracts.Assert(mem.Length == 0); 63Contracts.Assert(0 <= index && index < _pools.Length);

DataLoadSave\Database\DatabaseLoader.cs (9)

160Contracts.Assert(false); 335Contracts.Assert(range.Max.HasValue); 368Contracts.Assert(0 <= min && min < lim); 377Contracts.Assert(name != null); 401Contracts.Assert(sizeBase > 0); 404Contracts.Assert(colType.GetItemType().GetRawKind() != 0); 432Contracts.Assert(segs[a].Min <= segs[b].Min); 449Contracts.Assert(size >= segs.Length); 642Contracts.Assert((InternalDataKind)(byte)rawKind == rawKind);

DataLoadSave\Database\DatabaseLoaderCursor.cs (1)

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

DataLoadSave\EstimatorChain.cs (4)

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));

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 (10)

584Contracts.Assert(0 <= min && min < lim && lim <= SrcLim); 595Contracts.Assert(0 <= min && min < SrcLim); 622Contracts.Assert(sizeBase > 0 || isegVar >= 0); 623Contracts.Assert(isegVar >= -1); 627Contracts.Assert(Kind != 0); 649Contracts.Assert(segs[a].Min <= segs[b].Min); 667Contracts.Assert(isegVar == -1); 673Contracts.Assert(size >= segs.Length || size >= segs.Length - 1 && isegVar >= 0); 1022Contracts.Assert((InternalDataKind)(byte)rawKind == rawKind); 1623Contracts.Assert(false);

DataLoadSave\Text\TextLoaderCursor.cs (28)

51Contracts.Assert(active == null || active.Length == parent._bindings.OutputSchema.Count); 72Contracts.Assert(srcNeeded >= 0); 143Contracts.Assert(active == null || active.Length == parent._bindings.OutputSchema.Count); 148Contracts.Assert(cthd > 0); 160Contracts.Assert(active == null || active.Length == parent._bindings.OutputSchema.Count); 165Contracts.Assert(cthd > 0); 212Contracts.Assert(count > 0); 223Contracts.Assert(batch.Exception == null); 396Contracts.Assert(line > 0); 424Contracts.Assert(files.Count >= 0); 425Contracts.Assert(batchSize >= 2); 426Contracts.Assert(bufSize > 0); 427Contracts.Assert(limit >= 0); 428Contracts.Assert(cref > 0); 446Contracts.Assert(n >= 0); 687Contracts.Assert(_batchSize >= 2); 805Contracts.Assert(0 <= total); 806Contracts.Assert(0 <= index && index < Utils.Size(infos)); 853Contracts.Assert(0 <= irowMin && irowMin < irowLim); 854Contracts.Assert(total >= 0); 895Contracts.Assert(cthd > 0); 951Contracts.Assert(0 <= tid && tid < _threads.Length); 975Contracts.Assert(iblk < _blockCount - 3); 998Contracts.Assert(lines.Exception == null); 1003Contracts.Assert(lines.Infos.Length <= BlockSize); 1009Contracts.Assert(info.Line > 0); 1016Contracts.Assert(irow == batch.IrowLim); 1036Contracts.Assert(0 <= iblk && iblk < _blockCount);

DataLoadSave\Text\TextLoaderParser.cs (86)

DataLoadSave\Text\TextSaver.cs (16)

100Contracts.Assert(type.IsStandardScalar() || type is KeyDataViewType); 101Contracts.Assert(type.RawType == typeof(T)); 591Contracts.Assert(len >= 0); 607Contracts.Assert(len >= 0); 629Contracts.Assert(_mpcoldst[_col] == 0); 630Contracts.Assert(_mpcolslot[_col] == 0); 647Contracts.Assert(0 <= _col && _col < _pipes.Length); 678Contracts.Assert(_col < _pipes.Length); 689Contracts.Assert(_col == _pipes.Length); 761Contracts.Assert(_col == _pipes.Length); 762Contracts.Assert(dstLim <= _dstBase); 771Contracts.Assert(slot == _slotLim || slot < _slotLim && dst <= _mpslotdst[slot]); 779Contracts.Assert(col < _pipes.Length); 820Contracts.Assert(ichCur < ichLim); 834Contracts.Assert(ichRun == ichMin); 846Contracts.Assert(ichCur == ichLim);

DataLoadSave\Transpose\TransposeLoader.cs (2)

223Contracts.Assert(view != null); 711Contracts.Assert(pos <= int.MaxValue);

DataView\ArrayDataViewBuilder.cs (3)

383Contracts.Assert(typeof(TOut) == type.RawType); 413Contracts.Assert(0 <= index && index < _values.Length); 465Contracts.Assert(itemType.RawType == typeof(TOut));

DataView\BatchDataViewMapperBase.cs (1)

48Contracts.Assert(active.Length == SchemaBindings.ColumnCount);

DataView\CacheDataView.cs (22)

613Contracts.Assert(rowCount.HasValue); 620Contracts.Assert(pos >= 0); 670Contracts.Assert(pred(c)); 768Contracts.Assert(_curr >= 0); 785Contracts.Assert(_curr >= -1); // Should not be called when _curr = -2. 833Contracts.Assert(0 <= _curr && _curr < _perm.Length); 849Contracts.Assert(_curr >= -1); // Should not be called when _curr = -2. 852Contracts.Assert(_perm[_curr] >= 0); 856Contracts.Assert(result); 969Contracts.Assert(_curr >= 0); 985Contracts.Assert(_curr >= -1); 990Contracts.Assert(_reserved); 1004Contracts.Assert(_waiter.Wait(_curr)); 1012Contracts.Assert((_curr & _batchMask) < _batchMask); 1075Contracts.Assert(0 <= _curr && _curr < _perm.Length); 1091Contracts.Assert(_curr >= -1); // Should not be called when _curr = -2. 1109Contracts.Assert(0 <= _curr && _curr <= _currMax); 1111Contracts.Assert(result); 1440Contracts.Assert(0 <= _rowCount && _rowCount < int.MaxValue); 1450Contracts.Assert(0 <= idx && idx < _rowCount); 1469Contracts.Assert(0 <= srcCol && srcCol < input.Schema.Count); 1470Contracts.Assert(input.Schema[srcCol].Type.RawType == typeof(T));

DataView\DataViewConstructionUtils.cs (7)

878Contracts.Assert(value != null); 917Contracts.Assert(AnnotationType is VectorDataViewType); 941Contracts.Assert(typeT.IsGenericType); 943Contracts.Assert(typeT.GetGenericTypeDefinition() == typeof(VBuffer<>)); 947Contracts.Assert(itemType == annotationVectorType.ItemType.RawType); 957Contracts.Assert(AnnotationType is TextDataViewType); 962Contracts.Assert(AnnotationType.RawType == typeT);

DataView\InternalSchemaDefinition.cs (10)

100Contracts.Assert(IsComputed == (Generator != null)); 103Contracts.Assert((Generator == null) != (MemberInfo == null)); 113Contracts.Assert(parameterTypes.Length == 3); 114Contracts.Assert(parameterTypes[2].IsByRef); 115Contracts.Assert(parameterTypes[1] == typeof(long)); 116Contracts.Assert(!(parameterTypes[0].GetTypeInfo().IsPrimitive || parameterTypes[0] == typeof(string))); 119Contracts.Assert(Generator.GetMethodInfo().ReturnType == typeof(void)); 123Contracts.Assert(isVector == ColumnType is VectorDataViewType); 124Contracts.Assert(itemType == ColumnType.GetItemType().RawType); 158Contracts.Assert(false);

DataView\RowToRowMapperTransform.cs (5)

151Contracts.Assert(active.Length == n); 154Contracts.Assert(activeInput.Length == _bindings.InputSchema.Count); 171Contracts.Assert(active.Length == _bindings.Schema.Count); 176Contracts.Assert(0 <= col && col < _bindings.AddedColumnIndices.Count); 337Contracts.Assert(originFn != null);

DataView\Transposer.cs (16)

914Contracts.Assert(0 <= col && col < view.Schema.Count); 926Contracts.Assert(type is PrimitiveDataViewType || vectorSize > 0); 953Contracts.Assert(Utils.IsIncreasing(1, ends, vectorSize + 1)); 986Contracts.Assert(input.IsColumnActive(input.Schema[parent.SrcCol])); 1011Contracts.Assert(_view.Schema[col].Type.RawType == typeof(T)); 1025Contracts.Assert(row.Schema == _view.Schema); 1027Contracts.Assert(row.IsColumnActive(row.Schema[SrcCol])); 1038Contracts.Assert(Parent.ColumnCount == 1); 1096Contracts.Assert(Utils.Size(lims) >= 2); 1098Contracts.Assert(type.Size > 0); 1099Contracts.Assert(type.ItemType.RawType == typeof(T)); 1100Contracts.Assert(Utils.IsIncreasing(0, lims, type.Size + 1)); 1101Contracts.Assert(lims[lims.Length - 1] == type.Size); 1119Contracts.Assert(row.Schema == _view.Schema); 1121Contracts.Assert(row.IsColumnActive(row.Schema[SrcCol])); 1227Contracts.Assert(_inputValue.Length == Parent._lims[Parent._lims.Length - 1]);

DataView\TypedCursor.cs (2)

244Contracts.Assert(false); 501Contracts.Assert(peek == null);

DataView\ZipBinding.cs (2)

77Contracts.Assert(0 <= srcIndex && srcIndex < _cumulativeColCounts.Length); 79Contracts.Assert(0 <= srcCol && srcCol < _sources[srcIndex].Count);

Deprecated\Instances\HeaderSchema.cs (13)

46Contracts.Assert(col == 0); 56Contracts.Assert(nameList.Count == indexList.Count); 130Contracts.Assert(iv == cnn); 248Contracts.Assert(0 <= index && index < Count); 298Contracts.Assert(count >= 0); 376Contracts.Assert(count >= 0); 381Contracts.Assert(size > 2 * cnn); 391Contracts.Assert(cv < cnn); 397Contracts.Assert(cv == cnn); 409Contracts.Assert(count >= 0); 412Contracts.Assert(indices.Length == names.Length); 413Contracts.Assert(indices.Length <= count); 441Contracts.Assert(iv == _indices.FindIndexSorted(index));

Deprecated\Vector\GenericSpanSortHelper.cs (18)

91Contracts.Assert(left >= 0); 92Contracts.Assert(length >= 0); 93Contracts.Assert(length <= keys.Length); 94Contracts.Assert(length + left <= keys.Length); 95Contracts.Assert(length + left <= values.Length); 105Contracts.Assert(lo >= 0); 106Contracts.Assert(hi < keys.Length); 150Contracts.Assert(lo >= 0); 151Contracts.Assert(hi > lo); 152Contracts.Assert(hi < keys.Length); 193Contracts.Assert(lo >= 0); 194Contracts.Assert(hi > lo); 195Contracts.Assert(hi < keys.Length); 211Contracts.Assert(lo >= 0); 212Contracts.Assert(lo < keys.Length); 236Contracts.Assert(lo >= 0); 237Contracts.Assert(hi >= lo); 238Contracts.Assert(hi <= keys.Length);

Deprecated\Vector\VBufferMathUtils.cs (15)

117Contracts.Assert(length == count); 205Contracts.Assert(length > 0); 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 (9)

97Contracts.Assert(bottomHeap.Count == bottom); 110Contracts.Assert(topHeap.Count == top); 132Contracts.Assert(count == newCount); 175Contracts.Assert(valuesA.Length == indicesA.Length); 176Contracts.Assert(valuesB.Length == indicesB.Length); 235Contracts.Assert(0 <= length && length <= valuesA.Length); 236Contracts.Assert(0 <= length && length <= valuesB.Length); 323Contracts.Assert(0 <= ia && ia < iaLim && iaLim <= aIndices.Length); 324Contracts.Assert(0 <= ib && ib < ibLim && ibLim <= bIndices.Length);

Dirty\PredictionUtils.cs (1)

43Contracts.Assert(false);

EntryPoints\EntryPointNode.cs (6)

64Contracts.Assert(CheckType(typeof(T))); 104Contracts.Assert(Var<T>.CheckType(typeof(T))); 110Contracts.Assert(Var<T>.CheckType(typeof(T))); 139Contracts.Assert(Var<T>.CheckType(typeof(T))); 205Contracts.Assert(variableType.IsGenericType && variableType.GetGenericTypeDefinition() == typeof(Dictionary<,>) 1177Contracts.Assert(index >= 0);

EntryPoints\InputBuilder.cs (9)

234Contracts.Assert(bindings.Count > 0); 239Contracts.Assert(bindings.Count == 1); 241Contracts.Assert(success); 252Contracts.Assert(parameterBinding is ArrayIndexParameterBinding); 254Contracts.Assert(success); 264Contracts.Assert(paramBinding is DictionaryKeyParameterBinding); 348Contracts.Assert(success); 360Contracts.Assert(success); 393Contracts.Assert(type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Optional<>));

Evaluators\AnomalyDetectionEvaluator.cs (4)

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

Evaluators\AucAggregator.cs (3)

47Contracts.Assert(reservoirSize >= -1); 91Contracts.Assert(_negReservoir != null); 376Contracts.Assert(reservoirSize > 0);

Evaluators\BinaryClassifierEvaluator.cs (3)

702Contracts.Assert(!IsActive()); 1129Contracts.Assert(FloatUtils.IsFinite(_threshold)); 1131Contracts.Assert(!string.IsNullOrEmpty(_probCol) || _useRaw);

Evaluators\ClusteringEvaluator.cs (3)

329Contracts.Assert(features.HasValue); 339Contracts.Assert(Utils.Size(scores) == _numClusters); 340Contracts.Assert(Utils.Size(indices) == _numClusters);

Evaluators\EvaluatorBase.cs (2)

409Contracts.Assert(stratType.RawType == typeof(TStrat)); 417Contracts.Assert(col.HasValue);

Evaluators\EvaluatorUtils.cs (8)

70Contracts.Assert(map.ContainsKey(kind)); 512Contracts.Assert(src.Length == Utils.Size(map)); 536Contracts.Assert(src.Length == Utils.Size(map)); 1211Contracts.Assert(iMetric == metricNames.Count); 1248Contracts.Assert(dst.IsDense); 1551Contracts.Assert(sumSqMetrics != null || numFolds == 1); 1611Contracts.Assert(rowDigitLen >= 1); 1614Contracts.Assert((rowDigitLen == 0) == !useNumbersInHeader);

Evaluators\MultiOutputRegressionEvaluator.cs (6)

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);

Evaluators\QuantileRegressionEvaluator.cs (3)

125Contracts.Assert(size > 0); 193Contracts.Assert(SumWeights > 0); 194Contracts.Assert(src.IsDense);

Evaluators\RankingEvaluator.cs (13)

Evaluators\RegressionEvaluatorBase.cs (2)

202Contracts.Assert(PassNum < 1); 203Contracts.Assert(schema.Label.HasValue);

Model\Pfa\ModelUtils.cs (1)

27Contracts.Assert(1 < firstNonUpper && firstNonUpper <= name.Length);

Prediction\Calibrator.cs (6)

623Contracts.Assert(model != null); 630Contracts.Assert(model != null); 1031Contracts.Assert(predictor != null); 1859Contracts.Assert(minX <= maxX); 1861Contracts.Assert(0 <= value && value <= 1); 1862Contracts.Assert(n >= 0);

Scorers\ClusteringScorer.cs (3)

96Contracts.Assert(output.Schema == Bindings.RowMapper.OutputSchema); 97Contracts.Assert(output.IsColumnActive(output.Schema[Bindings.ScoreColumnIndex])); 131Contracts.Assert(Utils.Size(mapperOutputs) == 1);

Scorers\FeatureContributionCalculation.cs (2)

183Contracts.Assert(0 <= _topContributionsCount); 185Contracts.Assert(0 <= _bottomContributionsCount);

Scorers\GenericScorer.cs (3)

44Contracts.Assert(DerivedColumnCount == 0); 57Contracts.Assert(mapper.InputSchema == input); 77Contracts.Assert(mapper.InputRoleMappedSchema.Schema == input);

Scorers\MulticlassClassificationScorer.cs (6)

193Contracts.Assert(_type.ItemType.RawType == typeof(T)); 194Contracts.Assert(_getter is ValueGetter<VBuffer<T>>); 216Contracts.Assert(_bindable is IBindableCanSavePfa); 225Contracts.Assert(_bindable is IBindableCanSaveOnnx); 234Contracts.Assert(innerBound is ISchemaBoundRowMapper); 599Contracts.Assert(Utils.Size(mapperOutputs) == 1);

Scorers\PredictedLabelScorerBase.cs (9)

57Contracts.Assert(DerivedColumnCount == 1); 77Contracts.Assert(trainLabelColVecType.Size > 0); 87Contracts.Assert(metaCol.Type.RawType == typeof(T)); 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);

Scorers\RowToRowScorerBase.cs (14)

91Contracts.Assert(active.Length == bindings.ColumnCount); 94Contracts.Assert(activeInput.Length == bindings.Input.Count); 207Contracts.Assert(0 <= col && col < row.Schema.Count); 208Contracts.Assert(row.IsColumnActive(row.Schema[col])); 217Contracts.Assert(0 <= col && col < output.Schema.Count); 218Contracts.Assert(output.IsColumnActive(output.Schema[col])); 376Contracts.Assert(dst == count); 430Contracts.Assert(DerivedColumnCount <= iinfo && iinfo < InfoCount); 436Contracts.Assert(0 <= iinfo && iinfo < InfoCount); 447Contracts.Assert(0 <= iinfo && iinfo < InfoCount); 457Contracts.Assert(0 <= iinfo && iinfo < InfoCount); 478Contracts.Assert(active.Length == ColumnCount); 483Contracts.Assert(0 <= col && col < Mapper.OutputSchema.Count); 491Contracts.Assert(0 <= iinfo && iinfo < InfoCount);

Scorers\SchemaBindablePredictorWrapper.cs (28)

98Contracts.Assert(ValueMapper is ISingleCanSavePfa); 112Contracts.Assert(ValueMapper is ISingleCanSaveOnnx); 160Contracts.Assert(0 <= colSrc && colSrc < input.Schema.Count); 169Contracts.Assert(ValueMapper != null); 209Contracts.Assert(schema.Feature.HasValue); 210Contracts.Assert(outputSchema.Count == 1); 328Contracts.Assert(ValueMapper is ISingleCanSavePfa); 329Contracts.Assert(schema.Feature.HasValue); 330Contracts.Assert(Utils.Size(outputNames) == 1); // Score. 344Contracts.Assert(ValueMapper is ISingleCanSaveOnnx); 345Contracts.Assert(schema.Feature.HasValue); 346Contracts.Assert(Utils.Size(outputNames) <= 2); // PredictedLabel and/or Score. 351Contracts.Assert(ctx.ContainsColumn(featName)); 435Contracts.Assert(ValueMapper is IDistCanSavePfa); 436Contracts.Assert(schema.Feature.HasValue); 437Contracts.Assert(Utils.Size(outputNames) == 2); // Score and prob. 447Contracts.Assert(ctx.TokenOrNullForName(outputNames[0]) == scoreToken.ToString()); 448Contracts.Assert(ctx.TokenOrNullForName(outputNames[1]) == probToken.ToString()); 458Contracts.Assert(Utils.Size(outputNames) == 3); // Predicted Label, Score and Probability. 463Contracts.Assert(schema.Label.HasValue); 471Contracts.Assert(ctx.ContainsColumn(featName)); 520Contracts.Assert(parent._distMapper != null); 555Contracts.Assert(Utils.Size(active) == 2); 556Contracts.Assert(_parent._distMapper != null); 701Contracts.Assert(0 <= colSrc && colSrc < input.Schema.Count); 705Contracts.Assert(typeSrc != null && typeSrc.ItemType == NumberDataViewType.Single); 706Contracts.Assert(ValueMapper == null || 708Contracts.Assert(Utils.Size(_quantiles) > 0);

Training\TrainerUtils.cs (15)

56Contracts.Assert(!col.IsHidden); 70Contracts.Assert(data.Schema.Feature.HasValue); 72Contracts.Assert(!col.IsHidden); 74Contracts.Assert(colType != null && colType.IsKnownSize); 75Contracts.Assert(colType.ItemType == NumberDataViewType.Single); 89Contracts.Assert(!col.IsHidden); 124Contracts.Assert(!data.Schema.Schema[col.Index].IsHidden); 144Contracts.Assert(!col.IsHidden); 192Contracts.Assert(!col.IsHidden); 206Contracts.Assert(!col.IsHidden); 218Contracts.Assert(!col.IsHidden); 653Contracts.Assert(Utils.Size(inputs) > 0); 697Contracts.Assert(lim > 0); 707Contracts.Assert(_count < _lim); 970Contracts.Assert(classCount >= 0);

Transforms\ColumnBindingsBase.cs (33)

Transforms\ColumnConcatenatingTransformer.cs (24)

186Contracts.Assert(_sources.Length > 0); 274Contracts.Assert(_columns.Length > 0); 443Contracts.Assert(0 <= iinfo && iinfo < _parent._columns.Length); 497Contracts.Assert(typeCat.Length > 0); 599Contracts.Assert(_srcTypes[i].GetValueCount() > 0); 606Contracts.Assert(values.Length > 0 && values.Length % 2 == 0); 613Contracts.Assert(allValues.Count > 0); 620Contracts.Assert(!_isIdentity); 621Contracts.Assert(OutputType.Size > 0); 624Contracts.Assert(_slotNamesType.Size == OutputType.Size); 636Contracts.Assert(_columnOptions.Sources[i].alias != ""); 645Contracts.Assert(vectorTypeSrc.IsKnownSize); 670Contracts.Assert(slot == OutputType.Size); 685Contracts.Assert(SrcIndices.Length == 1); 741Contracts.Assert(offset < dstLength); 746Contracts.Assert(bufferValues.Length <= dstCount - count); 747Contracts.Assert(buffer.Length <= dstLength - offset); 769Contracts.Assert(count < dstCount); 776Contracts.Assert(count <= dstCount); 777Contracts.Assert(offset == dstLength); 788Contracts.Assert(tmpBufs[j].Length <= dstLength - offset); 800Contracts.Assert(offset == dstLength); 823Contracts.Assert(srcTokens.All(tok => tok != null)); 903Contracts.Assert(CanSaveOnnx(ctx));

Transforms\ColumnSelecting.cs (2)

345Contracts.Assert(Enum.IsDefined(typeof(HiddenColumnOption), hiddenOption)); 361Contracts.Assert(Enum.IsDefined(typeof(HiddenColumnOption), colHiddenOption));

Transforms\FeatureContributionCalculationTransformer.cs (2)

143Contracts.Assert(0 <= Top); 145Contracts.Assert(0 <= Bottom);

Transforms\GenerateNumberTransform.cs (8)

109Contracts.Assert(Utils.Size(useCounter) == InfoCount); 110Contracts.Assert(Utils.Size(states) == InfoCount); 192Contracts.Assert(0 <= iinfo && iinfo < InfoCount); 198Contracts.Assert(0 <= iinfo && iinfo < InfoCount); 207Contracts.Assert(0 <= iinfo && iinfo < InfoCount); 215Contracts.Assert(0 <= iinfo && iinfo < InfoCount); 227Contracts.Assert(0 <= iinfo && iinfo < InfoCount); 236Contracts.Assert(active.Length == Input.Count);

Transforms\Hashing.cs (14)

1000Contracts.Assert(Utils.IsPowerOfTwo(mask + 1)); 1002Contracts.Assert(0 <= srcCol && srcCol < input.Schema.Count); 1003Contracts.Assert(input.Schema[srcCol].Type.RawType == typeof(T)); 1026Contracts.Assert(Utils.IsPowerOfTwo(mask + 1)); 1144Contracts.Assert(Utils.IsPowerOfTwo(mask + 1)); 1282Contracts.Assert(Utils.IsPowerOfTwo(mask + 1)); 1574Contracts.Assert(_srcType.GetItemType().RawType == typeof(T)); 1680Contracts.Assert(_value.IsDense == _hash.IsDense); 1681Contracts.Assert(_value.Length == _hash.Length); 1682Contracts.Assert(valueValues.Length == hashValues.Length); 1725Contracts.Assert(_value.IsDense == _hash.IsDense); 1726Contracts.Assert(_value.Length == _hash.Length); 1727Contracts.Assert(valueValues.Length == hashValues.Length); 1879Contracts.Assert(NumBitsMin <= NumberOfBits && NumberOfBits < NumBitsLim);

Transforms\InvertHashUtils.cs (13)

38Contracts.Assert(0 <= col && col < schema.Count); 40Contracts.Assert(type.RawType == typeof(T)); 119Contracts.Assert(order >= 0); 173Contracts.Assert(slots > 0); 174Contracts.Assert(maxCount > 0); 192Contracts.Assert(Utils.Size(pairs) > 0); 211Contracts.Assert(sb.Length == 0); 232Contracts.Assert(count <= _slots); 247Contracts.Assert(0 <= p.Key && p.Key < _slots); 251Contracts.Assert(i == count); 261Contracts.Assert(0 <= p.Key && p.Key < _slots); 273Contracts.Assert(0 <= dstSlot && dstSlot < _slots); 288Contracts.Assert(0 <= dstSlot && dstSlot < _slots);

Transforms\KeyToValue.cs (1)

228Contracts.Assert(types[iinfo] == null);

Transforms\KeyToVector.cs (4)

405Contracts.Assert(slot == (long)kvpSlot.Key * keyCount); 663Contracts.Assert(0 <= iinfo && iinfo < _infos.Length); 664Contracts.Assert(_infos[iinfo] == info); 666Contracts.Assert(CanSavePfa);

Transforms\LabelConvertTransform.cs (5)

86Contracts.Assert(Infos.Length == Utils.Size(args.Columns)); 139Contracts.Assert(0 <= iinfo && iinfo < Infos.Length); 162Contracts.Assert(0 <= iinfo && iinfo < Infos.Length); 174Contracts.Assert(0 <= iinfo && iinfo < Infos.Length); 179Contracts.Assert(RowCursorUtils.TestGetLabelGetter(typeSrc) == null);

Transforms\MetadataDispatcher.cs (2)

216Contracts.Assert(_sealed); 444Contracts.Assert(_info != null);

Transforms\NAFilter.cs (4)

296Contracts.Assert(!(info.Type is VectorDataViewType)); 297Contracts.Assert(info.Type.RawType == typeof(T)); 308Contracts.Assert(info.Type is VectorDataViewType); 309Contracts.Assert(info.Type.RawType == typeof(VBuffer<T>));

Transforms\NormalizeColumn.cs (5)

1272Contracts.Assert(m2 >= 0); 1273Contracts.Assert(count >= 0); 1274Contracts.Assert(numZeros >= 0); 1282Contracts.Assert(d2 >= 0); 1284Contracts.Assert(m2 >= 0);

Transforms\NormalizeColumnDbl.cs (62)

Transforms\NormalizeColumnSng.cs (62)

Transforms\Normalizer.cs (8)

477Contracts.Assert(itemKind == InternalDataKind.R4 || itemKind == InternalDataKind.R8); 480Contracts.Assert(vectorType == null || vectorType.IsKnownSize); 816Contracts.Assert(0 <= iinfo && iinfo < _parent.Columns.Length); 817Contracts.Assert(_parent.Columns[iinfo] == info); 819Contracts.Assert(CanSavePfa); 826Contracts.Assert(0 <= iinfo && iinfo < _parent.Columns.Length); 827Contracts.Assert(_parent.Columns[iinfo] == info); 828Contracts.Assert(CanSaveOnnx(ctx));

Transforms\OneToOneTransformerBase.cs (1)

77Contracts.Assert(0 <= col && col < ColumnPairs.Length);

Transforms\PerGroupTransformBase.cs (1)

187Contracts.Assert(active.Length == bindings.ColumnCount);

Transforms\RangeFilter.cs (2)

335Contracts.Assert(filter._type is KeyDataViewType); 343Contracts.Assert(filter._type is KeyDataViewType);

Transforms\RowShufflingTransformer.cs (6)

374Contracts.Assert(bufferSize > 0); 383Contracts.Assert(type is PrimitiveDataViewType); 433Contracts.Assert(getter is ValueGetter<T>); 440Contracts.Assert(0 <= idx && idx < Buffer.Length); 450Contracts.Assert(0 <= idx && idx < Buffer.Length); 558Contracts.Assert(retval);

Transforms\RowToRowTransformerBase.cs (1)

84Contracts.Assert(input.Schema == InputSchema);

Transforms\SlotsDroppingTransformer.cs (22)

Transforms\TransformBase.cs (4)

233Contracts.Assert(originFn != null); 283Contracts.Assert(colSrc >= 0); 286Contracts.Assert(slotTypeSrc == null || typeSrc.GetItemType().Equals(slotTypeSrc.ItemType)); 321Contracts.Assert(Utils.Size(infos) == InfoCount);

Transforms\TypeConverting.cs (1)

470Contracts.Assert(0 <= iinfo && iinfo < _parent.ColumnPairs.Length);

Transforms\ValueToKeyMappingEstimator.cs (1)

198Contracts.Assert(kv.IsValid);

Transforms\ValueToKeyMappingTransformer.cs (4)

695Contracts.Assert(0 <= iinfo && iinfo < _unboundMaps.Length); 759Contracts.Assert(0 <= iinfo && iinfo < _parent.ColumnPairs.Length); 956Contracts.Assert(0 <= iinfo && iinfo < _infos.Length); 957Contracts.Assert(_infos[iinfo] == info);

Transforms\ValueToKeyMappingTransformerImpl.cs (27)

45Contracts.Assert(type is VectorDataViewType || type is PrimitiveDataViewType); 50Contracts.Assert(sortOrder == ValueToKeyMappingEstimator.KeyOrdinality.ByOccurrence || sortOrder == ValueToKeyMappingEstimator.KeyOrdinality.ByValue); 64Contracts.Assert(type.RawType == typeof(T)); 132Contracts.Assert(nstr.Id == i); 133Contracts.Assert(i == 0 || sortedPool.GetNormStrById(i - 1).Value.Span.CompareTo(sortedPool.GetNormStrById(i).Value.Span, StringComparison.Ordinal) < 0); 135Contracts.Assert(sortedPool.Count == _pool.Count); 167Contracts.Assert(type.RawType == typeof(T)); 268Contracts.Assert(max >= 0); 288Contracts.Assert(0 <= col && col < schema.Count); 289Contracts.Assert(count > 0); 293Contracts.Assert(autoConvert || bldr.ItemType == type.GetItemType()); 295Contracts.Assert(type is TextDataViewType || !autoConvert); 305Contracts.Assert(bldr is Builder<T>); 321Contracts.Assert(bldr is Builder<T>); 362Contracts.Assert(_remaining >= 0); 388Contracts.Assert(_remaining > 0); 394Contracts.Assert(_remaining >= 0); 416Contracts.Assert(!_val.IsDense && !_addedDefaultFromSparse); 504Contracts.Assert(count >= 0); 660Contracts.Assert(0 <= nstr.Id && nstr.Id < editor.Values.Length); 661Contracts.Assert(nstr.Id == slot); 742Contracts.Assert(_values.Count == Count); 767Contracts.Assert(ItemType.RawType == typeof(T)); 783Contracts.Assert(typeof(T) != typeof(ReadOnlyMemory<char>)); 789Contracts.Assert(src.IsDense); 910Contracts.Assert(!(info.TypeSrc is VectorDataViewType)); 1154Contracts.Assert(tempMeta.IsDense);

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\LocalEnvironment.cs (5)

71Contracts.Assert(source == this || source is Host); 78Contracts.Assert(parent is LocalEnvironment); 86Contracts.Assert(parent is LocalEnvironment); 102Contracts.Assert(parent is Host); 110Contracts.Assert(parent is Host);

Utilities\ModelFileUtils.cs (1)

385Contracts.Assert(index == 0);

Utilities\SlotDropper.cs (11)

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\TypeParsingUtils.cs (1)

152Contracts.Assert(Count == null || Count > 0);

Utils\ApiUtils.cs (2)

83Contracts.Assert(false); 151Contracts.Assert(false);

Utils\SequencePool.cs (25)

83Contracts.Assert(4 <= ibit && ibit <= 31); 120Contracts.Assert(_start[id] <= _start[id + 1]); 131Contracts.Assert(_buckets.Length == _mask + 1); 132Contracts.Assert(Utils.IsPowerOfTwo(_mask + 1)); 134Contracts.Assert(0 <= _idLim && Math.Max(10, _idLim) <= Utils.Size(_start) - 1); 135Contracts.Assert(Math.Max(10, _idLim) <= Utils.Size(_hash)); 136Contracts.Assert(Math.Max(10, _idLim) <= Utils.Size(_next)); 137Contracts.Assert(_start[0] == 0); 138Contracts.Assert(0 <= _start[_idLim] && Math.Max(40, _start[_idLim]) <= Utils.Size(_bytes)); 155Contracts.Assert(0 <= min && min <= lim && lim <= Utils.Size(sequence)); 161Contracts.Assert(0 <= idCur && idCur < _idLim); 169Contracts.Assert(ibCur <= ibLim); 182Contracts.Assert(success); 208Contracts.Assert(id == _idLim - 1); 232Contracts.Assert(0 <= min && min <= lim && lim <= Utils.Size(sequence)); 233Contracts.Assert(Hashing.HashSequence(sequence, min, lim) == hash); 238Contracts.Assert(_idLim + 1 == _start.Length); 244Contracts.Assert(_hash.Length >= _next.Length); 248Contracts.Assert(_idLim == _next.Length); 264Contracts.Assert(_idLim < _next.Length); 265Contracts.Assert(ibLim <= _bytes.Length - cbMax); 309Contracts.Assert(bytes.Length >= ib + 5 * (lim - min)); 347Contracts.Assert(0 <= min && min <= lim && lim <= Utils.Size(bytes)); 355Contracts.Assert(count < lim - min); 359Contracts.Assert(cur <= lim);