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