public void EvalFlip(RCRunner runner, RCClosure closure, RCBlock right) { RCBlock prototype = (RCBlock)right.Get(0); string[] names = new string[prototype.Count]; RCVectorBase[] columns = new RCVectorBase[prototype.Count]; for (int i = 0; i < prototype.Count; ++i) { RCBlock name = prototype.GetName(i); RCVectorBase scalar = (RCVectorBase)name.Value; columns[i] = RCVectorBase.FromScalar(scalar.Child(0)); names[i] = name.Name; } for (int i = 1; i < right.Count; ++i) { RCBlock row = (RCBlock)right.Get(i); for (int j = 0; j < row.Count; ++j) { RCBlock name = (RCBlock)row.GetName(j); int n = Array.IndexOf(names, name.Name); if (n >= 0) { RCVectorBase scalar = (RCVectorBase)name.Value; columns[n].Write(scalar.Child(0)); } } } RCBlock result = RCBlock.Empty; for (int i = 0; i < names.Length; ++i) { result = new RCBlock(result, names[i], ":", columns[i]); } runner.Yield(closure, result); }
public static RCVector <L> DoAt <L> (RCClosure closure, RCVector <L> left, RCVector <decimal> right) { L[] result = new L[right.Count]; for (int i = 0; i < right.Count; ++i) { if (right[i] < 0) { int j = (int)(left.Count + right[i]); if (j < 0 || j >= left.Count) { throw RCException.Range(closure, (long)right[i], left.Count); } result[i] = left[j]; } else { int j = (int)right[i]; if (j < 0 || j >= left.Count) { throw RCException.Range(closure, (long)right[i], left.Count); } result[i] = left[j]; } } return((RCVector <L>)RCVectorBase.FromArray(new RCArray <L> (result))); }
public void EvalUnflip(RCRunner runner, RCClosure closure, RCBlock right) { // Take a block of arrays and turn them into a block of rows. RCBlock[] blocks = new RCBlock[right.Get(0).Count]; for (int i = 0; i < blocks.Length; ++i) { blocks[i] = RCBlock.Empty; } for (int i = 0; i < right.Count; ++i) { RCBlock name = right.GetName(i); RCVectorBase vector = (RCVectorBase)name.Value; for (int j = 0; j < vector.Count; ++j) { RCValue box = RCVectorBase.FromScalar(vector.Child(j)); blocks[j] = new RCBlock(blocks[j], name.Name, ":", box); } } RCBlock result = RCBlock.Empty; for (int i = 0; i < blocks.Length; ++i) { result = new RCBlock(result, "", ":", blocks[i]); } runner.Yield(closure, result); }
protected virtual void DoEach <T> (RCRunner runner, RCClosure closure, RCBlock left, RCVector <T> right) { if (right.Count == 0) { runner.Yield(closure, RCBlock.Empty); return; } int i = closure.Index - 2; if (i < right.Count) { RCBlock result = new RCBlock("I", ":", new RCLong(i)); result = new RCBlock(result, "R", ":", RCVectorBase.FromArray(new RCArray <T> (right[i]))); left.Eval(runner, new RCClosure(closure, closure.Bot, left, closure.Left, result, 0)); } else { runner.Yield(closure, closure.Parent.Result); } }
protected RCValue ReorderColumn <T> (RCLong rank, RCVector <T> column) where T : IComparable <T> { return(RCVectorBase.FromArray( VectorMath.MonadicOp <long, T> (rank.Data, delegate(long r) { return column[(int)r]; }))); }
public static RCVector <L> DoWhere <L> (RCVector <L> left, RCVector <bool> right) { RCArray <L> result = new RCArray <L> (); for (int i = 0; i < right.Count; ++i) { if (right[i]) { result.Write(left[i]); } } return((RCVector <L>)RCVectorBase.FromArray(new RCArray <L> (result))); }
public void EvalDyadic(RCRunner runner, RCClosure closure, object left, object right) { // Brian! come back here to prevent the native exception RCOperator op = (RCOperator)closure.Code; RCVectorBase leftVector = left as RCVectorBase; RCVectorBase rightVector = right as RCVectorBase; if (leftVector == null || rightVector == null) { throw RCException.Overload(closure, op.Name, left, right); } runner.Yield(closure, VectorMath.InvokeDyadic(closure, op.Name, leftVector, rightVector)); }
public static RCVector <L> DoAt <L> (RCClosure closure, RCVector <L> left, RCVector <byte> right) { L[] result = new L[right.Count]; for (int i = 0; i < right.Count; ++i) { int j = right[i]; if (j < 0 || j >= left.Count) { throw RCException.Range(closure, right[i], left.Count); } result[i] = left[j]; } return((RCVector <L>)RCVectorBase.FromArray(new RCArray <L> (result))); }
public static RCValue InvokeSequential(RCClosure closure, string name, RCVectorBase right) { RCActivator.OverloadKey key = new RCActivator.OverloadKey(name, typeof(object), null, right.ScalarType); Overload overload; if (!_overloads.TryGetValue(key, out overload)) { throw RCException.Overload(closure, name, right); } object array = overload.Invoke(right.Array); return(RCVectorBase.FromArray(array)); }
public void EvalNetformat(RCRunner runner, RCClosure closure, RCString left, RCBlock right) { RCVectorBase[] columns = new RCVectorBase[right.Count]; for (int i = 0; i < right.Count; ++i) { columns[i] = (RCVectorBase)right.Get(i); if (columns[i].Count != columns[0].Count) { throw new Exception(string.Format( "All columns must have the same count. Expected: {0}, Actual: {1}", columns[0].Count, columns[i].Count)); } } RCArray <object[]> formatParams = new RCArray <object[]> (columns[0].Count); RCArray <string> result = new RCArray <string> (columns[0].Count); for (int i = 0; i < columns[0].Count; ++i) { formatParams.Write(new object[right.Count]); for (int j = 0; j < right.Count; ++j) { formatParams[i][j] = columns[j].Child(i); RCTimeScalar?time = formatParams[i][j] as RCTimeScalar ?; if (time.HasValue) { if (time.Value.Type == RCTimeType.Timespan) { throw new Exception( "netformat does not handle Timespans, please pass a specific date and time."); } formatParams[i][j] = new DateTime(time.Value.Ticks); } } } for (int i = 0; i < formatParams.Count; ++i) { result.Write(string.Format(left[0], formatParams[i])); } runner.Yield(closure, new RCString(result)); }
public static RCVector <L> DoRange <L> (RCVector <long> left, RCVector <L> right) { if (left.Count == 0) { return((RCVector <L>)RCVectorBase.FromArray(new RCArray <L> ())); } else if (left.Count == 1) { RCArray <L> result = new RCArray <L> (); for (int i = (int)left[0]; i < right.Count; ++i) { result.Write(right[i]); } return((RCVector <L>)RCVectorBase.FromArray(new RCArray <L> (result))); } else if (left.Count % 2 == 0) { RCArray <L> result = new RCArray <L> (); int pair = 0; while (pair < left.Count / 2) { int i = (int)left[2 * pair]; int j = (int)left[2 * pair + 1]; while (i <= j) { result.Write(right[i]); ++i; } ++pair; } return((RCVector <L>)RCVectorBase.FromArray(new RCArray <L> (result))); } else { throw new Exception("count of left argument must be 1 or an even number."); } }
public void EvalSort(RCRunner runner, RCClosure closure, RCSymbol left, RCBlock right) { SortDirection direction = ToDir(left); string col = (string)left[0].Part(1); RCVectorBase column = (RCVectorBase)right.Get(col); // It would be nice if there was an easy way to call one operator from another. // I tried to add one but found I would have to create a weird closure for this // purpose. // So I decided to wait and see and live with the switch statement for now. RCLong rank; switch (column.TypeCode) { case 'x': rank = new RCLong(RankUtils.DoRank <byte> (direction, (RCByte)column)); break; case 'l': rank = new RCLong(RankUtils.DoRank <long> (direction, (RCLong)column)); break; case 'd': rank = new RCLong(RankUtils.DoRank <double> (direction, (RCDouble)column)); break; case 'm': rank = new RCLong(RankUtils.DoRank <decimal> (direction, (RCDecimal)column)); break; case 's': rank = new RCLong(RankUtils.DoRank <string> (direction, (RCString)column)); break; case 'b': rank = new RCLong(RankUtils.DoRank <bool> (direction, (RCBoolean)column)); break; case 'y': rank = new RCLong(RankUtils.DoRank <RCSymbolScalar> (direction, (RCSymbol)column)); break; case 't': rank = new RCLong(RankUtils.DoRank <RCTimeScalar> (direction, (RCTime)column)); break; default: throw new Exception("Type:" + column.TypeCode + " is not supported by sort"); } RCBlock result = RCBlock.Empty; for (int i = 0; i < right.Count; ++i) { RCBlock name = right.GetName(i); column = (RCVectorBase)name.Value; RCValue reordered; switch (column.TypeCode) { case 'x': reordered = ReorderColumn <byte> (rank, (RCVector <byte>)column); break; case 'l': reordered = ReorderColumn <long> (rank, (RCVector <long>)column); break; case 'd': reordered = ReorderColumn <double> (rank, (RCVector <double>)column); break; case 'm': reordered = ReorderColumn <decimal> (rank, (RCVector <decimal>)column); break; case 's': reordered = ReorderColumn <string> (rank, (RCVector <string>)column); break; case 'b': reordered = ReorderColumn <bool> (rank, (RCVector <bool>)column); break; case 'y': reordered = ReorderColumn <RCSymbolScalar> (rank, (RCVector <RCSymbolScalar>)column); break; case 't': reordered = ReorderColumn <RCTimeScalar> (rank, (RCVector <RCTimeScalar>)column); break; default: throw new Exception("Type:" + column.TypeCode + " is not supported by sort"); } result = new RCBlock(result, name.Name, ":", reordered); } runner.Yield(closure, result); }
protected void DoTree(TreeNode parent, RCBlock right, ref double a, ref double g) { for (int i = 0; i < right.Count; ++i) { RCBlock current = right.GetName(i); object shortName = current.Name; if (shortName.Equals("")) { shortName = (long)i; } RCSymbolScalar s = new RCSymbolScalar(parent.s, (long)i); RCSymbolScalar n = new RCSymbolScalar(parent.k, shortName); TreeNode node = new TreeNode(s, n); node.v = current.Name; node.children = new RCArray <TreeNode> (); RCVectorBase vector = current.Value as RCVectorBase; if (vector != null) { switch (vector.TypeCode) { case 'l': DoTree <long> (node, (RCVector <long>)vector, ref node.n, ref node.g, Areal, Formatl); break; case 'd': DoTree <double> (node, (RCVector <double>)vector, ref node.n, ref node.g, Aread, Formatd); break; case 'm': DoTree <decimal> (node, (RCVector <decimal>)vector, ref node.n, ref node.g, Aream, Formatm); break; case 's': DoTree <string> (node, (RCVector <string>)vector, ref node.n, ref node.g, Areas, Formats); break; case 'x': DoTree <byte> (node, (RCVector <byte>)vector, ref node.n, ref node.g, Areax, Formatx); break; case 'y': DoTree <RCSymbolScalar> (node, (RCVector <RCSymbolScalar>)vector, ref node.n, ref node.g, Areay, Formaty); break; case 'b': DoTree <bool> (node, (RCVector <bool>)vector, ref node.n, ref node.g, Areab, Formatb); break; default: throw new Exception("Unknown typecode: " + vector.TypeCode); } a += node.n; g += Math.Abs(node.g); parent.children.Write(node); continue; } RCBlock block = current.Value as RCBlock; if (block != null) { DoTree(node, block, ref node.n, ref node.g); a += node.n; g += Math.Abs(node.g); parent.children.Write(node); continue; } RCCube cube = current.Value as RCCube; if (cube != null) { DoTree(node, cube, ref node.n, ref node.g); a += node.n; g += Math.Abs(node.g); parent.children.Write(node); continue; } RCOperator oper = current.Value as RCOperator; if (oper != null) { DoTree(node, oper, ref node.n, ref node.g); a += node.n; g += Math.Abs(node.g); parent.children.Write(node); continue; } RCReference reference = current.Value as RCReference; if (reference != null) { DoTree(node, reference, ref node.n, ref node.g); a += node.n; g += Math.Abs(node.g); parent.children.Write(node); continue; } } }
public void EvalAppend(RCRunner runner, RCClosure closure, RCBlock right) { if (right.Count == 0) { runner.Yield(closure, RCBlock.Empty); } RCValue first = right.Get(0); RCVectorBase vector = first as RCVectorBase; if (vector != null) { RCVectorBase result; switch (vector.TypeCode) { case 'x': result = new RCByte(DoAppend <byte> (right)); break; case 'l': result = new RCLong(DoAppend <long> (right)); break; case 'd': result = new RCDouble(DoAppend <double> (right)); break; case 'm': result = new RCDecimal(DoAppend <decimal> (right)); break; case 's': result = new RCString(DoAppend <string> (right)); break; case 'b': result = new RCBoolean(DoAppend <bool> (right)); break; case 'y': result = new RCSymbol(DoAppend <RCSymbolScalar> (right)); break; case 't': result = new RCTime(DoAppend <RCTimeScalar> (right)); break; default: throw new Exception("Type:" + vector.TypeCode + " is not supported by sort"); } runner.Yield(closure, result); return; } RCCube cube = first as RCCube; if (cube != null) { RCCube result = new RCCube(cube); for (int i = 1; i < right.Count; ++i) { Writer writer = new Writer(result, null, true, true, 0); writer.Write((RCCube)right.Get(i)); } runner.Yield(closure, result); return; } // Individual values are now appended to the result just like the children of // blocks. { RCBlock result = RCBlock.Empty; for (int i = 0; i < right.Count; ++i) { RCBlock top = right.GetName(i); if (top.Value is RCBlock) { RCBlock list = (RCBlock)right.Get(i); for (int j = 0; j < list.Count; ++j) { RCBlock item = list.GetName(j); result = new RCBlock(result, item.Name, ":", item.Value); } } else { result = new RCBlock(result, top.Name, ":", top.Value); } } runner.Yield(closure, result); } }
protected void DoChart(RCCube result, RCSymbolScalar parent, ref long row, long col, RCBlock right) { for (int i = 0; i < right.Count; ++i) { RCBlock current = right.GetName(i); object shortName = current.Name; if (shortName.Equals("")) { shortName = (long)i; } RCSymbolScalar name = new RCSymbolScalar(parent, shortName); RCSymbolScalar cell = RCSymbolScalar.From(row, col, 0L); result.WriteCell("r", cell, row); result.WriteCell("c", cell, col); result.WriteCell("l", cell, 0L); result.WriteCell("k", cell, name); result.WriteCell("v", cell, shortName is long?shortName.ToString() : shortName); result.Axis.Write(cell); RCVectorBase vector = current.Value as RCVectorBase; if (vector != null) { ++col; switch (vector.TypeCode) { case 'l': DoChart <long> (result, name, row, col, (RCVector <long>)vector); break; case 'd': DoChart <double> (result, name, row, col, (RCVector <double>)vector); break; case 'm': DoChart <decimal> (result, name, row, col, (RCVector <decimal>)vector); break; case 's': DoChart <string> (result, name, row, col, (RCVector <string>)vector); break; case 'x': DoChart <byte> (result, name, row, col, (RCVector <byte>)vector); break; case 'y': DoChart <RCSymbolScalar> (result, name, row, col, (RCVector <RCSymbolScalar>)vector); break; case 'b': DoChart <bool> (result, name, row, col, (RCVector <bool>)vector); break; default: throw new Exception("Unknown typecode: " + vector.TypeCode); } --col; ++row; continue; } RCBlock block = current.Value as RCBlock; if (block != null) { ++col; ++row; DoChart(result, name, ref row, col, block); --col; continue; } RCOperator oper = current.Value as RCOperator; if (oper != null) { ++col; string val = oper.ToString(); cell = RCSymbolScalar.From(row, col, 0L); result.WriteCell("r", cell, (long)row); result.WriteCell("c", cell, (long)col); result.WriteCell("l", cell, 0L); result.WriteCell("k", cell, new RCSymbolScalar(name, 0L)); result.WriteCell("v", cell, val); result.Write(cell); ++row; --col; continue; } RCReference reference = current.Value as RCReference; if (reference != null) { ++col; string val = reference.ToString(); cell = RCSymbolScalar.From(row, col, 0L); result.WriteCell("r", cell, (long)row); result.WriteCell("c", cell, (long)col); result.WriteCell("l", cell, 0L); result.WriteCell("k", cell, new RCSymbolScalar(name, 0L)); result.WriteCell("v", cell, val); result.Write(cell); ++row; --col; continue; } RCCube cube = current.Value as RCCube; if (cube != null) { ++col; ++row; DoChart(result, name, ref row, col, cube); ++row; --col; continue; } } }