private void ReportFunctions(LogicalCircuit root) { try { CircuitMap map = new CircuitMap(root); CircuitState state = map.Apply(1); Dictionary <string, int> func = new Dictionary <string, int>(); foreach (CircuitFunction f in state.Functions) { string name = f.ReportName; if (func.ContainsKey(name)) { func[name]++; } else { func.Add(name, 1); } } this.Functions = new List <string>(func.Keys); this.Functions.Sort(StringComparer.Ordinal); this.Usage = func; } catch (Exception exception) { this.BuildMapException = exception; } }
public Parameter AddParameter(Result result, CircuitMap circuitMap, Jam jam, int bitNumber) { Tracer.Assert(CircuitMap.IsPrimitive(jam.CircuitSymbol.Circuit)); SymbolMap map = this.AddSymbol(circuitMap, (CircuitSymbol)jam.CircuitSymbol); return(map.AddParameter(result, circuitMap, jam, bitNumber)); }
private void RunningMapDoubleClick(object sender, MouseButtonEventArgs e) { try { if (this.Editor != null && this.Editor.Power && e.ChangedButton == MouseButton.Left) { TreeView treeView = sender as TreeView; if (treeView != null && treeView.SelectedItem != null) { CircuitMap map = treeView.SelectedItem as CircuitMap; if (map != null) { this.Editor.OpenLogicalCircuit(map); TreeViewItem item = this.Container(treeView, map); if (item != null) { item.IsExpanded = true; } e.Handled = true; } } } } catch (Exception exception) { Tracer.Report("MainFrame.RunningMapDoubleClick", exception); this.ReportException(exception); } }
public Result AddResult(CircuitMap circuitMap, Jam jam, int bitNumber) { Tracer.Assert(CircuitMap.IsPrimitive(jam.CircuitSymbol.Circuit)); SymbolMap map = this.AddSymbol(circuitMap, (CircuitSymbol)jam.CircuitSymbol); return(map.AddResult(circuitMap, jam, bitNumber)); }
public Parameter AddParameter(Result result, CircuitMap circuitMap, Jam jam, int bitNumber) { Tracer.Assert(circuitMap.Circuit == jam.CircuitSymbol.LogicalCircuit && jam.CircuitSymbol == this.key.CircuitSymbol); JamKey jamKey = new JamKey(jam, bitNumber); Parameter parameter; if (this.parameters.TryGetValue(jamKey, out parameter)) { if (!parameter.Result.IsTriState || !result.IsTriState) { if (parameter.Result == result && parameter.CircuitMap == circuitMap && parameter.Jam == jam && parameter.BitNumber == bitNumber) { return(parameter); } CircuitGlyph symbol = jam.CircuitSymbol; throw new CircuitException(Cause.UserError, Properties.Resources.ErrorManyResults(jam.Pin.Name, symbol.Circuit.Notation + symbol.Point.ToString()) ); } parameter.Result.Link(result); } else { parameter = new Parameter(result, circuitMap, jam, bitNumber); this.parameters.Add(jamKey, parameter); result.Add(parameter); } return(parameter); }
public static void Validate(LogicalCircuit logicalCircuit) { CircuitMap map = new CircuitMap(TableChank.Copy(logicalCircuit)); // this will throw if bit width error occurred. map.Apply(1); }
public WireDisplayControl(Canvas canvas, Point point, Wire wire) { this.InitializeComponent(); Panel.SetZIndex(this, int.MaxValue); Canvas.SetLeft(this, point.X - 3); Canvas.SetTop(this, point.Y - 3); canvas.Children.Add(this); this.UpdateLayout(); if(this.CaptureMouse() && Mouse.LeftButton == MouseButtonState.Pressed) { this.editor = App.Mainframe.Editor; CircuitMap map = this.editor.CircuitRunner.VisibleMap; Tracer.Assert(wire.LogicalCircuit == map.Circuit); this.parameter = map.StateIndexes(wire).ToArray(); this.circuitState = this.editor.CircuitRunner.CircuitState; if(0 < this.parameter.Length && this.circuitState != null) { this.state = new State[this.parameter.Length]; this.bitWidth.Text = Properties.Resources.WireDisplayBitWidth(this.parameter.Length); this.timer = new DispatcherTimer(DispatcherPriority.Normal, App.Mainframe.Dispatcher); this.timer.Tick += TimerTick; this.timer.Interval = new TimeSpan(0, 0, 0, 0, 1000 / (this.editor.IsMaximumSpeed ? 25 : Math.Min(25, this.editor.Frequency * 4))); } else { this.bitWidth.Text = Properties.Resources.WireDisplayDisconnected; this.display.Visibility = Visibility.Collapsed; } } else { this.Cancel(); } }
public JamBit(CircuitMap map, Jam jam, int bit) { Tracer.Assert(map.Circuit == jam.CircuitSymbol.LogicalCircuit); Tracer.Assert(0 <= bit && bit < jam.Pin.BitWidth); this.map = map; this.jam = jam; this.bit = bit; }
protected StateIndex(CircuitMap circuitMap, Jam jam, int bitNumber) { Tracer.Assert(circuitMap.Circuit == jam.CircuitSymbol.LogicalCircuit); Tracer.Assert(jam.IsValid(bitNumber)); this.CircuitMap = circuitMap; this.Jam = jam; this.BitNumber = bitNumber; }
public Result AddResult(CircuitMap circuitMap, Jam jam, int bitNumber) { Tracer.Assert(circuitMap.Circuit == jam.CircuitSymbol.LogicalCircuit && jam.CircuitSymbol == this.key.CircuitSymbol); Result result = new Result(circuitMap, jam, bitNumber); this.results.Add(new JamKey(jam, bitNumber), result); return(result); }
public void OpenLogicalCircuit(CircuitMap map) { Tracer.Assert(this.Power); this.OpenLogicalCircuit(map.Circuit); this.CircuitRunner.VisibleMap = map; map.TurnOn(); map.Redraw(true); this.Mainframe.Status = map.Path(); }
private void CircuitMapCleanUpTest(CircuitProject circuitProject, string logicalCircuitName, int expectedFunctions) { ProjectTester.SwitchTo(circuitProject, logicalCircuitName); CircuitMap map = new CircuitMap(circuitProject.ProjectSet.Project.LogicalCircuit); CircuitState state = map.Apply(CircuitRunner.HistorySize); Assert.AreEqual(expectedFunctions, state.Functions.Count(), "wrong number of functions"); }
public Result(CircuitMap circuitMap, Jam jam, int bitNumber) : base(circuitMap, jam, bitNumber) { Tracer.Assert(jam.Pin.PinType == PinType.Output); this.Parameters = new List <Parameter>(); if (jam.Pin.Circuit is Gate gate && (gate.GateType == GateType.TriState1 || gate.GateType == GateType.TriState2)) { this.TriStateGroup = new HashSet <Result> { this }; } }
public SymbolMap AddSymbol(CircuitMap circuitMap, CircuitSymbol circuitSymbol) { SymbolMapKey key = new SymbolMapKey(circuitMap, circuitSymbol); SymbolMap map; if (!this.symbols.TryGetValue(key, out map)) { map = new SymbolMap(key); this.symbols.Add(key, map); } return(map); }
private void CircuitMapPerfTest(string project, string initialCircuit, int maxCount, int maxSeconds) { CircuitProject circuitProject = ProjectTester.Load(this.TestContext, project, initialCircuit); Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); for (int i = 0; i < maxCount; i++) { CircuitMap circuitMap = new CircuitMap(circuitProject.ProjectSet.Project.LogicalCircuit); CircuitState circuitState = circuitMap.Apply(CircuitRunner.HistorySize); Assert.IsNotNull(circuitState); circuitMap.TurnOn(); } stopwatch.Stop(); this.TestContext.WriteLine("{0} CircuitMap(s) created and applied in {1} - {2:N2} sec per each map", maxCount, stopwatch.Elapsed, stopwatch.Elapsed.TotalSeconds / maxCount); Assert.IsTrue(stopwatch.Elapsed < new TimeSpan(0, 0, maxSeconds), "CircuitMap was created and applied successfully but too slow"); }
private void RunningMapTreeViewSelectedItemChanged(object sender, RoutedPropertyChangedEventArgs <object> e) { try { if (sender == e.OriginalSource && e.NewValue != null && !object.ReferenceEquals(e.OldValue, e.NewValue)) { CircuitMap map = e.NewValue as CircuitMap; if (map != null) { TreeViewItem item = this.Container((TreeView)sender, map); if (item != null) { item.IsExpanded = true; item.BringIntoView(); } } } } catch (Exception exception) { Tracer.Report("MainFrame.RunningMapTreeViewSelectedItemChanged", exception); this.ReportException(exception); } }
private TreeViewItem Container(TreeView treeView, CircuitMap map) { Tracer.Assert(map != null); if (map.Parent == null) { return((TreeViewItem)treeView.ItemContainerGenerator.ContainerFromItem(map)); } else { TreeViewItem parent = this.Container(treeView, map.Parent); if (parent != null) { parent.IsExpanded = true; return((TreeViewItem)parent.ItemContainerGenerator.ContainerFromItem(map)); } else { return(null); } } }
public TableChank(LogicalCircuit logicalCircuit) { this.LogicalCircuit = TableChank.Copy(logicalCircuit); this.Plug(); // Create map and state CircuitMap circuitMap = new CircuitMap(this.LogicalCircuit); this.CircuitState = circuitMap.Apply(CircuitRunner.HistorySize); this.Inputs.ForEach(s => s.Function = circuitMap.FunctionConstant(s.Symbol)); this.Outputs.ForEach(s => s.Function = circuitMap.FunctionProbe(s.Symbol)); this.Inputs.Where(s => s.Function == null).ToList().ForEach(s => this.Inputs.Remove(s)); this.Outputs.Where(s => s.Function == null).ToList().ForEach(s => this.Outputs.Remove(s)); Tracer.Assert(this.Inputs.All(s => s.Function != null) && this.Outputs.All(s => s.Function != null)); this.InputBitCount = this.Inputs.Sum(p => p.Pin.BitWidth); this.Count = BigInteger.One << this.InputBitCount; circuitMap.TurnOn(); }
public bool IsConnected(CircuitMap map, Jam jam, int bit) { return(!this.jamConnected.Add(new JamBit(map, jam, bit))); }
public Parameter(Result result, CircuitMap circuitMap, Jam jam, int bitNumber) : base(circuitMap, jam, bitNumber) { Tracer.Assert(jam.Pin.PinType == PinType.Input); this.Result = result; }
public JamBit(CircuitMap circuitMap, Jam jam, int bit) { this.Map = circuitMap; this.Jam = jam; this.Bit = bit; }
public SymbolMapKey(CircuitMap circuitMap, CircuitSymbol circuitSymbol) { this.CircuitMap = circuitMap; this.CircuitSymbol = circuitSymbol; }
protected override void Edit(Symbol symbol) { CircuitSymbol circuitSymbol = symbol as CircuitSymbol; if (circuitSymbol != null) { if (this.InEditMode) { LogicalCircuit lc = circuitSymbol.Circuit as LogicalCircuit; if (lc != null) { this.OpenLogicalCircuit(lc); return; } CircuitProbe cp = circuitSymbol.Circuit as CircuitProbe; if (cp != null) { this.Edit(cp); return; } CircuitButton cb = circuitSymbol.Circuit as CircuitButton; if (cb != null) { this.Edit(cb); return; } Constant ct = circuitSymbol.Circuit as Constant; if (ct != null) { this.Edit(ct); return; } Sensor sr = circuitSymbol.Circuit as Sensor; if (sr != null) { this.Edit(sr); return; } Memory m = circuitSymbol.Circuit as Memory; if (m != null) { this.Edit(m); return; } Pin pin = circuitSymbol.Circuit as Pin; if (pin != null) { this.Edit(pin); return; } LedMatrix ledMatrix = circuitSymbol.Circuit as LedMatrix; if (ledMatrix != null) { this.Edit(ledMatrix); return; } Sound sound = circuitSymbol.Circuit as Sound; if (sound != null) { this.Edit(sound); return; } GraphicsArray graphicsArray = circuitSymbol.Circuit as GraphicsArray; if (graphicsArray != null) { this.Edit(graphicsArray); return; } } else if (this.CircuitRunner != null && this.CircuitRunner.VisibleMap != null) { CircuitMap map = this.CircuitRunner.VisibleMap.Child(circuitSymbol); if (map != null) { this.OpenLogicalCircuit(map); return; } if (circuitSymbol.Circuit is CircuitProbe) { FunctionProbe functionProbe = this.CircuitRunner.VisibleMap.FunctionProbe(circuitSymbol); if (functionProbe != null) { this.Mainframe.ShowDialog(new DialogProbeHistory(functionProbe)); } return; } if ((circuitSymbol.Circuit is Memory) || (circuitSymbol.Circuit is GraphicsArray)) { IFunctionMemory functionMemory = this.CircuitRunner.VisibleMap.FunctionMemory(circuitSymbol); if (functionMemory != null) { this.Mainframe.ShowDialog(new DialogMemory(functionMemory)); } return; } if (circuitSymbol.Circuit is Constant) { if (this.CircuitRunner.Root.First() == this.CircuitRunner.VisibleMap) { FunctionConstant functionConstant = this.CircuitRunner.VisibleMap.FunctionConstant(circuitSymbol); if (functionConstant != null) { this.CircuitProject.InOmitTransaction(() => functionConstant.Value++); } } else { this.Mainframe.Status = Properties.Resources.MessageNotRootConstant(this.CircuitRunner.Root.First().Circuit.Name); } } } } else if (this.InEditMode) { TextNote textNote = symbol as TextNote; if (textNote != null) { this.Edit(textNote); } } }