public void Format_DBNullValue_NullDisplay(ColumnType columnType)
{
var factory = new CellFormatterFactory();
var formatter = factory.GetObject(columnType);
var text = formatter.Format(DBNull.Value);
Assert.That(text, Is.EqualTo("(null)"));
}
public void AddColumn(string colName, int width, ColumnType columnType, string description, bool persistent)
{
AddColumn(colName, width, columnType, description);
if (persistent){
AddPersistentColumn(colName, width, columnType, description, null);
}
}
public ColumnMappingField(FieldInfo field, ColumnAttribute attribute)
{
this._Field = field;
this._ColumnName = string.IsNullOrEmpty(attribute.ColumnName) ? field.Name : attribute.ColumnName;
this._ColumnType = attribute.ColumnType;
this._ColumnId = attribute.ColumnId;
}
public ColumnMappingProperty(PropertyInfo Property, ColumnAttribute attribute)
{
this._Property = Property;
this._ColumnName = string.IsNullOrEmpty(attribute.ColumnName) ? Property.Name : attribute.ColumnName;
this._ColumnType = attribute.ColumnType;
this._ColumnId = attribute.ColumnId;
}
public static string ColumnTypeToString(ColumnType ct)
{
switch (ct){
case ColumnType.Boolean:
return "C";
case ColumnType.Categorical:
return "C";
case ColumnType.Color:
return "C";
case ColumnType.DateTime:
return "T";
case ColumnType.DashStyle:
return "C";
case ColumnType.Integer:
return "N";
case ColumnType.MultiInteger:
return "M";
case ColumnType.MultiNumeric:
return "M";
case ColumnType.Numeric:
return "N";
case ColumnType.Text:
return "T";
default:
return "T";
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Column" /> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="title">The title.</param>
/// <param name="type">The type.</param>
/// <param name="pk">if set to <c>true</c> the column is a primary key.</param>
public Column(string name, string title = null, ColumnType type = ColumnType.Text, bool pk = false)
{
this.Name = name;
this.Title = (title == null) ? name : title;
this.Type = type;
this.PrimaryKey = pk;
}
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="objectSrc"></param>
public ColumnSchema(ColumnSchema objectSrc)
{
Name = objectSrc.Name;
Type = objectSrc.Type;
Reference = objectSrc.Reference;
Comment = objectSrc.Comment;
}
/// <summary>
/// Explicit constructor for a foreign key
/// </summary>
/// <param name="name">Name of the column</param>
/// <param name="type">Type of the column</param>
public ColumnSchema(string name, ColumnType type, string tableName, string columnName, string comment)
{
Name = name;
Type = type;
Reference = string.Format("{0}.{1}", tableName, columnName);
Comment = comment;
}
public override string GetNativeSqlType(ColumnType type)
{
switch (type)
{
case ColumnType.ID:
return "integer primary key autoincrement";
case ColumnType.ForeignKey:
case ColumnType.Integer:
return "integer";
case ColumnType.String:
return "text";
case ColumnType.Bool:
return "bool";
case ColumnType.Timestamp:
return "timestamp";
case ColumnType.Date:
return "date";
case ColumnType.Double:
return "double";
default:
return null;
}
}
public ColumnAttribute(ColumnType type)
{
switch (type)
{
case ColumnType.IncrementPrimary:
ParameterDirection = ParameterDirection.InputOutput;
IsUnique = IsPrimaryKey = IsIncrement = true;
break;
case ColumnType.Primary:
ParameterDirection = ParameterDirection.Input;
IsUnique = IsPrimaryKey = true;
break;
case ColumnType.Unique:
ParameterDirection = ParameterDirection.Input;
IsUnique = true;
break;
case ColumnType.Nullable:
IsNullable = true;
ParameterDirection = ParameterDirection.Input;
break;
default:
ParameterDirection = ParameterDirection.Input;
break;
}
}
public ColumnData(String name, ColumnType type, String comparison, String method)
{
Name = name;
Type = type;
Comparison = comparison;
TimingMethod = method;
}
public ValuedExpression(string expression, object value, ColumnType type, string tolerance)
: base(expression)
{
Value = value;
Type = type;
Tolerance = tolerance;
}
public static ColumnParser Create(ColumnType type, string format)
{
switch (type)
{
case ColumnType.Logger:
return new LoggerParser();
case ColumnType.Level:
return new LevelParser();
case ColumnType.Timestamp:
return new TimestampParser(format);
case ColumnType.Thread:
return new ThreadParser();
case ColumnType.Line:
return new LineParser();
case ColumnType.Newline:
return new NewlineParser();
case ColumnType.Message:
return new MessageParser();
case ColumnType.Date:
return new DateParser(format, DateTimeKind.Local);
case ColumnType.UtcDate:
return new DateParser(format, DateTimeKind.Utc);
default:
throw new KeyNotFoundException(string.Format("Unable to find a parser for '{0}'", type));
}
}
/// <summary>
/// The column definition.
/// </summary>
/// <param name="theName">The name of the column.</param>
/// <param name="theDataType">The type of the column.</param>
public ColumnDefinition(String theName, ColumnType theDataType)
{
Name = theName;
DataType = theDataType;
Count = -1;
Low = High = Mean = Sd = Double.NaN;
}
public TableInfo(string name, string primaryKeyName, ColumnType? primaryKeyType, short? primaryKeySize)
{
Name = name;
PrimaryKeyName = primaryKeyName;
PrimaryKeyType = primaryKeyType;
PrimaryKeySize = primaryKeySize;
}
/// <summary>
/// Filter items in ImageListView incrementally.
/// This method optimizes on-the-fly filtering as user types in a search box.
/// </summary>
/// <param name="key">An item is visible only if it contains this string</param>
private void FilterIncrementallyWith(string key, ColumnType attrType)
{
if (key.Length == mLastSearch.Length) return;
if (mVisibleItems == null)
{
mVisibleItems = new LinkedList<ImageListViewItem>(mItems);
mInvisibleItems = new LinkedList<ImageListViewItem>();
}
if (key.Length > mLastSearch.Length)
{
ToggleMatchedItems(mVisibleItems, mInvisibleItems, false, key, attrType);
}
else if (key.Length < mLastSearch.Length)
{
ToggleMatchedItems(mInvisibleItems, mVisibleItems, true, key, attrType);
}
mImageListView.Items.Clear(false);
mImageListView.SuspendLayout();
foreach (ImageListViewItem item in mVisibleItems)
{
mImageListView.Items.Add(item, mAdaptor);
}
mImageListView.ResumeLayout();
mLastSearch = key;
}
/// <summary>
/// Filter out items in ImageListView according to given criterion.
/// </summary>
/// <param name="key">An item is visible only if it contains this string</param>
internal void FilterWith(string key, ColumnType attrType)
{
if (mItems == null)
{
throw new InvalidOperationException("Method Snapshot() should be called before the first search.");
}
mImageListView.Items.Clear(false);
if (key.Length == 0) // reset items
{
mImageListView.Items.AddRange(mItems, mAdaptor);
}
else
{
string uKey = key.ToUpperInvariant();
mImageListView.SuspendLayout();
foreach (ImageListViewItem item in mItems)
{
Boolean isMatched = false;
switch (attrType)
{
case ColumnType.Name:
isMatched = item.Text.Contains(uKey); break;
default:
throw new NotImplementedException();
}
if (isMatched) mImageListView.Items.Add(item, mAdaptor);
}
mImageListView.ResumeLayout();
}
mLastSearch = key;
}
public void AddColumn(string colName, int width, ColumnType columnType, string description, RenderTableCell renderer,
bool persistent)
{
AddColumn(colName, width, columnType, description, renderer);
if (persistent){
AddPersistentColumn(colName, width, columnType, description, renderer);
}
}
public DataTypeItem(DataType dataType, ColumnType[] allowedColumns)
{
eX4XcIhHpDXt70u2x3N.k8isAcYzkUOGF();
// ISSUE: explicit constructor call
base.\u002Ector();
this.mjxdnU89b0 = dataType;
this.Awnd7GaIPh = new ArrayList((ICollection) allowedColumns);
}
public void AddColumn(string tableName, string columnName, ColumnType columnType)
{
var tableForInsert = getTable(tableName);
if (hasColumn(tableForInsert, columnName))
throw new ZException("Table [{0}] already contains column with specified name: {1}.", tableName, columnName);
tableForInsert.Columns.Add(new Column(columnName, columnType));
}
private ColumnDefinitionPayload(string name, CharacterSet characterSet, int columnLength, ColumnType columnType, ColumnFlags columnFlags)
{
Name = name;
CharacterSet = characterSet;
ColumnLength = columnLength;
ColumnType = columnType;
ColumnFlags = columnFlags;
}
/// <summary>
/// Initializes a new instance of the EsentInvalidConversionException class.
/// </summary>
/// <param name="tablename">The name of the table the column wasn't found in.</param>
/// <param name="columnName">The name of the column.</param>
/// <param name="columnType">The type of column data was being converted for.</param>
/// <param name="objectType">The type of object that the conversion failed for.</param>
/// <param name="innerException">The exception raised during conversion.</param>
internal EsentInvalidConversionException(string tablename, string columnName, ColumnType columnType, Type objectType, Exception innerException)
: base(String.Format("Unable to convert an object of type {0} for column '{1}' ({2}) of table '{3}'", objectType, columnName, columnType, tablename), innerException)
{
this.Data["table"] = tablename;
this.Data["column"] = columnName;
this.Data["columnType"] = columnType;
this.Data["objectType"] = objectType;
}
public Column()
{
eX4XcIhHpDXt70u2x3N.k8isAcYzkUOGF();
// ISSUE: explicit constructor call
base.\u002Ector();
this.aBGgvFVujA = ColumnType.Skipped;
this.NrkgoRFju2 = "";
}
public static string Translate(ColumnType type, int length, int precision, int scale, string customType)
{
string physicalTypeString = String.Empty;
length = length >= 1 ? length : 1;
switch(type)
{
case ColumnType.CUSTOM:
physicalTypeString = customType;
break;
case ColumnType.INT32:
physicalTypeString = "INTEGER";
break;
case ColumnType.UINT32:
physicalTypeString = "INTEGER";
break;
case ColumnType.INT64:
physicalTypeString = "BIGINT";
break;
case ColumnType.UINT64:
physicalTypeString = "BIGINT";
break;
case ColumnType.DOUBLE:
physicalTypeString = "FLOAT";
break;
case ColumnType.FLOAT:
physicalTypeString = "FLOAT";
break;
case ColumnType.BOOL:
physicalTypeString = "BIT";
break;
case ColumnType.DATE:
physicalTypeString = "DATE";
break;
case ColumnType.TIME:
physicalTypeString = String.Format("TIME({0})",scale >= 0 ? scale : 7);
break;
case ColumnType.DATETIME:
//physicalTypeString = String.Format("DATETIMEOFFSET({0})", scale >= 0 ? scale : 7);
physicalTypeString = "DATETIME2(7)";
break;
case ColumnType.DECIMAL:
physicalTypeString = String.Format("DECIMAL({0},{1})", precision >= 1 ? precision : 38, scale >= 0 ? scale : 0);
break;
case ColumnType.BINARY:
physicalTypeString = String.Format("BINARY VARYING({0})", length <= 8000 ? length.ToString() : "max");
break;
case ColumnType.WSTR:
physicalTypeString = String.Format("NATIONAL CHARACTER VARYING({0})", length <= 4000 ? length.ToString() : "max");
break;
case ColumnType.STR:
physicalTypeString = String.Format("CHARACTER VARYING({0})", length <= 8000 ? length.ToString() : "max");
break;
default:
throw new Exception("Unknown Data Type");
}
return physicalTypeString;
}
public void InsertDMIn(TwitterDirectMessage dm, ColumnType colType)
{
for (int i = 0; i < flowColumns.Controls.Count; i++) {
ColumnControl cc = (ColumnControl)flowColumns.Controls[i];
if (cc.ColType == colType) {
cc.InsertDM(cc.flowColumn, dm);
}
}
}
public void InsertTweetIn(TwitterStatus tweet, ColumnType colType)
{
for (int i = 0; i < flowColumns.Controls.Count; i++) {
ColumnControl cc = (ColumnControl)flowColumns.Controls[i];
if (cc.ColType == colType) {
cc.InsertTweet(cc.flowColumn, tweet);
}
}
}
private Column GetColumn(ColumnType type)
{
foreach (Column column in (List<Column>) this.Columns)
{
if (type == column.ColumnType)
return column;
}
return (Column)null;
}
/// <summary>
/// Initializes a new instance of the ImageListViewColumnHeader class.
/// </summary>
/// <param name="type">The type of data to display in this column.</param>
/// <param name="text">Text of the column header.</param>
/// <param name="width">Width in pixels of the column header.</param>
public ImageListViewColumnHeader(ColumnType type, string text, int width)
{
mImageListView = null;
owner = null;
mText = text;
mType = type;
mWidth = width;
mVisible = true;
mDisplayIndex = -1;
}
private bool _unique; // just for scripting; all indexes are made unique
#endregion Fields
#region Constructors
public Index(string name, int[] column, ColumnType[] type, bool unique)
{
_name = name;
_fields = column.Length;
_column = column;
_type = type;
_unique = unique;
_column_0 = _column[0];
_type_0 = _type[0];
}
public TestFactory()
{
ObservableCollection<ColumnType> listOfProperties = new ObservableCollection<ColumnType>();
ColumnType ct = new ColumnType();
ct.Name = "name";
ct.Type = typeof(string).AssemblyQualifiedName;
listOfProperties.Add(ct);
factory = Factory.GetInstance(listOfProperties);
}
/// <summary>
/// Refresh the dynamic columns
/// </summary>
public void Refresh()
{
if (_source == null || !DynamicColumns)
{
return;
}
try
{
Information = "";
Error = "";
MustRefresh = true;
//Build table def from SQL or table name
var sql = "";
if (IsForSQLModel)
{
if (Model.UseRawSQL)
{
sql = Sql;
}
else
{
sql = string.Format("SELECT * FROM ({0}) a WHERE 1=0", Sql);
}
}
else
{
string CTE = "", name = "";
GetExecSQLName(ref CTE, ref name);
sql = string.Format("{0}SELECT * FROM {1} WHERE 1=0", CTE, name);
}
DataTable defTable = GetDefinitionTable(sql);
foreach (DataColumn column in defTable.Columns)
{
string fullColumnName = (IsSQL && !IsForSQLModel ? Source.GetTableName(AliasName) + "." : "") + Source.GetColumnName(column.ColumnName);
MetaColumn newColumn = Columns.FirstOrDefault(i => i.Name == fullColumnName);
column.ColumnName = fullColumnName; //Set it here to clear the columns later
ColumnType type = Helper.NetTypeConverter(column.DataType);
if (newColumn == null)
{
newColumn = MetaColumn.Create(fullColumnName);
newColumn.Source = _source;
newColumn.DisplayName = (KeepColumnNames ? column.ColumnName.Trim() : Helper.DBNameToDisplayName(column.ColumnName.Trim()));
newColumn.Category = (Alias == MetaData.MasterTableName ? "Master" : AliasName);
newColumn.DisplayOrder = GetLastDisplayOrder();
Columns.Add(newColumn);
newColumn.Type = type;
newColumn.SetStandardFormat();
}
newColumn.Source = _source;
if (type != newColumn.Type)
{
newColumn.Type = type;
newColumn.SetStandardFormat();
}
}
//Clear columns for No SQL or SQL Model
if (!IsSQL || IsForSQLModel)
{
Columns.RemoveAll(i => !defTable.Columns.Contains(i.Name));
}
MustRefresh = false;
Information = "Dynamic columns have been refreshed successfully";
}
catch (Exception ex)
{
Error = ex.Message;
Information = "Error got when refreshing dynamic columns.";
}
Information = Helper.FormatMessage(Information);
UpdateEditorAttributes();
}
// Checks that all the label columns of the model have the same key type as their label column - including the same
// cardinality and the same key values, and returns the cardinality of the label column key.
private static int CheckKeyLabelColumnCore <T>(IHostEnvironment env, IPredictorModel[] models, KeyType labelType, ISchema schema, int labelIndex, ColumnType keyValuesType)
where T : IEquatable <T>
{
env.Assert(keyValuesType.ItemType.RawType == typeof(T));
env.AssertNonEmpty(models);
var labelNames = default(VBuffer <T>);
schema.GetMetadata(MetadataUtils.Kinds.KeyValues, labelIndex, ref labelNames);
var classCount = labelNames.Length;
var curLabelNames = default(VBuffer <T>);
for (int i = 1; i < models.Length; i++)
{
var model = models[i];
var edv = new EmptyDataView(env, model.TransformModel.InputSchema);
model.PrepareData(env, edv, out RoleMappedData rmd, out IPredictor pred);
var labelInfo = rmd.Schema.Label;
if (labelInfo == null)
{
throw env.Except("Training schema for model {0} does not have a label column", i);
}
var curLabelType = rmd.Schema.Schema.GetColumnType(rmd.Schema.Label.Index);
if (!labelType.Equals(curLabelType.AsKey))
{
throw env.Except("Label column of model {0} has different type than model 0", i);
}
var mdType = rmd.Schema.Schema.GetMetadataTypeOrNull(MetadataUtils.Kinds.KeyValues, labelInfo.Index);
if (!mdType.Equals(keyValuesType))
{
throw env.Except("Label column of model {0} has different key value type than model 0", i);
}
rmd.Schema.Schema.GetMetadata(MetadataUtils.Kinds.KeyValues, labelInfo.Index, ref curLabelNames);
if (!AreEqual(ref labelNames, ref curLabelNames))
{
throw env.Except("Label of model {0} has different values than model 0", i);
}
}
return(classCount);
}
public string[] GetLabelNamesOrNull(out ColumnType labelType)
{
Host.AssertNonEmpty(PredictorModels);
return(PredictorModels[0].GetLabelInfo(Host, out labelType));
}
private static IDataTransform CreateLambdaTransform(IHost host, IDataView input, string inputColumnName,
string outputColumnName, Action <TState> initFunction, bool hasBuffer, ColumnType outputColTypeOverride)
{
var inputSchema = SchemaDefinition.Create(typeof(DataBox <TInput>));
inputSchema[0].ColumnName = inputColumnName;
var outputSchema = SchemaDefinition.Create(typeof(DataBox <TOutput>));
outputSchema[0].ColumnName = outputColumnName;
if (outputColTypeOverride != null)
{
outputSchema[0].ColumnType = outputColTypeOverride;
}
Action <DataBox <TInput>, DataBox <TOutput>, TState> lambda;
if (hasBuffer)
{
lambda = MapFunction;
}
else
{
lambda = MapFunctionWithoutBuffer;
}
return(LambdaTransform.CreateMap(host, input, lambda, initFunction, inputSchema, outputSchema));
}
private bool IsNumeric(int ind)
{
ColumnType c = columnTypes[ind];
return(c == ColumnType.Expression || c == ColumnType.Integer || c == ColumnType.Numeric || c == ColumnType.NumericLog);
}
public ColumnAttribute(string columnName, ColumnType columnType)
{
this.ColumnName = columnName;
this.ColumnType = columnType;
}
/// <summary>
/// Assign a normalizer to the specified column type for output.
/// </summary>
/// <param name="colType">The column type.</param>
/// <param name="norm">The normalizer.</param>
public void AssignOutputNormalizer(ColumnType colType, INormalizer norm)
{
_outputNormalizers[colType] = norm;
}
/// <summary> /// Whether this type is a standard scalar type completely determined by its <see cref="ColumnType.RawType"/> /// (not a <see cref="KeyType"/> or <see cref="StructuredType"/>, etc). /// </summary> public static bool IsStandardScalar(this ColumnType columnType) => (columnType is NumberType) || (columnType is TextType) || (columnType is BoolType) || (columnType is TimeSpanType) || (columnType is DateTimeType) || (columnType is DateTimeOffsetType);
/// <summary> /// Zero return means either it's not a key type or the cardinality is unknown. /// </summary> public static int GetKeyCount(this ColumnType columnType) => (columnType as KeyType)?.Count ?? 0;
internal abstract IColumnFunctionBuilder MakeBuilder(IHost host, int srcIndex, ColumnType srcType, RowCursor cursor);
public ExportColumn()
{
columnType = ColumnType.InternalName;
}
public ExportColumn(ColumnType _columnType)
{
columnType = _columnType;
}
// When the label column is not a key, we check that the number of classes is the same for all the predictors, by checking the
// OutputType property of the IValueMapper.
// If any of the predictors do not implement IValueMapper we throw an exception. Returns the class count.
private static int CheckNonKeyLabelColumnCore(IHostEnvironment env, IPredictor pred, IPredictorModel[] models, bool isBinary, ColumnType labelType)
{
env.Assert(!labelType.IsKey);
env.AssertNonEmpty(models);
if (isBinary)
{
return(2);
}
// The label is numeric, we just have to check that the number of classes is the same.
if (!(pred is IValueMapper vm))
{
throw env.Except("Cannot determine the number of classes the predictor outputs");
}
var classCount = vm.OutputType.VectorSize;
for (int i = 1; i < models.Length; i++)
{
var model = models[i];
var edv = new EmptyDataView(env, model.TransformModel.InputSchema);
model.PrepareData(env, edv, out RoleMappedData rmd, out pred);
vm = pred as IValueMapper;
if (vm.OutputType.VectorSize != classCount)
{
throw env.Except("Label of model {0} has different number of classes than model 0", i);
}
}
return(classCount);
}
/// <summary>
/// Returns the sub item item text corresponding to the specified column type.
/// </summary>
/// <param name="type">The type of information to return.</param>
/// <returns>Formatted text for the given column type.</returns>
public string GetSubItemText(ColumnType type)
{
switch (type)
{
case ColumnType.DateAccessed:
if (DateAccessed == DateTime.MinValue)
{
return("");
}
else
{
return(DateAccessed.ToString("g"));
}
case ColumnType.DateCreated:
if (DateCreated == DateTime.MinValue)
{
return("");
}
else
{
return(DateCreated.ToString("g"));
}
case ColumnType.DateModified:
if (DateModified == DateTime.MinValue)
{
return("");
}
else
{
return(DateModified.ToString("g"));
}
case ColumnType.FileName:
return(FileName);
case ColumnType.Name:
return(Text);
case ColumnType.FilePath:
return(FilePath);
case ColumnType.FileSize:
if (FileSize == 0)
{
return("");
}
else
{
return(Utility.FormatSize(FileSize));
}
case ColumnType.FileType:
return(FileType);
case ColumnType.Dimensions:
if (Dimensions == Size.Empty)
{
return("");
}
else
{
return(string.Format("{0} x {1}", Dimensions.Width, Dimensions.Height));
}
case ColumnType.Resolution:
if (Resolution == SizeF.Empty)
{
return("");
}
else
{
return(string.Format("{0} x {1}", Resolution.Width, Resolution.Height));
}
case ColumnType.ImageDescription:
return(ImageDescription);
case ColumnType.EquipmentModel:
return(EquipmentModel);
case ColumnType.DateTaken:
if (DateTaken == DateTime.MinValue)
{
return("");
}
else
{
return(DateTaken.ToString("g"));
}
case ColumnType.Artist:
return(Artist);
case ColumnType.Copyright:
return(Copyright);
case ColumnType.ExposureTime:
return(ExposureTime);
case ColumnType.FNumber:
if (FNumber == 0.0f)
{
return("");
}
else
{
return(FNumber.ToString("f2"));
}
case ColumnType.ISOSpeed:
if (ISOSpeed == 0)
{
return("");
}
else
{
return(ISOSpeed.ToString());
}
case ColumnType.ShutterSpeed:
return(ShutterSpeed);
case ColumnType.Aperture:
return(Aperture);
case ColumnType.UserComment:
return(UserComment);
default:
throw new ArgumentException("Unknown column type", "type");
}
}
/// <summary>
/// 构造
/// </summary>
/// <param name="columnType"></param>
public NumberPrecentageDataType(ColumnType columnType) : base(columnType)
{
}
private IColumnView readArrayColumn(JsonReader reader, ColumnType type, int rowCount)
{
readCheck(reader, JsonToken.PropertyName, "values");
readCheck(reader, JsonToken.StartArray);
switch (type)
{
case ColumnType.String:
{
string[] values = new string[rowCount];
int i = 0;
while (i < rowCount)
{
values[i++] = reader.ReadAsString();
}
readCheck(reader, JsonToken.EndArray);
return(new StringArrayColumnView(values));
}
case ColumnType.Number:
{
double[] values = new double[rowCount];
int i = 0;
while (i < rowCount)
{
reader.Read();
if (reader.TokenType == JsonToken.Null)
{
values[i++] = double.NaN;
}
else
{
values[i++] = (double)reader.Value;
}
}
readCheck(reader, JsonToken.EndArray);
return(new DoubleArrayColumnView(values));
}
case ColumnType.Boolean:
{
byte[] values = new byte[rowCount];
int i = 0;
while (i < rowCount)
{
reader.Read();
if (reader.TokenType == JsonToken.Null)
{
values[i++] = BooleanArrayColumnView.MISSING;
}
else
{
values[i++] = (byte)(((bool)reader.Value) ? 1 : 0);
}
}
readCheck(reader, JsonToken.EndArray);
return(new BooleanArrayColumnView(values));
}
}
throw new Exception(string.Format("Unsupported type '{0}'", type));
}
public Pair <int> constraintNum; //constraintNum is a catchall variable for the 4 different constraint types, since each can be labeled by 2 integers.
//Cells are labelled by (row,column), rows by (row,content), columns by (column,content), and squares by (square, content).
//Squares are labelled via: 1 2 3
// 4 5 6
// 7 8 9
public SudokuColumnHeader(ColumnType t, Pair <int> constraints)
{
type = t; constraintNum = constraints;
}
public Plays Plays(ColumnType type) => _plays.Single(x => x.Type == type);
public ColInfo(int index, ColumnType type)
{
Index = index;
Type = type;
}
/// <summary>
/// Adds an output variable to the list.
/// </summary>
public void AddOutputVariable(ColumnType type, string variableName, List <long> dim = null)
{
_host.CheckValue(type, nameof(type));
_host.CheckParam(IsVariableDefined(variableName), nameof(variableName));
_outputs.Add(OnnxUtils.GetModelArgs(type, variableName, dim));
}
public GridEXColumn AddColumn(string colName, ColumnType colType, int width, ColumnBoundMode boundMode, string caption, FilterEditType editType)
{
return(AddColumn(colName, colType, width, boundMode, caption, editType, TextAlignment.Near));
}
/// <summary>
/// The main constructor for the sequential transform
/// </summary>
/// <param name="host">The host.</param>
/// <param name="windowSize">The size of buffer used for windowed buffering.</param>
/// <param name="initialWindowSize">The number of datapoints picked from the beginning of the series for training the transform parameters if needed.</param>
/// <param name="inputColumnName">The name of the input column.</param>
/// <param name="outputColumnName">The name of the dst column.</param>
/// <param name="outputColType"></param>
private protected SequentialTransformerBase(IHost host, int windowSize, int initialWindowSize, string inputColumnName, string outputColumnName, ColumnType outputColType)
{
Host = host;
Host.CheckParam(initialWindowSize >= 0, nameof(initialWindowSize), "Must be non-negative.");
Host.CheckParam(windowSize >= 0, nameof(windowSize), "Must be non-negative.");
// REVIEW: Very bad design. This base class is responsible for reporting errors on
// the arguments, but the arguments themselves are not derived form any base class.
Host.CheckNonEmpty(inputColumnName, nameof(PercentileThresholdTransform.Arguments.Source));
Host.CheckNonEmpty(outputColumnName, nameof(PercentileThresholdTransform.Arguments.Source));
InputColumnName = inputColumnName;
OutputColumnName = outputColumnName;
OutputColumnType = outputColType;
InitialWindowSize = initialWindowSize;
WindowSize = windowSize;
}
public ColumnDef(string name, ColumnType type, int ord)
{
name_ = Utils.normalizeName(name);
type_ = type; ordinal_ = ord;
}
/* Function: GetColumn
* Returns the bounds of a parameter's column and what type it is, which depends on <ColumnOrder>. You *must* call
* <CalculateColumns()> beforehand. Returns false if the column index is out of bounds or the contents are empty for
* that particular slot.
*/
public bool GetColumn(int columnIndex, out TokenIterator start, out TokenIterator end, out ColumnType type)
{
if (columnIndex >= columnIndexes.Length)
{
start = parsedPrototype.Tokenizer.LastToken;
end = parsedPrototype.Tokenizer.LastToken;
type = ColumnType.Name;
return(false);
}
int startIndex = columnIndexes[columnIndex];
int endIndex = (columnIndex + 1 >= columnIndexes.Length ? endOfColumnsIndex : columnIndexes[columnIndex + 1]);
start = parsedPrototype.Tokenizer.FirstToken;
if (startIndex > 0)
{
start.Next(startIndex);
}
end = start;
if (endIndex > startIndex)
{
end.Next(endIndex - startIndex);
}
type = ColumnOrder[columnIndex];
end.PreviousPastWhitespace(PreviousPastWhitespaceMode.EndingBounds, start);
start.NextPastWhitespace(end);
return(end > start);
}
public ColumnBinding(string property, ColumnType type) : this(property, property, type)
{
}
/// <summary> /// Establishes a new mapping from an data view column in the context, if necessary generates a unique name, and /// returns that newly allocated name. /// </summary> /// <param name="type">The data view type associated with this column name</param> /// <param name="colName">The data view column name</param> /// <param name="skip">Whether we should skip the process of establishing the mapping from data view column to /// ONNX variable name.</param> /// <returns>The returned value is the name of the variable corresponding </returns> public abstract string AddIntermediateVariable(ColumnType type, string colName, bool skip = false);
public void ForcePlay(ColumnType columnType)
{
HasForcedPlay = true;
ForcedPlayColumnType = columnType;
}
public void ShowFieldSelector(int i)
{
columnType = (ColumnType)EditorGUILayout.EnumPopup("Column #" + (i + 1).ToString(), columnType);
}
internal override IColumnFunctionBuilder MakeBuilder(IHost host, int srcIndex, ColumnType srcType, RowCursor cursor) => NormalizeTransform.LogMeanVarUtils.CreateBuilder(this, host, srcIndex, srcType, cursor);
internal override IColumnFunctionBuilder MakeBuilder(IHost host, int srcIndex, ColumnType srcType, RowCursor cursor) => NormalizeTransform.SupervisedBinUtils.CreateBuilder(this, host, LabelColumn, srcIndex, srcType, cursor);