public void CloneTest() { Gates.IC nor = CreateNor(); Gates.IC nor2 = (Gates.IC)nor.Clone(); nor2.Circuit.Start(); nor[0] = false; nor2[0] = false; Gates.PropagationThread.Instance.WaitOnPropagation(); //Gates.PropagationThread.Instance.WaitOnPropagation(); Assert.AreEqual(true, nor.Output[0]); Assert.AreEqual(true, nor2.Output[0]); nor[0] = true; Gates.PropagationThread.Instance.WaitOnPropagation(); //nor2.WaitOnPropagation(); Assert.AreEqual(false, nor.Output[0]); Assert.AreEqual(true, nor2.Output[0]); nor2[0] = true; Gates.PropagationThread.Instance.WaitOnPropagation(); //nor2.WaitOnPropagation(); Assert.AreEqual(false, nor.Output[0]); Assert.AreEqual(false, nor2.Output[0]); nor[0] = false; Gates.PropagationThread.Instance.WaitOnPropagation(); //nor2.WaitOnPropagation(); Assert.AreEqual(true, nor.Output[0]); Assert.AreEqual(false, nor2.Output[0]); }
public void Nor() { Gates.IC nor = CreateNor(); nor[0] = false; nor[1] = true; Gates.PropagationThread.Instance.WaitOnPropagation(); Assert.AreEqual(false, nor.Output[0]); nor[0] = true; nor[1] = false; Gates.PropagationThread.Instance.WaitOnPropagation(); Assert.AreEqual(false, nor.Output[0]); nor[0] = false; nor[1] = false; Gates.PropagationThread.Instance.WaitOnPropagation(); Assert.AreEqual(true, nor.Output[0]); nor[0] = true; nor[1] = true; Gates.PropagationThread.Instance.WaitOnPropagation(); Assert.AreEqual(false, nor.Output[0]); }
private Gates.IC CreateAndChain(int len) { Gates.Circuit andc = new Gates.Circuit(); andc.Start(); Gates.IOGates.UserInput in1 = new Gates.IOGates.UserInput(); andc.Add(in1); Gates.IOGates.UserOutput out1 = new Gates.IOGates.UserOutput(); andc.Add(out1); if (len > 1) { Gates.IC cand1 = CreateAndChain(len / 2); Gates.IC cand2 = CreateAndChain(len / 2); andc.Add(cand1); andc.Add(cand2); andc[new Gates.Terminal(0, cand1)] = new Gates.Terminal(0, in1); andc[new Gates.Terminal(0, cand2)] = new Gates.Terminal(0, cand1); andc[new Gates.Terminal(0, out1)] = new Gates.Terminal(0, cand2); } else { Gates.BasicGates.And mand = new Gates.BasicGates.And(); andc.Add(mand); andc[new Gates.Terminal(0, mand)] = new Gates.Terminal(0, in1); andc[new Gates.Terminal(1, mand)] = new Gates.Terminal(0, in1); andc[new Gates.Terminal(0, out1)] = new Gates.Terminal(0, mand); } return(new Gates.IC(andc, new Gates.IOGates.UserInput[] { in1 }, new Gates.IOGates.UserOutput[] { out1 }, "AndChain")); }
Gates.IC CreateSRLatch() { Gates.Circuit sr = new Gates.Circuit(); sr.Start(); Gates.IC nor1 = CreateNor(); Gates.IC nor2 = CreateNor(); Gates.IOGates.UserInput in1 = new Gates.IOGates.UserInput(); Gates.IOGates.UserInput in2 = new Gates.IOGates.UserInput(); Gates.IOGates.UserOutput out1 = new Gates.IOGates.UserOutput(); Gates.IOGates.UserOutput out2 = new Gates.IOGates.UserOutput(); sr.Add(nor1); sr.Add(nor2); sr.Add(in1); sr.Add(in2); sr.Add(out1); sr.Add(out2); sr[new Gates.Terminal(0, nor1)] = new Gates.Terminal(0, in1); sr[new Gates.Terminal(1, nor2)] = new Gates.Terminal(0, in2); sr[new Gates.Terminal(1, nor1)] = new Gates.Terminal(0, nor2); sr[new Gates.Terminal(0, nor2)] = new Gates.Terminal(0, nor1); sr[new Gates.Terminal(0, out1)] = new Gates.Terminal(0, nor1); sr[new Gates.Terminal(0, out2)] = new Gates.Terminal(0, nor2); return(new Gates.IC(sr, new Gates.IOGates.UserInput[] { in1, in2 }, new Gates.IOGates.UserOutput[] { out1, out2 }, "SRLatch")); }
public void NorInCiruit() { Gates.IC nor = CreateNor(); Gates.Circuit c = new Gates.Circuit(); c.Start(); c.Add(nor); // primarily just tests that c's wait // also makes the nor wait nor[0] = false; nor[1] = true; Gates.PropagationThread.Instance.WaitOnPropagation(); Assert.AreEqual(false, nor.Output[0]); nor[0] = true; nor[1] = false; Gates.PropagationThread.Instance.WaitOnPropagation(); Assert.AreEqual(false, nor.Output[0]); nor[0] = false; nor[1] = false; Gates.PropagationThread.Instance.WaitOnPropagation(); Assert.AreEqual(true, nor.Output[0]); nor[0] = true; nor[1] = true; Gates.PropagationThread.Instance.WaitOnPropagation(); Assert.AreEqual(false, nor.Output[0]); }
/// <summary> /// Clone the IC with terminals and location hinting. The IC may optionally /// be renamed in this cloning process. /// </summary> /// <param name="name"></param> /// <returns></returns> public IC CreateUserInstance(string name) { Gates.IC nic = (Gates.IC)((Gates.IC)_gate).Clone(name); // duplicate the term ids because they have individual // refernece to actual terminal IC nuic = new IC(nic, CloneTerminals()); DuplicateLocationHinting(nuic); return(nuic); }
public IC(Gates.IC gate, TerminalID[] termsid) : base(gate, termsid) { locationHints = new Dictionary <Gates.AbstractGate, GateLocation>(); // may need to length the gate symbol // to accomodate the label // load the terminal tooltips foreach (TerminalID tid in _termsid) { Gates.AbstractGate ab; if (tid.isInput) { ab = gate.Inputs[tid.ID]; } else { ab = gate.Outputs[tid.ID]; } tid.t.ToolTip = ab.Name; } r = new Rectangle(); r.Margin = new System.Windows.Thickness(12, 17, 12, 17); r.Width = this.Width - 24; r.Height = this.Height - 34; r.Stroke = Brushes.Black; r.StrokeThickness = 2; r.Fill = Brushes.White; myCanvas.Children.Add(r); nm = new TextBox(); nm.Text = gate.Name; nm.HorizontalAlignment = System.Windows.HorizontalAlignment.Center; nm.VerticalAlignment = System.Windows.VerticalAlignment.Center; nm.TextAlignment = TextAlignment.Center; nm.Margin = new System.Windows.Thickness(20, this.Height / 2 - 12, 20, this.Height / 2 - 12); nm.Width = this.Width - 40; nm.Height = 24; nm.BorderThickness = new Thickness(0); IsReadOnly = true; myCanvas.Children.Add(nm); nm.LostFocus += new RoutedEventHandler(nm_LostFocus); nm.KeyDown += new System.Windows.Input.KeyEventHandler(nm_KeyDown); ResizeDueToName(); }
private void Visit(Gates.IC ic) { if (!visited.Contains(ic.Name)) { visited.Add(ic.Name); foreach (Gates.AbstractGate ag in ic.Circuit) { if (ag is Gates.IC) { Visit((Gates.IC)ag); } } results.Add(ic); } }
/// <summary> /// Create an IC, but ignore user input and output. This is useful if /// the IC is just a package for some other operation. /// </summary> /// <param name="name"></param> /// <returns></returns> public UIGates.IC CreateNonTerminaledIC(string name) { Gates.IC nic = new Gates.IC(c, new Gates.IOGates.UserInput[0], new Gates.IOGates.UserOutput[0], name); UIGates.IC nuic = new UIGates.IC(nic, new Gate.TerminalID[0]); // finally, hint the IC so that we can remember // where things are placed visually in the future foreach (Gates.AbstractGate g in c) { nuic.locationHints.Add(g, pos(g)); } return((UIGates.IC)nuic.CreateUserInstance()); }
public void PropagationTest() { // this test checks for the accuracy // of wait for propagation // by determining if it fully waits for all propagation // to occur through the contained sub-circuits // this came from a problem where all sub-circuits // were instructed to wait BUT // the loop didn't repeat this based on that // so one could pass off an incomplete result // to another and the waiting could end before // it was all really done Gates.Circuit c = new Gates.Circuit(); c.Start(); // EXTREMELY SPECIFIC // The long chain appears FIRST in the circuit add list // But the input connects to the short chain first // Then the wait waits on the long chain, which has nothing // then briefly on the short chain, which passes a change // to the long chain... // but it DOESN'T wait for the long chain to finish // (because it already waited on the long chain before it had any work!) Gates.IC ac1 = CreateAndChain(64); Gates.IC ac2 = CreateAndChain(10); Gates.IOGates.UserInput ui = new Gates.IOGates.UserInput(); Gates.BasicGates.And mand = new Gates.BasicGates.And(); c.Add(ac1); c.Add(ac2); c.Add(ui); c.Add(mand); c[new Gates.Terminal(0, ac2)] = new Gates.Terminal(0, ui); c[new Gates.Terminal(0, ac1)] = new Gates.Terminal(0, ac2); c[new Gates.Terminal(0, mand)] = new Gates.Terminal(0, ac1); c[new Gates.Terminal(1, mand)] = new Gates.Terminal(0, ac2); ui.Value = false; Gates.PropagationThread.Instance.WaitOnPropagation(); Assert.AreEqual(false, mand.Output[0]); ui.Value = true; Gates.PropagationThread.Instance.WaitOnPropagation(); Assert.AreEqual(true, mand.Output[0]); }
public void SRLatch() { Gates.Circuit c = new Gates.Circuit(); c.Start(); Gates.IOGates.UserInput ui_r = new Gates.IOGates.UserInput(); Gates.IOGates.UserInput ui_s = new Gates.IOGates.UserInput(); Gates.IOGates.UserOutput uo = new Gates.IOGates.UserOutput(); Gates.IC latch = CreateSRLatch(); c.Add(ui_r); c.Add(ui_s); c.Add(uo); c.Add(latch); c[new Gates.Terminal(0, latch)] = new Gates.Terminal(0, ui_r); c[new Gates.Terminal(1, latch)] = new Gates.Terminal(0, ui_s); c[new Gates.Terminal(0, uo)] = new Gates.Terminal(0, latch); for (int i = 0; i < 4; i++) { // SET ui_r.Value = false; ui_s.Value = true; Gates.PropagationThread.Instance.WaitOnPropagation(); Assert.AreEqual(true, uo.Value); // HOLD ui_r.Value = false; ui_s.Value = false; Gates.PropagationThread.Instance.WaitOnPropagation(); Assert.AreEqual(true, uo.Value); // RESET ui_r.Value = true; ui_s.Value = false; Gates.PropagationThread.Instance.WaitOnPropagation(); Assert.AreEqual(false, uo.Value); // HOLD ui_r.Value = false; ui_s.Value = false; Gates.PropagationThread.Instance.WaitOnPropagation(); Assert.AreEqual(false, uo.Value); } }
public UIGates.IC CreateIC(string name) { posGates = new List<GTerm>(); List<Gates.IOGates.UserInput> uis = new List<Gates.IOGates.UserInput>(); List<Gates.IOGates.UserOutput> uos = new List<Gates.IOGates.UserOutput>(); // Determine the center-point of the X bool fst = true; double maxX = 0, maxY = 0, minX = 0, minY = 0; foreach (Gates.AbstractGate g in c) { Point p = pos(g).GetPoint(); if (fst) { maxX = p.X; minX = p.X; maxY = p.Y; minY = p.Y; fst = false; } maxX = Math.Max(maxX, p.X); maxY = Math.Max(maxY, p.Y); minX = Math.Min(minX, p.X); minY = Math.Min(minY, p.Y); //avgX += p.X; //avgY += p.Y; } //avgX /= c.Count; //avgY /= c.Count; avgX = (maxX + minX) / 2.0; avgY = (maxY + minY) / 2.0; // For all user i/o gates, determine where they fall in the X foreach (Gates.AbstractGate g in c) { if (g is Gates.IOGates.UserInput) { uis.Add((Gates.IOGates.UserInput)g); PositionAndHold(g); } if (g is Gates.IOGates.UserOutput) { uos.Add((Gates.IOGates.UserOutput)g); PositionAndHold(g); } } // Apply a sort to order user i/o gates with respect // to the standard ordering that the IC uses to display its terminals // see Gate class posGates.Sort((firstVal, nextVal) => { if (firstVal.pos != nextVal.pos) return firstVal.pos.CompareTo(nextVal.pos); else return firstVal.offset.CompareTo(nextVal.offset); }); Gates.IC nic = new Gates.IC(c, uis.ToArray(), uos.ToArray(), name); List<Gate.TerminalID> tids = new List<Gate.TerminalID>(); // constuct the terminal id list based on the sorted sequence foreach (GTerm gt in posGates) { tids.Add(new Gate.TerminalID(gt.gate is Gates.IOGates.UserInput, gt.gate is Gates.IOGates.UserInput ? uis.IndexOf((Gates.IOGates.UserInput)gt.gate) : uos.IndexOf((Gates.IOGates.UserOutput)gt.gate), gt.pos)); } UIGates.IC nuic = new UIGates.IC(nic, tids.ToArray()); // finally, hint the IC so that we can remember // where things are placed visually in the future foreach (Gates.AbstractGate g in c) { nuic.locationHints.Add(g, pos(g)); } // in some cases, the caller may be using these gates // so we create a clone so there is no interference return (UIGates.IC)nuic.CreateUserInstance(); }
/// <summary> /// Create an IC, but ignore user input and output. This is useful if /// the IC is just a package for some other operation. /// </summary> /// <param name="name"></param> /// <returns></returns> public UIGates.IC CreateNonTerminaledIC(string name) { Gates.IC nic = new Gates.IC(c, new Gates.IOGates.UserInput[0], new Gates.IOGates.UserOutput[0], name); UIGates.IC nuic = new UIGates.IC(nic, new Gate.TerminalID[0]); // finally, hint the IC so that we can remember // where things are placed visually in the future foreach (Gates.AbstractGate g in c) { nuic.locationHints.Add(g, pos(g)); } return (UIGates.IC)nuic.CreateUserInstance(); }
/// <summary> /// Create an IC based on the circuit. All user input and outputs /// will be turned into terminals on this IC. The technique is to establish /// a center-point of the gates involved, and establish a "X" shape originating /// from this center. The position of the user i/o gates within this X shape /// determine how they appear on the IC. The goal is to have the layout of /// terminals match the layout and ordering of user inputs and outputs. /// </summary> /// <param name="name"></param> /// <returns></returns> public UIGates.IC CreateIC(string name) { posGates = new List <GTerm>(); List <Gates.IOGates.UserInput> uis = new List <Gates.IOGates.UserInput>(); List <Gates.IOGates.UserOutput> uos = new List <Gates.IOGates.UserOutput>(); // Determine the center-point of the X double maxX = 0, maxY = 0, minX = 0, minY = 0; var pts = createCenter(); maxX = pts.Right; minX = pts.Left; maxY = pts.Bottom; minY = pts.Top; avgX = (maxX + minX) / 2.0; avgY = (maxY + minY) / 2.0; // For all user i/o gates, determine where they fall in the X foreach (Gates.AbstractGate g in c) { if (g is Gates.IOGates.UserInput) { uis.Add((Gates.IOGates.UserInput)g); PositionAndHold(g); } if (g is Gates.IOGates.UserOutput) { uos.Add((Gates.IOGates.UserOutput)g); PositionAndHold(g); } } // Apply a sort to order user i/o gates with respect // to the standard ordering that the IC uses to display its terminals // see Gate class posGates.Sort((firstVal, nextVal) => { if (firstVal.pos != nextVal.pos) { return(firstVal.pos.CompareTo(nextVal.pos)); } else { return(firstVal.offset.CompareTo(nextVal.offset)); } }); Gates.IC nic = new Gates.IC(c, uis.ToArray(), uos.ToArray(), name); List <Gate.TerminalID> tids = new List <Gate.TerminalID>(); // constuct the terminal id list based on the sorted sequence foreach (GTerm gt in posGates) { tids.Add(new Gate.TerminalID(gt.gate is Gates.IOGates.UserInput, gt.gate is Gates.IOGates.UserInput ? uis.IndexOf((Gates.IOGates.UserInput)gt.gate) : uos.IndexOf((Gates.IOGates.UserOutput)gt.gate), gt.pos)); } UIGates.IC nuic = new UIGates.IC(nic, tids.ToArray()); // finally, hint the IC so that we can remember // where things are placed visually in the future foreach (Gates.AbstractGate g in c) { nuic.locationHints.Add(g, pos(g)); } // in some cases, the caller may be using these gates // so we create a clone so there is no interference return((UIGates.IC)nuic.CreateUserInstance()); }
/// <summary> /// The "template" here is used as a visual template, that is, a descriptor of /// how the terminals should be laid out and a provided of location hints. /// The IC becomes the actual circuit within the return value. /// Accordingly, it is assumed that the template will be of the same /// "type" as the IC. /// </summary> /// <param name="ic"></param> /// <param name="template"></param> /// <returns></returns> public static IC CreateFromTemplate(Gates.IC ic, IC template) { UIGates.IC nuic = new UIGates.IC(ic, template.CloneTerminals()); template.DuplicateLocationHinting(nuic); return(nuic); }