private bool IsZeroMatrix(Tree.Node node, Context context) { bool ret = true; context.Push(node); foreach (var child in node.Children) { if (context.IsMapping(child)) { ret = false; break; } if (child.Instruction is InstructionMatrix) { if (!IsZeroMatrix(child, context)) { ret = false; break; } } var num = child.Instruction as InstructionNumber; if (num == null || num.Value != 0) { ret = false; break; } } context.Pop(); return(ret); }
static void Main(string[] args) { Tree tree = new Tree(); StreamReader f = new StreamReader("in.txt"); StreamWriter vi = new StreamWriter("out.txt"); int kor = Convert.ToInt32(f.ReadLine()); Tree.Node root = new Tree.Node(kor); while (!f.EndOfStream) { int s = Convert.ToInt32(f.ReadLine()); tree.MainInsert(root, s); } root = tree.height(root); Tree.Node root1 = root; //root = tree.Delet_Ver(root, num_del); int num_del = tree.MSL(root, root1); root = tree.Delet_Ver(root, num_del); //tree.wr(); tree.OutFile(root, vi); vi.Close(); //Console.WriteLine(root.left.father.key); }
public TreeBuilder AddNode(Tree.Node node) { tree._nodes.Push(node); SetNameObserver(node.name); tree.nodeWasCreated = true; return(this); }
internal Tree.Node GetNodeNumber(int nodeToMutate, ref int currentNodeNum) { if (currentNodeNum == nodeToMutate) { return(this); } else if (currentNodeNum > nodeToMutate) { throw new ApplicationException(); } else { currentNodeNum++; if (this is Tree.FuncNode) { FuncNode thisNode = this as FuncNode; foreach (Node n in thisNode.Children) { Tree.Node posNode = n.GetNodeNumber(nodeToMutate, ref currentNodeNum); if (posNode != null) { return(posNode); } } } } return(null); }
protected string Sparsify(string val, Tree.Node node) { var isp = node.Instruction as Instructions.SparseOperator; if (isp == null) { return(val); } var args = Array.ConvertAll(isp.ArgSparsity, (a) => { return(String.Format("({0}-by-{1}) ({2})", a.Dimension.Rows, a.Dimension.Columns, String.Join("|", Array.ConvertAll(a.Sparsity, (b) => b.ToString())))); }); var id = String.Format("{0} SP {1}", val, String.Join(", ", args)); string ret; if (!s_sparseFunctionNames.TryGetValue(id, out ret)) { ret = val + "_sp_" + s_sparseFunctionNames.Count; s_sparseFunctionNames[id] = ret; } return(ret); }
/// <summary> /// Finds the width of each level of the specified tree. /// </summary> /// <param name="tree">Tree to find width of levels.</param> /// <returns>Width of levels in the tree.</returns> public int[] Find(Tree tree) { if (tree == null) { throw new ArgumentNullException(nameof(tree), "tree cannot be null"); } if (tree.Root == null) { return(new int[] { 0 }); } List <int> results = new List <int>(); List <Tree.Node> toVisit = new List <Tree.Node>(); toVisit.Add(tree.Root); while (toVisit.Count > 0) { int levelCount = toVisit.Count; for (int i = 0; i < levelCount; i++) { Tree.Node node = toVisit[0]; toVisit.RemoveAt(0); toVisit.AddRange(node.Children); } results.Add(levelCount); } return(results.ToArray()); }
static void Main(string[] args) { Tree tree = new Tree(); StreamReader f = new StreamReader("input.txt"); //StreamReader prov = new StreamReader("input.txt"); StreamWriter vi = new StreamWriter("output.txt"); int num_del = Convert.ToInt32(f.ReadLine()); f.ReadLine(); //prov.ReadLine(); //prov.ReadLine(); //if (prov.ReadLine() == null) //{ // if (prov.ReadLine() == null) // { // Environment.Exit(0); // } //} int kor = Convert.ToInt32(f.ReadLine()); Tree.Node root = new Tree.Node(kor); while (!f.EndOfStream) { int s = Convert.ToInt32(f.ReadLine()); tree.MainInsert(root, s); } root = tree.Delet_Ver(root, num_del); //tree.wr(); tree.OutFile(root, vi); vi.Close(); //Console.WriteLine(root.left.father.key); }
public InitializeDelayHistory(DelayedState state, DataTable history, Tree.Node equation, IEnumerable <INode> deps, bool ontime) { d_state = state; d_history = history; d_deps = new List <INode>(deps); d_equation = equation; d_ontime = ontime; }
public string Translate(Context context, Tree.Node child) { string ret; context.Push(child); ret = Translate(context); context.Pop(); return(ret); }
public Context Pop() { d_stack.Pop(); if (d_stack.Count == 0) { d_root = null; } return(this); }
private int LiteralIndex(Tree.Node node) { var i = node.Instruction as InstructionNumber; if (i == null) { throw new Exception("Non constant indices are not yet supported"); } return((int)(i.Value + 0.5)); }
protected virtual string Translate(Computation.Loop node, Context context) { StringBuilder ret = new StringBuilder(); Context ctx = context.Clone(context.Program, context.Options, node.Expression, node.Mapping); ret.AppendFormat("for ({0} = 0; i < {1}; ++i)", context.DeclareValueVariable("int", "i"), node.Items.Count); ret.AppendLine(); ret.AppendLine("{"); if (Cdn.RawC.Options.Instance.Verbose) { var dt = (node.IndexTable[0].Object as Computation.Loop.Index).DataItem; ret.AppendFormat("\t{0} {1}[{2}] = {3}({4}", context.BeginComment, context.This(context.Program.StateTable), dt.AliasOrIndex.Replace(context.BeginComment, "//").Replace(context.EndComment, "//"), context.ThisCall(node.Function.Name), context.This(context.Program.StateTable)); var eq = node.Items[0].Equation; foreach (Tree.Embedding.Argument arg in node.Function.OrderedArguments) { Tree.Node subnode = eq.FromPath(arg.Path); DataTable.DataItem it = context.Program.StateTable[subnode]; ret.AppendFormat(", {0}[{1}]", context.This(context.Program.StateTable), it.AliasOrIndex.Replace(context.BeginComment, "//").Replace(context.EndComment, "//")); } ret.Append("); "); ret.Append(context.EndComment); ret.AppendLine(); } ret.AppendLine(Context.Reindent(TranslateAssignment(String.Format("{0}[i][0]", context.This(node.IndexTable)), ctx), "\t")); ret.Append("}"); return(ret.ToString()); }
public Loop(Program program, DataTable indextable, Tree.Embedding embedding, Function function) { d_function = function; d_embedding = embedding; d_items = new List <Item>(); d_indextable = indextable; d_program = program; // Create expression d_expression = (Tree.Node)d_embedding.Expression.Clone(); d_expression.Instruction = new Instructions.Function(d_function); // Generate mapping d_mapping = new Dictionary <Tree.NodePath, object>(); }
private string TranslateAssign(Context context, Tree.Node node, string assignto) { if (node.Dimension.IsOne) { return(String.Format("({0})[0] = {1}", assignto, Translate(context, node))); } else { context.PushRet(assignto); var ret = Translate(context, node); context.PopRet(); return(ret); } }
private Node <T> DeleteN(Node <T> root, Node <T> deleteNode) { if (root == null) { return(root); } var comparerRes = Comparer <T> .Default.Compare(deleteNode.data, root.data); if (comparerRes < 0) { root.left = DeleteN(root.left, deleteNode); } else if (comparerRes > 0) { root.right = DeleteN(root.right, deleteNode); } else { //No child nodes if (root.left == null && root.right == null) { root = null; return(root); } //No left child else if (root.left == null) { Node <T> temp = root; root = root.right; temp = null; } //No right child else if (root.right == null) { Node <T> temp = root; root = root.left; temp = null; } //Has both child nodes else { Node <T> min = FindMin(root.right); root.data = min.data; root.right = DeleteN(root.right, min); } } return(root); }
public Context Push(State state, Tree.Node node) { if (node == null) { return(this); } d_stack.Push(new Item(state, node)); if (d_root == null) { d_root = node; } return(this); }
public static int SumTree(Tree tree) { switch (tree.Tag) { case Tree.TagValue.Leaf: return(0); case Tree.TagValue.Node: Tree.Node node = tree.GetAsNode(); return(node.Value + SumTree(node.Left) + SumTree(node.Right)); default: Debug.Assert(false, "Unhandled alternative in switch over 'Tree'"); return(0); } }
static void Main(string[] args) { Tree tree = new Tree(); StreamReader f = new StreamReader("input.txt"); StreamWriter vi = new StreamWriter("output.txt"); int k = Convert.ToInt32(f.ReadLine()); Tree.Node root = new Tree.Node(k); while (!f.EndOfStream) { int s = Convert.ToInt32(f.ReadLine()); tree.MainInsert(root, s); } //tree.wr(); tree.OutFile(root, vi); vi.Close(); }
public void Add(DataTable.DataItem target, Tree.Node equation) { d_items.Add(new Item(target, equation)); // Add row to index table d_indextable.Add(new Index((ulong)target.DataIndex, target)); d_indextable.IntegerTypeSize = (ulong)target.DataIndex; foreach (Tree.Embedding.Argument arg in d_function.OrderedArguments) { Tree.Node subnode = equation.FromPath(arg.Path); DataTable.DataItem it = d_program.StateTable[subnode]; d_indextable.Add(new Index((ulong)it.DataIndex, it)).Type = (it.Type | DataTable.DataItem.Flags.Index); d_indextable.IntegerTypeSize = (ulong)it.DataIndex; } }
public virtual bool TryMapping(Tree.Node node, out string ret) { Tree.NodePath path = node.RelPath(d_root); object o; if (d_mapping.TryGetValue(path, out o)) { var li = o as Computation.Loop.Mapped; if (li != null) { var t = This(d_program.StateTable); var i = This(li.IndexTable); if (li.Node.Dimension.IsOne) { ret = String.Format("{0}[{1}[i][{2}]]", t, i, li.Index); } else if (SupportsPointers) { ret = String.Format("({0} + {1}[i][{2}])", t, i, li.Index); } else { throw new Exception("Loop substitutes requiring pointers are not supported yet in this format."); } } else { ret = o.ToString(); } return(true); } else { ret = ""; return(false); } }
private bool NodeIsOne(Tree.Node node) { if (!node.Dimension.IsOne) { return(false); } else { foreach (var child in node.Children) { if (!child.Dimension.IsOne) { return(false); } } } return(true); }
public string AcquireTemporary(Tree.Node node) { int size = node.Dimension.Size(); /* This code would reuse temporaries which are no * longer needed, however this doesn't work for * function arguments which were assumed to be * evaluated in order (C doesn't guarantee this) */ /*for (int i = 0; i < d_tempstorage.Count; ++i) * { * var tmp = d_tempstorage[i]; * * if (tmp.Node != null) * { * continue; * } * * if (tmp.Size < size) * { * continue; * } * * tmp.Node = node; * * d_tempactive[node] = i; * d_tempstack.Peek().Add(tmp); * * return String.Format("tmp{0}", i); * }*/ var tmpstack = d_tempstack.Peek(); var idx = tmpstack.Count; var newtmp = new Temporary { Node = node, Size = size, Name = String.Format("tmp{0}", idx), }; tmpstack.Add(newtmp); return(newtmp.Name); }
/* This method translates a child and makes sure to allocate temporary * memory for it if necessary. */ private string TranslateChildV(Tree.Node child, Context context) { string ret; if (child.Dimension.IsOne || InstructionHasStorage(child.Instruction, context)) { context.PushRet(null); ret = Translate(context, child); context.PopRet(); } else { context.PushRet(context.AcquireTemporary(child)); ret = Translate(context, child); context.PopRet(); } return(ret); }
public Node <T> Insert(Node <T> root, T value) { if (root == null) { Node <T> node = new Node <T>(value); root = node; return(root); } var comparerRes = Comparer <T> .Default.Compare(root.data, value); if (comparerRes > 0) { root.left = Insert(root.left, value); } else if (comparerRes < 0) { root.right = Insert(root.right, value); } return(root); }
public Function(string name, Tree.Node expression, IEnumerable <Tree.Embedding.Argument> arguments) { d_expression = expression; d_arguments = new List <Tree.Embedding.Argument>(arguments); d_name = name; d_orderedArguments = new List <Tree.Embedding.Argument>(); foreach (Tree.Embedding.Argument arg in d_arguments) { while (arg.Index >= d_orderedArguments.Count) { d_orderedArguments.Add(null); } if (d_orderedArguments[(int)arg.Index] == null) { d_orderedArguments[(int)arg.Index] = arg; } } }
public virtual string MathFunction(Tree.Node node) { Cdn.InstructionFunction instruction = (Cdn.InstructionFunction)node.Instruction; var smanip = instruction.GetStackManipulation(); var type = (Cdn.MathFunctionType)instruction.Id; if (!smanip.Push.Dimension.IsOne) { return(MathFunctionV(type, node)); } for (int i = 0; i < node.Children.Count; ++i) { if (!node.Children[i].Dimension.IsOne) { return(MathFunctionV(type, node)); } } return(MathFunction(type, (int)smanip.Pop.Num)); }
static void Main(string[] args) { Tree tree = new Tree(); tree.addArrayIndex(new int[3] { 70, 84, 85 }); tree.addArrayIndex(new int[4] { 70, 84, 78, 80 }); tree.addArrayIndex(new int[4] { 70, 84, 78, 76 }); tree.addArrayIndex(new int[4] { 70, 49, 54, 51 }); tree.addArrayIndex(new int[4] { 70, 84, 37, 40 }); tree.addArrayIndex(new int[4] { 70, 49, 37, 22 }); tree.ShowTreeNode(tree.root); System.Console.ReadKey(); Tree.Node n = tree.Ancestor(40, 78); System.Console.WriteLine("Ancestro: " + n.index); n = tree.Ancestor(51, 37); System.Console.WriteLine("Ancestro: " + n.index); n = tree.Ancestor(76, 85); System.Console.WriteLine("Ancestro: " + n.index); System.Console.ReadKey(); }
public Context(Program program, Options options, Tree.Node node, Dictionary <Tree.NodePath, object> mapping) { d_program = program; d_options = options; d_stack = new Stack <Item>(); Push(node); if (mapping != null) { d_mapping = mapping; } else { d_mapping = new Dictionary <Tree.NodePath, object>(); } d_tempstack = new Stack <List <Temporary> >(); d_ret = new Stack <string>(); d_tempstack.Push(new List <Temporary>()); }
public override bool TryMapping(Tree.Node node, out string ret) { Tree.NodePath path = node.RelPath(Root); object o; if (Mapping.TryGetValue(path, out o)) { var li = o as Computation.Loop.Mapped; if (li != null && !li.Node.Dimension.IsOne) { ret = String.Format("Cdn.Utils.array_slice({0}, {1}[i][{2}], {1}[i][{2}] + {3})", This(Program.StateTable), This(li.IndexTable), li.Index, li.Node.Dimension.Size()); return(true); } } return(base.TryMapping(node, out ret)); }
private void openFile(object sender, EventArgs e) { if (openFileDialog.ShowDialog() != DialogResult.OK) return; currentFileName = openFileDialog.FileName; root = Tree.XmlTree.Load(currentFileName); //right side of the box foreach (Tree.Node<Tree.Record> someNode in Tree.Tree.Traverse(root)) preorderListBox.Items.Add(someNode.Data.ToString()); //left side of the box TreeNode parentNode = new TreeNode(root.Data.ToString()); treeView.Nodes.Add(parentNode); int tempind = 0; foreach (Tree.Node<Tree.Record> child in root.Children) { parentNode.Nodes.Add(child.Data.ToString()); generateTreeView(child, parentNode.Nodes[tempind++]); } treeView.Invalidate(); //draw tree }
private void LiteralIndices(Tree.Node node, List <int> ret) { var i = node.Instruction as InstructionNumber; if (i != null) { ret.Add((int)(i.Value + 0.5)); return; } var m = node.Instruction as InstructionMatrix; if (m != null) { foreach (var child in node.Children) { LiteralIndices(child, ret); } } else { throw new Exception("Non constant indices are not yet supported"); } }