public NumberValue BinaryGet(BinaryValue value, NumberValue index) { if (index.Value < 0 || index.Value > value.Value.Length) { throw ProgramError.Fatal("Binary", "get index out of range"); } return(NumberValue.Create(value.Value[(int)index.Value])); }
// Create new table using only the rows after the first N public RelationValue Skip(RelationValue relarg, NumberValue howmany) { Logger.WriteLine(3, "Skip {0} {1}", relarg, howmany); var relnew = relarg.Value.Skip(howmany); Logger.WriteLine(3, "[S {0}]", relnew); return(RelationValue.Create(relnew)); }
// Take -- take some rows, discard the rest public override DataTable Take(NumberValue value) { var count = (int)Math.Max(0, Math.Min(value.Value, int.MaxValue)); var newtable = AddLimit(count); Logger.WriteLine(4, "[Take '{0}']", newtable); return(newtable); }
// Create new table using only the first N rows public RelationValue Take(RelationValue relarg, NumberValue howmany) { Logger.WriteLine(3, "Take {0} {1}", relarg, howmany); var relnew = relarg.Value.Take(howmany); Logger.WriteLine(3, "[T {0}]", relnew); return(RelationValue.Create(relnew)); }
// Recursive expansion public RelationValue Recurse(RelationValue relarg, NumberValue flags, CodeValue exprarg) { Logger.WriteLine(3, "Recurse {0} {1} {2}", relarg, flags, exprarg); var relnew = relarg.Value.Recurse((int)flags.Value, exprarg.AsEval); Logger.WriteLine(3, "[Rec {0}]", relnew); return(RelationValue.Create(relnew)); }
// Return rank of attribute with tuple indexing public TypedValue Rank(CodeValue attribute, NumberValue index, PointerValue lookup) { var row = lookup.Value as DataRow; Logger.Assert(row != null, "lookup is not row"); var value = attribute.AsEval.EvalOpen(row); var offset = row.Heading.FindIndex(attribute.AsEval.Name); return(NumberValue.Create(index.Value + 1)); }
// Parse string as number public NumberValue Number(TextValue value) { decimal d; if (Decimal.TryParse(value.Value, out d)) { return(NumberValue.Create(d)); } throw ProgramError.Fatal("Convert", "not a valid number"); }
// Fold an operation and one argument over a set of tuples public TypedValue Fold(PointerValue accblkarg, NumberValue accidarg, TypedValue defarg, CodeValue expr) { Logger.WriteLine(3, "Fold n={0} def={1} expr={2}", accidarg, defarg, expr); var accblock = accblkarg.Value as AccumulatorBlock; var accid = (int)accidarg.Value; var accum = accblock[accid] ?? defarg; accblock[accid] = expr.AsEval.EvalIsFolded(null, accblock[accid]); Logger.WriteLine(3, "[Fold {0}]", accblock[accid]); return(accblock[accid]); }
public BinaryValue BinarySet(BinaryValue value, NumberValue index, NumberValue newvalue) { if (index.Value < 0 || index.Value > value.Value.Length) { throw ProgramError.Fatal("Binary", "set index out of range"); } var b = value.Value.Clone() as byte[]; b[(int)index.Value] = (byte)newvalue.Value; return(BinaryValue.Create(b)); }
// Update Join with joinop bit flags public VoidValue UpdateJoin(RelationValue rel1, RelationValue rel2, NumberValue joparg) { var joinop = (JoinOps)joparg.Value; Logger.WriteLine(3, "UpdateJoin {0} {1} {2}", rel1, rel2, joinop); // note: two different algorithms depending on dyadic status rel1.Value.UpdateJoin(rel2.Value, joinop); Logger.WriteLine(3, "[UJ]"); return(VoidValue.Default); }
// Dyadic tuple: does Set ops depending on joinop bit flags public TupleValue DyadicTuple(TupleValue tup1, TupleValue tup2, NumberValue joparg) { var joinop = (JoinOps)joparg.Value; var mergeop = (MergeOps)((int)(joinop & JoinOps.SETOPS) >> 3); // FIX: bit func? var newheading = DataHeading.Merge(mergeop, tup1.Value.Heading, tup2.Value.Heading); Logger.WriteLine(3, "DyadicTuple {0} {1} n={2} ({3} {4})", tup1, tup2, joparg, mergeop, newheading); var tupnew = DataRow.Create(newheading, tup1.Value, tup2.Value); Logger.WriteLine(3, "[DT {0}]", tupnew); return(TupleValue.Create(tupnew)); }
// Pad on left with spaces or truncate to right to length public TextValue Right(TextValue arg1, NumberValue arg2) { if (arg2.Value < 0) { return(TextValue.Default); } var str = arg1.Value; var len = (int)arg2.Value; var strx = (len >= str.Length) ? str.PadLeft(len) : str.Substring(str.Length - len, len); return(TextValue.Create(strx)); }
// Dyadic: does Join, Antijoin or Set ops depending on joinop bit flags public RelationValue DyadicSet(RelationValue rel1, RelationValue rel2, NumberValue joparg) { var joinop = (JoinOps)joparg.Value; var mergeop = (MergeOps)(joinop & JoinOps.MERGEOPS); var newheading = DataHeading.Merge(mergeop, rel1.Value.Heading, rel2.Value.Heading); Logger.WriteLine(3, "DyadicSet {0} {1} n={2} ({3} {4})", rel1, rel2, joparg, mergeop, newheading); var rel1res = DataTable.ResolveDyadic(rel1.Value, rel2.Value); var relnew = rel1res.DyadicSet(rel2.Value, joinop, newheading); Logger.WriteLine(3, "[DS {0}]", relnew); return(RelationValue.Create(relnew)); }
// sequence of integers public RelationValue Sequence(NumberValue countarg) { var heading = DataHeading.Create("N:number"); var table = DataTableLocal.Create(heading); var n = Decimal.Zero; var count = (int)countarg.Value; for (var i = 0; i < count; ++i) { table.AddRow(DataRow.Create(heading, new TypedValue[] { NumberValue.Create(n) })); n += 1; } return(RelationValue.Create(table)); }
// Take -- take some rows, discard the rest public override DataTable Take(NumberValue value) { var newtable = DataTableLocal.Create(Heading); var count = value.Value; foreach (var row in GetRows()) //TODO:Enumerable { if (count-- > 0) { newtable.AddRow(row); } } return(newtable); }
// Multiple copies of a string to fill a length public TextValue Fill(TextValue arg1, NumberValue arg2) { if (arg2.Value < 0) { return(TextValue.Default); } StringBuilder sb = new StringBuilder(); var times = ((int)arg2.Value + arg1.Value.Length - 1) / arg1.Value.Length; while (times-- > 0) { sb.Append(arg1.Value); } return(TextValue.Create(sb.ToString(0, (int)arg2.Value))); }
// Converter driven by source type TypedValue Converter(ConversionTypes type, object value) { switch (type) { case ConversionTypes.Bool: return(BoolValue.Create((bool)value)); case ConversionTypes.Int: return(NumberValue.Create((int)value)); case ConversionTypes.String: return(TextValue.Create((string)value)); case ConversionTypes.Decimal: return(NumberValue.Create((decimal)value)); case ConversionTypes.DateTime: return(TimeValue.Create((DateTime)value)); default: return(TypedValue.Empty); } }
static NumberValue() { Zero = new NumberValue { Value = Decimal.Zero }; One = new NumberValue { Value = Decimal.One }; Minimum = new NumberValue { Value = Decimal.MinValue }; Maximum = new NumberValue { Value = Decimal.MaxValue }; Default = new NumberValue { Value = Decimal.Zero }; }
void AddMember(string parent, DataHeading heading) { int index = 0; foreach (var column in heading.Columns) { var addrow = DataRow.Create(Table.Heading, new TypedValue[] { TextValue.Create(parent), NumberValue.Create(++index), TextValue.Create(column.Name), TextValue.Create(column.DataType.BaseType.Name), TextValue.Create(column.DataType.GetUniqueName ?? "") }); Table.AddRow(addrow); // Recursive call. note: may be duplicate, but no matter. if (column.DataType.GetUniqueName != null) { AddMember(column.DataType.GetUniqueName, column.DataType.Heading); } } }
public static TypedValue Parse(DataType type, string value) { if (type == DataTypes.Bool) { return(BoolValue.Create(bool.Parse(value))); } if (type == DataTypes.Number) { return(NumberValue.Create(Decimal.Parse(value))); } if (type == DataTypes.Time) { return(TimeValue.Create(DateTime.Parse(value))); } if (type == DataTypes.Text) { return(TextValue.Create(value)); } return(TypedValue.Empty); }
// Return degree as scalar public NumberValue Degree(RelationValue arg) { return(NumberValue.Create(arg.Value.Degree)); }
// Return cardinality as scalar public NumberValue Count(RelationValue arg) { return(NumberValue.Create(arg.Value.GetCount())); }
public NumberValue Pow(NumberValue arg1, NumberValue arg2) { var v = Math.Pow((double)arg1.Value, (double)arg2.Value); return(NumberValue.Create((decimal)v)); }
public NumberValue Mod(NumberValue arg1, NumberValue arg2) { return(NumberValue.Create(Decimal.Remainder(Decimal.Truncate(arg1.Value), Decimal.Truncate(arg2.Value)))); }
public NumberValue Div(NumberValue arg1, NumberValue arg2) { return(NumberValue.Create(Decimal.Truncate(Decimal.Divide(Decimal.Truncate(arg1.Value), Decimal.Truncate(arg2.Value))))); }
public NumberValue Divide(NumberValue arg1, NumberValue arg2) { return(NumberValue.Create(arg1.Value / arg2.Value)); }
public NumberValue Multiply(NumberValue arg1, NumberValue arg2) { return(NumberValue.Create(arg1.Value * arg2.Value)); }
public NumberValue Subtract(NumberValue arg1, NumberValue arg2) { return(NumberValue.Create(arg1.Value - arg2.Value)); }
public NumberValue Add(NumberValue arg1, NumberValue arg2) { return(NumberValue.Create(arg1.Value + arg2.Value)); }
///================================================================= /// /// Arithmetic operations /// public NumberValue Neg(NumberValue arg1) { return(NumberValue.Create(-arg1.Value)); }