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