Type

Commands\CrossValidationCommand.cs (1)

302var type = schema[index].Type;

Commands\DataCommand.cs (1)

166var type = cursor.Schema[currentIndex].Type;

Commands\SaveDataCommand.cs (2)

150var type = data.Schema[i].Type; 212var type = view.Schema[i].Type;

Commands\ScoreCommand.cs (1)

190var type = loader.Schema[i].Type;

Commands\ShowSchemaCommand.cs (3)

140var type = schema[col].Type; 156if ((typeNames = schema[col].Annotations.Schema.GetColumnOrNull(AnnotationUtils.Kinds.SlotNames)?.Type) == null) 193var type = metaColumn.Type;

Data\DataViewUtils.cs (10)

185var type = schema[col].Type; 205if (!IsCacheable(col.Type)) 355DataViewType type = schema[c].Type; 540ch.Assert(column.Type.IsCacheable()); 542Utils.MarshalInvoke(_createInPipeMethodInfo, this, column.Type.RawType, input, activeToCol[c]); 544outPipes[i][c] = inPipe.CreateOutPipe(column.Type); 1244return Utils.MarshalInvoke(_createGetterMethodInfo, this, Schema[col].Type.RawType, col); 1250var type = Schema[col].Type; 1257Ch.Assert(type.Equals(cursor.Schema[col].Type)); 1338var colType = cursor.Schema[srcColIndex].Type;

Data\RowCursorUtils.cs (9)

39return Utils.MarshalInvoke(_getGetterAsDelegateCoreMethodInfo, row.Schema[col].Type.RawType, row, col); 61var typeSrc = row.Schema[col].Type; 82var typeSrc = row.Schema[col].Type; 127var typeSrc = row.Schema[col].Type; 160var typeSrc = row.Schema[col].Type as VectorDataViewType; 180var typeSrc = row.Schema[col].Type as VectorDataViewType; 308DataViewType type = cursor.Schema[col].Type; 354var type = cursor.Schema[labelIndex].Type; 376var type = cursor.Schema[labelIndex].Type;

Data\SchemaAnnotationsExtensions.cs (4)

23=> column.Type is VectorDataViewType vectorType 51if (!(column.Type.GetItemType() is KeyDataViewType keyType)) 60&& metaColumn.Value.Type is VectorDataViewType vectorType 83if (metaColumn == null || !(metaColumn.Value.Type is BooleanDataViewType))

DataDebuggerPreview.cs (2)

48setters[i] = Utils.MarshalInvoke(_makeSetterMethodInfo, this, data.Schema[i].Type.RawType, cursor, i); 105public override string ToString() => $"{Column.Name}: {Column.Type}";

DataLoadSave\Binary\BinaryLoader.cs (1)

991.Select(x => new { col = x, isSavable = saver.IsColumnSavable(schema[x].Type) });

DataLoadSave\Binary\BinarySaver.cs (5)

284_host.Check(metaColumn.Type != null, "Metadata with null type detected, disallowed"); 288args[4] = metaColumn.Type; 289IValueCodec codec = (IValueCodec)methInfo.MakeGenericMethod(metaColumn.Type.RawType).Invoke(this, args); 294metaColumn.Type, schema[col].Name, col, metaColumn.Name); 718DataViewType type = schema[colIndices[c]].Type;

DataLoadSave\DataOperationsCatalog.cs (3)

230var type = input.Schema[columnName].Type; 264var type = input.Schema[columnName].Type; 558var type = data.Schema[samplingColIndex].Type;

DataLoadSave\Text\TextSaver.cs (6)

64DataViewType type = cursor.Schema[col].Type; 167&& (typeNames = cursor.Schema[source].Annotations.Schema.GetColumnOrNull(AnnotationUtils.Kinds.SlotNames)?.Type as VectorDataViewType) != null 402DataViewType itemType = data.Schema[cols[i]].Type.GetItemType(); 414var type = data.Schema[cols[i]].Type; 422var typeNames = data.Schema[cols[i]].Annotations.Schema.GetColumnOrNull(AnnotationUtils.Kinds.SlotNames)?.Type as VectorDataViewType; 478var type = schema[src].Type;

DataLoadSave\Transpose\TransposeLoader.cs (11)

297var ttype = schema[0].Type; 312var type = _parent.Schema[_col].Type; 553env.Assert(Enumerable.Range(0, schema.Count).All(c => saver.IsColumnSavable(schema[c].Type))); 614return view.Schema[0].Type as VectorDataViewType; 682Ch.Assert(cursor.Schema[0].Type.RawType == typeof(VBuffer<T>)); 683Ch.Assert(cursor.Schema[0].Type is VectorDataViewType); 690=> (VectorDataViewType)_rowCursor.Schema[0].Type; 738_host.Assert((trans as ITransposeDataView)?.GetSlotType(0).GetValueCount() == Schema[col].Type.GetValueCount()); 798var type = Schema[col].Type; 813var type = Schema[col].Type; 833var type = Schema[col].Type;

DataView\AppendRowsDataView.cs (3)

118DataViewType type = Schema[c].Type; 124_host.Check(schema[c].Type.SameSizeAndItemType(type), errMsg); 182DataViewType colType = Schema[col].Type;

DataView\CacheDataView.cs (6)

134var type = schema[c].Type; 1221return Utils.MarshalInvoke(_createGetterDelegateMethodInfo, this, Schema[col].Type.RawType, col); 1228Ch.Assert(Schema[col].Type.RawType == typeof(TValue)); 1287var type = input.Schema[srcCol].Type; 1350var type = input.Schema[srcCol].Type; 1470Contracts.Assert(input.Schema[srcCol].Type.RawType == typeof(T));

DataView\DataViewConstructionUtils.cs (4)

79schemaDefinitionCol.ColumnType = col.Type; 86var info = Utils.MarshalInvoke(_getAnnotationInfoMethodInfo, annotation.Type.RawType, annotation.Name, annotations); 106return new AnnotationInfo<T>(kind, value, annotations.Schema[kind].Type); 230_getters[c] = predicate(c) ? CreateGetter(schema[c].Type, schemaDef.Columns[c], peeks[c]) : null;

DataView\DataViewExtensions.cs (2)

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

49var typeOrig = input.Schema[colSrc].Type;

DataView\LambdaFilter.cs (1)

40var typeOrig = input.Schema[colSrc].Type;

DataView\Transposer.cs (15)

139var type = schema[_cols[c].Index].Type; 148ch.Assert(Enumerable.Range(0, slicerSchema.Count).All(c => saver.IsColumnSavable(slicerSchema[c].Type))); 255if (_view.Schema[col].Type is VectorDataViewType) 269if (transposedColumn.Type is PrimitiveDataViewType primitiveDataViewType) 271else if (transposedColumn.Type is VectorDataViewType vectorDataViewType) 361Ch.Assert(_view.Schema[_col].Type is PrimitiveDataViewType); 362Ch.Assert(_view.Schema[_col].Type.RawType == typeof(T)); 374var isDefault = Conversion.Conversions.DefaultInstance.GetIsDefaultPredicate<T>(_view.Schema[_col].Type); 517var type = _view.Schema[_colCurr].Type; 690_slotLim = _view.Schema[_colCurr].Type.GetValueCount(); 924var type = view.Schema[col].Type; 1011Contracts.Assert(_view.Schema[col].Type.RawType == typeof(T)); 1018schemaBuilder.AddColumn(selectedColumn.Name, selectedColumn.Type, selectedColumn.Annotations); 1094var type = _view.Schema[SrcCol].Type as VectorDataViewType; 1443var type = _data.Schema[_col].Type;

DataView\TypedCursor.cs (3)

110var realColType = _data.Schema[colIndex].Type; 252DataViewType expectedType = data.Schema[colIndex].Type; 358var colType = input.Schema[index].Type;

Dirty\ChooseColumnsByIndexTransform.cs (1)

117schemaBuilder.AddColumn(selectedColumn.Name, selectedColumn.Type, selectedColumn.Annotations);

EntryPoints\PredictorModelImpl.cs (1)

127labelType = trainRms.Label.Value.Type;

Evaluators\AnomalyDetectionEvaluator.cs (3)

98var t = score.Type; 102t = schema.Label.Value.Type; 733var type = cursor.Schema[stratCol].Type;

Evaluators\BinaryClassifierEvaluator.cs (8)

130var t = score.Type; 134t = schema.Label.Value.Type; 146var probType = prob[0].Type; 177if (labelCol.Type is KeyDataViewType && 178labelCol.Annotations.Schema.GetColumnOrNull(AnnotationUtils.Kinds.KeyValues)?.Type is VectorDataViewType vecType && 1264var t = schema[(int)LabelIndex].Type; 1268t = schema[ScoreIndex].Type; 1275t = schema[_probIndex].Type;

Evaluators\ClusteringEvaluator.cs (12)

99DataViewType type = schema.Label?.Type; 107type = score.Type; 117var t = schema.Feature.Value.Type; 137Host.Assert(!_calculateDbi || schema.Feature?.Type.IsKnownSizeVector() == true); 139var scoreType = score.Type as VectorDataViewType; 148int numClusters = scoreInfo.Type.GetVectorSize(); 332_clusterCentroids[i] = VBufferUtils.CreateEmpty<Single>(features.Value.Type.GetVectorSize()); 413_clusterCentroids[i] = VBufferUtils.CreateEmpty<Single>(features.Value.Type.GetVectorSize()); 500Host.Assert(score.Type.GetVectorSize() == _scoresArr.Length); 755var type = schema[(int)ScoreIndex].Type; 840var type = perInst.Schema[index].Type; 847var type = perInst.Schema[index].Type;

Evaluators\EvaluatorBase.cs (2)

52EvaluateUtils.CheckWeightType(Host, schema.Weight.Value.Type); 118list.Add(AggregatorDictionaryBase.Create(schema, stratCol.Name, stratCol.Type, createAgg));

Evaluators\EvaluatorUtils.cs (33)

Evaluators\MulticlassClassificationEvaluator.cs (16)

78var scoreType = score.Type as VectorDataViewType; 80throw Host.ExceptSchemaMismatch(nameof(schema), "score", score.Name, "vector of two or more items of type Single", score.Type.ToString()); 82var labelType = schema.Label.Value.Type; 90int numClasses = score.Type.GetVectorSize(); 101var mdType = schema.Schema[scoreInfo.Index].Annotations.Schema.GetColumnOrNull(AnnotationUtils.Kinds.SlotNames)?.Type as VectorDataViewType; 113int numClasses = score[0].Type.GetVectorSize(); 124int numClasses = scoreInfo.Type.GetVectorSize(); 418Host.Assert(score.Type.GetVectorSize() == _scoresArr.Length); 619_numClasses = scoreColumn.Type.GetVectorSize(); 860var scoreType = schema[ScoreIndex].Type as VectorDataViewType; 862throw Host.ExceptSchemaMismatch(nameof(schema), "score", ScoreCol, "Vector of two or more items of type Single", schema[ScoreIndex].Type.ToString()); 863var labelType = schema[LabelIndex].Type; 1060var labelType = labelCol.Type; 1064labelName, labelCol.Type, NumberDataViewType.Double, 1071var type = perInstSchema[sortedClassesIndex].Type; 1080var type = perInst.Schema[sortedScoresIndex].Type;

Evaluators\MultiOutputRegressionEvaluator.cs (12)

61var t = score.Type as VectorDataViewType; 63throw Host.ExceptSchemaMismatch(nameof(schema), "score", score.Name, "known-size vector of Single", score.Type.ToString()); 65t = schema.Label.Value.Type as VectorDataViewType; 67throw Host.ExceptSchemaMismatch(nameof(schema), "label", schema.Label.Value.Name, "known-size vector of Single or Double", schema.Label.Value.Type.ToString()); 73int vectorSize = score.Type.GetVectorSize(); 549var t = schema[LabelIndex].Type as VectorDataViewType; 551throw Host.ExceptSchemaMismatch(nameof(schema), "label", LabelCol, "known-size vector of Single or Double", schema[LabelIndex].Type.ToString()); 558t = schema[ScoreIndex].Type as VectorDataViewType; 560throw Host.ExceptSchemaMismatch(nameof(schema), "score", ScoreCol, "known-size vector of Single", schema[ScoreIndex].Type.ToString()); 595var type = schema[column].Annotations.Schema.GetColumnOrNull(AnnotationUtils.Kinds.SlotNames)?.Type; 691var type = cursor.Schema[stratCol].Type; 707var type = fold.Schema[i].Type as VectorDataViewType;

Evaluators\QuantileRegressionEvaluator.cs (10)

46int scoreSize = scoreInfo.Type.GetVectorSize(); 47var type = schema.Schema[scoreInfo.Index].Annotations.Schema.GetColumnOrNull(AnnotationUtils.Kinds.SlotNames)?.Type as VectorDataViewType; 59var t = score.Type as VectorDataViewType; 61throw Host.ExceptSchemaMismatch(nameof(schema), "score", score.Name, "Vector of Single or Double", score.Type.ToString()); 63var labelType = schema.Label.Value.Type; 71var scoreType = scoreInfo.Type as VectorDataViewType; 74var slotNamesType = schema.Schema[scoreInfo.Index].Annotations.Schema.GetColumnOrNull(AnnotationUtils.Kinds.SlotNames)?.Type as VectorDataViewType; 447var t = schema[(int)LabelIndex].Type; 451VectorDataViewType scoreType = schema[ScoreIndex].Type as VectorDataViewType; 516var type = data.Schema[i].Type;

Evaluators\RankingEvaluator.cs (3)

98var t = schema.Label.Value.Type; 105if (scoreCol.Type != NumberDataViewType.Single) 114var t = schema.Group.Value.Type;

Evaluators\RegressionEvaluator.cs (4)

58var t = score.Type; 62t = schema.Label.Value.Type; 328var t = schema[(int)LabelIndex].Type; 332t = schema[ScoreIndex].Type;

Model\Pfa\BoundPfaContext.cs (1)

170DataViewType type = schema[col].Type;

Prediction\Calibrator.cs (3)

668var scoreType = _predictor.OutputSchema[_scoreCol].Type; 702var type = predictorRow.Schema[column.Index].Type; 886var type = outputSchema[scoreCol].Type;

Prediction\CalibratorCatalog.cs (5)

288setIdCol.Type is KeyDataViewType setIdType && setIdType.RawType == typeof(uint) && 290kindCol.Type is TextDataViewType && 292valueKindCol.Type is TextDataViewType) 301builder.Add(kindCol.Name, kindCol.Type, annotation.GetGetter<ReadOnlyMemory<char>>(kindCol)); 302builder.Add(valueKindCol.Name, valueKindCol.Type, annotation.GetGetter<ReadOnlyMemory<char>>(valueKindCol));

Scorers\BinaryClassifierScorer.cs (4)

67var keyType = trainSchema.Label.Value.Annotations.Schema.GetColumnOrNull(AnnotationUtils.Kinds.KeyValues)?.Type as VectorDataViewType; 99if (mapper.OutputSchema[scoreIdx].Annotations.Schema.GetColumnOrNull(AnnotationUtils.Kinds.TrainingLabelValues)?.Type != null) 115var type = labelColumn.Annotations.Schema.GetColumnOrNull(AnnotationUtils.Kinds.KeyValues)?.Type as VectorDataViewType; 221node.AddAttribute("to", predictedLabelCol.Value.Type.RawType);

Scorers\FeatureContributionCalculation.cs (4)

195var typeSrc = input.Schema[colSrc].Type; 207var typeSrc = input.Schema[colSrc].Type; 324var featureSize = FeatureColumn.Type.GetVectorSize(); 344var featureContributionType = new VectorDataViewType(NumberDataViewType.Single, ((VectorDataViewType)FeatureColumn.Type).Dimensions);

Scorers\MulticlassClassificationScorer.cs (5)

333builder.AddColumn(partialSchema[i].Name, partialSchema[i].Type, meta.ToAnnotations()); 417var keyType = trainSchema.Label.Value.Annotations.Schema.GetColumnOrNull(AnnotationUtils.Kinds.KeyValues)?.Type as VectorDataViewType; 459if (outSchema[scoreIdx].Annotations.Schema.GetColumnOrNull(metaKind)?.Type != null) 461scoreType = outSchema[scoreIdx].Type; 493var type = trainSchema.Label.Value.Annotations.Schema.GetColumnOrNull(AnnotationUtils.Kinds.KeyValues)?.Type;

Scorers\PredictedLabelScorerBase.cs (7)

75if (trainLabelColumn?.Type is VectorDataViewType trainLabelColVecType && (ulong)trainLabelColVecType.Size == predColKeyType.Count) 87Contracts.Assert(metaCol.Type.RawType == typeof(T)); 89builder.Add(AnnotationUtils.Kinds.KeyValues, metaCol.Type, meta.GetGetter<T>(metaCol)); 151var scoreType = mapper.OutputSchema[scoreColIndex].Type; 192yield return new KeyValuePair<string, DataViewType>(sch[i].Name, sch[i].Type); 214return _predColMetadata.Schema[mcol].Type; 300var scoreType = mapper.OutputSchema[scoreColIndex].Type;

Scorers\PredictionTransformer.cs (5)

236FeatureColumnType = trainSchema[col].Type; 251FeatureColumnType = TrainSchema[col].Type; 266FeatureColumnType = TrainSchema[col].Type; 284if (!inputSchema[col].Type.Equals(FeatureColumnType)) 285throw Host.ExceptSchemaMismatch(nameof(inputSchema), "feature", FeatureColumnName, FeatureColumnType.ToString(), inputSchema[col].Type.ToString());

Scorers\RowToRowScorerBase.cs (4)

210var type = row.Schema[col].Type; 431return Mapper.OutputSchema[iinfo - DerivedColumnCount].Type; 441foreach (var pair in Mapper.OutputSchema[iinfo - DerivedColumnCount].Annotations.Schema.Select(c => new KeyValuePair<string, DataViewType>(c.Name, c.Type))) 452return Mapper.OutputSchema[iinfo - DerivedColumnCount].Annotations.Schema.GetColumnOrNull(kind)?.Type;

Scorers\SchemaBindablePredictorWrapper.cs (4)

127if (schema.Feature?.Type is DataViewType type) 162var typeSrc = input.Schema[colSrc].Type; 527if (schema.Feature?.Type is DataViewType typeSrc) 704var typeSrc = column.Type as VectorDataViewType;

Scorers\ScoreSchemaFactory.cs (2)

58schemaBuilder.AddColumn(partialSchema[0].Name, partialSchema[0].Type, partialSchema[0].Annotations); 103schemaBuilder.AddColumn(partialSchema[0].Name, partialSchema[0].Type, metadataBuilder.ToAnnotations());

Training\TrainerUtils.cs (23)

57if (!(col.Type is VectorDataViewType vecType && vecType.Size > 0 && vecType.ItemType == NumberDataViewType.Single)) 58throw Contracts.ExceptParam(nameof(data), "Training feature column '{0}' must be a known-size vector of R4, but has type: {1}.", col.Name, col.Type); 73var colType = col.Type as VectorDataViewType; 90if (col.Type != BooleanDataViewType.Instance && col.Type != NumberDataViewType.Single && col.Type != NumberDataViewType.Double && !(col.Type is KeyDataViewType keyType && keyType.Count == 2)) 92KeyDataViewType colKeyType = col.Type as KeyDataViewType; 110col.Name, col.Type); 125if (col.Type != NumberDataViewType.Single && col.Type != NumberDataViewType.Double) 128"Training label column '{0}' type isn't suitable for regression: {1}. Type must be Single or Double.", col.Name, col.Type); 145if (col.Type is KeyDataViewType keyType && keyType.Count > 0) 154if (col.Type != NumberDataViewType.Single && col.Type != NumberDataViewType.Double) 155throw Contracts.ExceptParam(nameof(data), "Training label column '{0}' type is not valid for multi-class: {1}. Type must be Single or Double.", col.Name, col.Type); 193if (!(col.Type is VectorDataViewType vectorType 196throw Contracts.ExceptParam(nameof(data), "Training label column '{0}' must be a known-size vector of Single, but has type: {1}.", col.Name, col.Type); 207if (col.Type != NumberDataViewType.Single && col.Type != NumberDataViewType.Double) 208throw Contracts.ExceptParam(nameof(data), "Training weight column '{0}' must be of floating point numeric type, but has type: {1}.", col.Name, col.Type); 219if (col.Type is KeyDataViewType) 221throw Contracts.ExceptParam(nameof(data), "Training group column '{0}' type is invalid: {1}. Must be Key type.", col.Name, col.Type);

Transforms\ColumnBindingsBase.cs (3)

505return Input[index].Type; 516return Input[index].Annotations.Schema.Select(c => new KeyValuePair<string, DataViewType>(c.Name, c.Type)); 529return Input[index].Annotations.Schema.GetColumnOrNull(kind)?.Type;

Transforms\ColumnConcatenatingTransformer.cs (6)

470var curType = inputSchema[srcCol].Type; 553_srcTypes = sources.Select(c => inputSchema[c].Type).ToArray(); 559_isIdentity = SrcIndices.Length == 1 && _inputSchema[SrcIndices[0]].Type is VectorDataViewType; 576return new DataViewSchema.DetachedColumn(_columnOptions.Name, inputCol.Type, inputCol.Annotations); 650typeNames = inputMetadata.Schema[idx].Type as VectorDataViewType; 933InputSchema[srcIndex].Type.GetValueCount()));

Transforms\ColumnCopying.cs (3)

220var type = input.Schema[colIndex].Type; 233result[i] = new DataViewSchema.DetachedColumn(_columns[i].outputColumnName, srcCol.Type, srcCol.Annotations); 252var dstVariableName = ctx.AddIntermediateVariable(_schema[colIndex].Type, column.outputColumnName);

Transforms\ColumnSelecting.cs (1)

747var dstVariable = ctx.AddIntermediateVariable(dstCol.Type, dstCol.Name);

Transforms\FeatureContributionCalculationTransformer.cs (2)

183_featureColumnType = schema[_featureColumnIndex].Type as VectorDataViewType; 185throw Host.ExceptSchemaMismatch(nameof(schema), "feature", _parent.ColumnPairs[0].inputColumnName, "vector of Single", schema[_featureColumnIndex].Type.ToString());

Transforms\Hashing.cs (7)

150var type = inputSchema[srcCol].Type; 166var srcType = inputSchema[srcCol].Type; 267var srcType = input.Schema[srcCol].Type; 1003Contracts.Assert(input.Schema[srcCol].Type.RawType == typeof(T)); 1325_srcTypes[i] = inputSchema[_parent.ColumnPairs[i].inputColumnName].Type; 1493_srcType = row.Schema[srcCol].Type; 1511DataViewType typeSrc = row.Schema[srcCol].Type;

Transforms\InvertHashUtils.cs (1)

39var type = schema[col].Type.GetItemType();

Transforms\KeyToValue.cs (3)

229var typeSrc = schema[ColMapNewToOld[iinfo]].Type; 230var typeVals = schema[ColMapNewToOld[iinfo]].Annotations.Schema.GetColumnOrNull(AnnotationUtils.Kinds.KeyValues)?.Type; 488var srcType = Parent.InputSchema[Parent.ColMapNewToOld[InfoIndex]].Type;

Transforms\KeyToVector.cs (4)

116var type = inputSchema[srcCol].Type; 282var type = inputSchema[colSrc].Type; 315typeNames = keyValuesColumn.Value.Type as VectorDataViewType; 379var typeSlotSrc = inputMetadata.Schema.GetColumnOrNull(AnnotationUtils.Kinds.SlotNames)?.Type as VectorDataViewType;

Transforms\LabelConvertTransform.cs (1)

178var typeSrc = input.Schema[col].Type;

Transforms\MetadataDispatcher.cs (2)

236foreach (var kvp in info.SchemaSrc[info.IndexSrc].Annotations.Schema.Select(c => new KeyValuePair<string, DataViewType>(c.Name, c.Type))) 268return info.SchemaSrc[info.IndexSrc].Annotations.Schema.GetColumnOrNull(kind)?.Type;

Transforms\NAFilter.cs (2)

114var type = schema[index].Type; 150var type = schema[index].Type;

Transforms\NormalizeColumn.cs (4)

812var type = row.Schema[col].Type; 917Host.Assert(valueCol.Type.IsKnownSizeVector()); 918ColumnSlotCount = valueCol.Type.GetValueCount(); 1132var labelColumnType = cursor.Schema[labelColumnId].Type;

Transforms\Normalizer.cs (3)

547srcTypes[i] = data.Schema[srcCols[i]].Type; 647var typeSrc = input.Schema[ColumnPairs[iinfo].inputColumnName].Type; 705var colType = inputSchema[srcCol].Type;

Transforms\RangeFilter.cs (2)

106_type = schema[_index].Type; 154_type = schema[_index].Type;

Transforms\RowShufflingTransformer.cs (5)

195var type = schema[c].Type; 215var type = schema[c].Type; 531input.Schema[c].Type, RowCursorUtils.GetGetterAsDelegate(input, c)); 680return Utils.MarshalInvoke(_createGetterDelegateMethodInfo, this, Schema[col].Type.RawType, col); 687Ch.Assert(Schema[col].Type.RawType == typeof(TValue));

Transforms\SlotsDroppingTransformer.cs (1)

484_srcTypes[i] = inputSchema[_cols[i]].Type;

Transforms\TransformBase.cs (3)

349var type = inputSchema[colSrc].Type; 398var type = inputSchema[colSrc].Type; 619ctx.AddIntermediateVariable(OutputSchema[_bindings.MapIinfoToCol(iinfo)].Type, info.Name)))

Transforms\TypeConverting.cs (4)

330var srcType = input.Schema[item.Source ?? item.Name].Type; 402if (!CanConvertToType(Host, srcCol.Type, _parent._columns[i].OutputKind.ToInternalDataKind(), _parent._columns[i].OutputKeyCount, 407_parent._columns[i].InputColumnName, srcCol.Type, itemType); 440var srcType = InputSchema[_srcCols[i]].Type;

Transforms\ValueMapping.cs (22)

365internal DataViewType ValueColumnType => _valueMap.ValueColumn.Type; 450Host.Check(retrievedKeyColumn.Type == keyColumn.Type, nameof(keyColumn) + "'s column type doesn't match that of the associated column in " + nameof(dataView)); 458Host.Check(retrievedValueColumn.Type == valueColumn.Type, nameof(valueColumn) + "'s column type doesn't match that of the associated column in " + nameof(dataView)); 810var method = del.Method.GetGenericMethodDefinition().MakeGenericMethod(keyColumn.Type.RawType, valueColumn.Type.RawType); 863if (!(ValueColumn.Type is VectorDataViewType)) 871ValueColumn.Type, 900if (ValueColumn.Type is VectorDataViewType vectorType) 903return Utils.MarshalInvoke(_getValueMethodInfo, ValueColumn.Type.RawType, _mapping[key]); 912if (column.Type is VectorDataViewType) 952ValueColumn.Type is KeyDataViewType); 1070var type = _inputSchema[colSrc].Type; 1109var typeValue = _valueMap.ValueColumn.Type; 1110var typeKey = _valueMap.KeyColumn.Type; 1111var kind = _valueMap.ValueColumn.Type.GetRawKind(); 1283if (_inputSchema[_columns[i].inputColumnName].Type is VectorDataViewType && _valueMap.ValueColumn.Type is VectorDataViewType) 1285var colType = _valueMap.ValueColumn.Type; 1286if (_inputSchema[_columns[i].inputColumnName].Type is VectorDataViewType) 1287colType = new VectorDataViewType(ColumnTypeExtensions.PrimitiveTypeFromType(_valueMap.ValueColumn.Type.GetItemType().RawType));

Transforms\ValueToKeyMappingTransformer.cs (2)

236var type = inputSchema[colSrc].Type; 479var typeSrc = keyData.Schema[0].Type;

Transforms\ValueToKeyMappingTransformerImpl.cs (3)

292var type = schema[col].Type; 1098VectorDataViewType srcMetaType = _schema[srcCol].Annotations.Schema.GetColumnOrNull(AnnotationUtils.Kinds.KeyValues)?.Type as VectorDataViewType; 1179VectorDataViewType srcMetaType = _schema[srcCol].Annotations.Schema.GetColumnOrNull(AnnotationUtils.Kinds.KeyValues)?.Type as VectorDataViewType;

Utilities\ColumnCursor.cs (4)

40var colType = column.Type; 45if (data.Schema[colIndex].Name != colName || data.Schema[colIndex].Type != colType) 74throw Contracts.ExceptParam(nameof(column), string.Format("Cannot load vector type, {0}, specified in {1} to the user-defined type, {2}.", column.Type, nameof(column), typeof(T))); 95column.Name, column.Type, nameof(data), typeof(T)));