internal void RunCalc(CalcMode mode) { if (File.Exists("CQMacroCreator.exe") && File.Exists("CosmosQuest.exe")) { DQTimer.Stop(); main.calcStatus.SynchronizedInvoke(() => main.calcStatus.Text = "Calc is running"); calcOut = ""; var proc = new Process(); proc.StartInfo.FileName = "CQMacroCreator"; proc.StartInfo.Arguments = mode == CalcMode.DQ ? "quick" : "quickdung"; proc.StartInfo.RedirectStandardOutput = true; proc.StartInfo.RedirectStandardError = true; proc.EnableRaisingEvents = true; proc.StartInfo.CreateNoWindow = true; proc.StartInfo.UseShellExecute = false; proc.ErrorDataReceived += proc_ErrorDataReceived; proc.OutputDataReceived += proc_DataReceived; proc.Exited += proc_Exited; proc.Start(); proc.BeginErrorReadLine(); proc.BeginOutputReadLine(); proc.WaitForExit(); } else { MessageBox.Show("CQMacroCreator.exe or CosmosQuest.exe file not found"); } }
public static TVEResults Calculate(SliceData sliceData, double factor = 0.3, CalcMode mode = CalcMode.BySum) { var data = mode == CalcMode.BySum ? sliceData.DataBySum : sliceData.DataByCount; var total = data.Sum(x => x); var tve = new TVEResults { SliceData = sliceData, Factor = factor, Total = total, Cutoff = (int)(total * factor), Mode = mode, }; var sorted = data.OrderByDescending(x => x).ToArray(); int sum = 0; int nToExceed = 0; for (int i = 0; i < sorted.Length; i++) { nToExceed++; sum += sorted[i]; if (sum > tve.Cutoff) { break; } } tve.Count = nToExceed; tve.Percentage = nToExceed * 100.0 / sliceData.Count; return(tve); }
internal void fightWithPresetLineup(CalcMode mode) { List <string> DQl = new List <string>(); string s = ""; for (int i = 0; i < main.WBlineups[2].Count; i++) { main.WBlineups[2][i].SynchronizedInvoke(() => s = main.WBlineups[2][i].Text); DQl.Add(s); } if (DQl.Any(x => x != "")) { int[] Lineup = main.getLineup(4, 0); currentDQ = int.Parse(PFStuff.DQLevel); main.calcStatus.SynchronizedInvoke(() => main.calcStatus.Text = "Using best lineup."); main.taskQueue.Enqueue(() => sendSolution(Lineup, mode), "DQ"); } else if (main.DQCalcBox.Checked) { RunCalc(mode); } else { main.calcStatus.SynchronizedInvoke(() => main.calcStatus.Text = "Done"); } }
public ItemsPage() { InitializeComponent(); Title = "Converter"; btnChangeCalcMode.Text = "<-->"; curCalcMode = CalcMode.PSI_TO_BAR; BindingContext = new ConverterModel(); }
//This is used by the public ctor and ComparisonBinaryExpressionGenerator. protected BinaryExpressionGenerator(GeneratorFactory factory, BlockGenerator block, ExpressionGenerator left, ExpressionGenerator right, VMSpecializationType type) : base(factory) { _type = type; _left = left; _right = right; var leftType = left.GetSingleType(); var rightType = right.GetSingleType(); if (leftType != VMSpecializationType.Polymorphic || rightType != VMSpecializationType.Polymorphic || _type != VMSpecializationType.Polymorphic) { throw new NotImplementedException(); } //Determine whether we can share the dest slot with one of the operands. //This saves a stack slot. // ? = (expr) + a //will be generated as // dest = (expr) // dest = dest + a //Note that at this point we have no idea what variable (or temp variable) //will be assigned to this binary expr, so for the code // a = (expr) + a //we will get an invalid code if we use the above pattern: // a = (expr) // a = a + a --> Wrong, the value that was in the second a has been lost! //This special case is handled during emit stage. var leftOnStack = left.TryGetFromStack(out _); var rightOnStack = right.TryGetFromStack(out _); if (leftType == _type && !leftOnStack) { _mode = CalcMode.LeftToDest; _rightTemp = block.TempAllocator.Allocate(rightType); } else if (rightType == _type && !rightOnStack) { _mode = CalcMode.RightToDest; _leftTemp = block.TempAllocator.Allocate(leftType); } else { _mode = CalcMode.Normal; if (!leftOnStack) { _leftTemp = block.TempAllocator.Allocate(leftType); } if (!rightOnStack) { _rightTemp = block.TempAllocator.Allocate(rightType); } } }
/// <summary> /// Do one mode of math within a string. /// </summary> /// <param name="s">Some string.</param> /// <param name="cm">Math mode to do.</param> /// <returns>Math-done string.</returns> static private string CalcDo(this string s, CalcMode cm) { return Regex.Replace(s,// and here, see the horrorific beauty of regex... $@"(?<digit1>([0-9]+[.])?[0-9]+)\s*[{cm switch{ CalcMode.Add => @"+", CalcMode.Sub => @"-", CalcMode.Div => @"/", _ => @"*" }}]\s*(?<digit2>([0-9]+[.])?[0-9]+)",
public void SwitchMode(CalcMode mode) { this.MainWindow.Focus(); this.MainWindow.Keyboard.HoldKey(KeyboardInput.SpecialKeys.ALT); this.MainWindow.Keyboard.Enter(((int)mode).ToString()); this.MainWindow.Keyboard.LeaveKey(KeyboardInput.SpecialKeys.ALT); InteractionTimeout.Wait(1000); this.InitializeMisc(); }
private CalcTestData GetTestData(CalcMode mode) { return(new CalcTestData() { AppPath = appPath, MainWindowTitle = title, Numbers = numbers, Mode = mode, }); }
private void MenuSettings_Click(object sender, RoutedEventArgs e) { SettingsWindow settings = new SettingsWindow(); settings.Owner = this; settings.CalculationMode = mode; if (settings.ShowDialog() == true) { mode = settings.CalculationMode; textBox_TextChanged(null, null); } }
public void CreateQuestion() { a = Random.Range(10, 100); b = Random.Range(10, 100); mode = (CalcMode)Random.Range(0, 2); int answer = GetAnswer(); if ((answer < 0) || (answer > 110)) { CreateQuestion(); } }
public MainWindow() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; InitializeComponent(); mode = Properties.Settings.Default.CalcMode; SavedItems = Properties.Settings.Default.SavedItems ?? new ObservableCollection <Calculation>(); lstSaved.ItemsSource = SavedItems; foreach (var item in SavedItems) { parser.SetVariable($"r{item.ID}", item.Result); } }
public double CalcMaxScore(Nucleotide[] data, CalcMode? mode = null) { var ret = 0.0; foreach (Direction direction in Enum.GetValues(typeof (Direction))) { var b = data.GetChain(direction); for (int i = 0; i < data.Length - Length; i++) { var tmp = CalcScore(b, i, mode); if (tmp > ret) ret = tmp; } } return ret; }
private void ButtonSubmit_Click(object sender, RoutedEventArgs e) { if ((bool)radDecimal.IsChecked) { CalculationMode = CalcMode.Decimal; } else if ((bool)radBoolean.IsChecked) { CalculationMode = CalcMode.Boolean; } else { CalculationMode = CalcMode.Double; } this.DialogResult = true; this.Close(); }
private async Task <bool> sendSolution(int[] lineup, CalcMode mode) { if (DQFailedAttempts >= 3) { if (main.DQCalcBox.getCheckState()) { RunCalc(mode); } } else { bool b = false; if (mode == CalcMode.DQ) { b = await main.pf.sendDQSolution(lineup); } if (mode == CalcMode.DUNG) { b = await main.pf.sendDungSolution(lineup); } if (!b) { DQFailedAttempts++; main.taskQueue.Enqueue(() => sendSolution(lineup, mode), "DQ"); } else { if (currentDQ == int.Parse(PFStuff.DQLevel)) { if (main.DQCalcBox.getCheckState()) { RunCalc(mode); } } else { DQFailedAttempts = 0; currentDQ = int.Parse(PFStuff.DQLevel); main.taskQueue.Enqueue(() => sendSolution(lineup, mode), "DQ"); main.autoLevel.levelTimer.Interval = 60 * 1000; } } } return(true); }
public static Histogram Calculate(SliceData sd, CalcMode calcMode = CalcMode.BySum, HistoMode histoMode = HistoMode.Normal) { var h = new Histogram { SliceData = sd, Frequency = new int[100], CalcMode = calcMode, HistoMode = histoMode, }; var data = calcMode == CalcMode.ByCount ? sd.DataByCount : sd.DataBySum; if (h.HistoMode == HistoMode.Normal) { var min = calcMode == CalcMode.ByCount ? sd.RollingCountMinValue : sd.RollingSumMinValue; var max = calcMode == CalcMode.ByCount ? sd.RollingCountMaxValue : sd.RollingSumMaxValue; double div = Math.Max(1.0, max - min); foreach (var val in data) { int idx = Math.Min(99, (int)Math.Floor((val - min) / div * 100.0)); h.Frequency[idx]++; } } else { var min = calcMode == CalcMode.ByCount ? sd.RollingCountMinValue : sd.RollingSumMinValue; var max = calcMode == CalcMode.ByCount ? sd.RollingCountMaxValue : sd.RollingSumMaxValue; double div = Math.Max(10.0, max - min); foreach (var val in data) { int idx = Math.Min(99, (int)Math.Floor((Math.Log10(Math.Max(1, val - min)) / Math.Log10(div) * 100.0))); h.Frequency[idx]++; } } return(h); }
public double CalcScore(Nucleotide[] data, int pos, CalcMode? mode) { switch (mode ?? DefaultCalcMode) { case CalcMode.Degree: return CalcScoreDegree(data, pos); case CalcMode.Eps: return CalcScoreEps(data, pos); case CalcMode.Strict: return CalcScoreStrict(data, pos); default: throw new NotSupportedException(); } }
public static MachineStatus Calc(long pc, long[] memory, long[] Inputs, Action <string, long, long> outputFunc, CalcMode calcMode = default) { int inputCounter = 0; long relativeBase = 0; while (pc < memory.Length) { var opcode = memory[pc] % 100; var arg1Mode = ArgMode(memory[pc], 100); var arg2Mode = ArgMode(memory[pc], 1000); var arg3Mode = ArgMode(memory[pc], 10000); long getArg1() { switch (opcode) { case 1: case 2: case 3: case 4: case 5: case 6: case 7: case 8: case 9: var addr = memory[pc + 1]; long arg = addr; if (arg1Mode == 0) { arg = memory[addr]; } if (arg1Mode == 2) { arg = memory[addr + relativeBase]; } return(arg); } return(0); } long getArg2() { switch (opcode) { case 1: case 2: case 5: case 6: case 7: case 8: var addr = memory[pc + 2]; long arg = addr; if (arg2Mode == 0) { arg = memory[addr]; } if (arg2Mode == 2) { arg = memory[addr + relativeBase]; } return(arg); } return(0); } long getArg3() { switch (opcode) { case 7: case 8: var addr = memory[pc + 3]; long arg = addr; if (arg3Mode == 2) { arg = memory[addr + relativeBase]; } return(arg); } return(0); } var arg1 = getArg1(); var arg2 = getArg2(); var arg3 = getArg3(); switch (opcode) { case 1: var addrt = memory[pc + 3]; if (arg3Mode == 2) { addrt = addrt + relativeBase; } memory[addrt] = arg1 + arg2; pc = pc + 4; break; case 2: addrt = memory[pc + 3]; if (arg3Mode == 2) { addrt = addrt + relativeBase; } memory[addrt] = arg1 * arg2; pc = pc + 4; break; case 3: var addr31 = memory[pc + 1]; if (arg1Mode == 2) { addr31 = relativeBase + addr31; } memory[addr31] = Inputs[inputCounter++]; pc = pc + 2; if (calcMode == CalcMode.RunToFirstInput) { return new MachineStatus { Result = -240174, ProgramCounter = pc, RanToHalt = false } } ; break; case 4: arg1 = getArg1(); outputFunc("Output {0} {1}", pc, arg1); pc = pc + 2; if (calcMode == CalcMode.RunToFirstOutput) { return new MachineStatus { Result = arg1, ProgramCounter = pc, RanToHalt = false } } ; break; case 5: //JNZ if (arg1 != 0) { pc = arg2; } else { pc = pc + 3; } break; case 6: //JZ if (arg1 == 0) { pc = arg2; } else { pc = pc + 3; } break; case 7: //LT addrt = memory[pc + 3]; if (arg3Mode == 2) { addrt = addrt + relativeBase; } if (arg1 < arg2) { memory[addrt] = 1; } else { memory[addrt] = 0; } pc = pc + 4; break; case 8: //EQ addrt = memory[pc + 3]; if (arg3Mode == 2) { addrt = addrt + relativeBase; } if (arg1 == arg2) { memory[addrt] = 1; } else { memory[addrt] = 0; } pc = pc + 4; break; case 9: //Set Relative Base relativeBase += arg1; pc += 2; break; case 99: return(new MachineStatus { Result = memory[0], ProgramCounter = pc, RanToHalt = true }); } } return(new MachineStatus { Result = -230771, ProgramCounter = pc, RanToHalt = false }); }
/** * Constructor * * @param cm the calculation mode */ public CalcModeRecord(CalcMode cm) : base(Type.CALCMODE) { calculationMode = cm; }
public FFPFog() { this.fogMode = FogMode.None; this.calcMode = FFPFog.CalcMode.PerVertex; this.passOverrideParams = false; }
public CalculationMode(CalcMode modeOnStartup) { CurrentMode = modeOnStartup; }
public double CalcMaxScore(Nucleotide[] data, int startPos, int endPos, CalcMode? mode = null) { Debug.Assert(startPos > 0); var ret = 0.0; var end = Math.Min(data.Length - Length, endPos); for (int i = startPos; i < end; i++) { var tmp = CalcScore(data, i, mode); if (tmp > ret) ret = tmp; } return ret; }
public double[] CalcMaxScore(Nucleotide[][] data, CalcMode? mode = null) { return data.Select(p => CalcMaxScore(p, mode)).ToArray(); }
public object Evaluate(string expression, CalcMode calMode, IntegerBits intBits, IntegerFormat intFmt) { Expression.CurCalcMode = calMode; Expression.CurIntBits = intBits; Expression.CurIntFmt = intFmt; var x = _cache != null ? _cache[expression] : Parse(expression); return Token.FormatValue(x.Evaluate(), calMode, intBits, intFmt); }
public double CalcScore(Nucleotide[] data, int pos, CalcMode? mode) { double ret = 0.0; var mo = mode ?? DefaultCalcMode; foreach (var ms in new[] {_posMotiffs, _negMotiffs}) { var sum = new List<double>(); foreach (var m in ms) { switch (mo) { case CalcMode.Degree: sum.Add(m.CalcScoreDegree(data, pos)); break; case CalcMode.Eps: sum.Add(m.CalcScoreEps(data, pos)); break; case CalcMode.Strict: sum.Add(m.CalcScoreStrict(data, pos)); break; default: throw new NotSupportedException(); } } var tmp = Mode == DiffMode.Avg ? sum.Average() : sum.Max(); if (ms == _posMotiffs) ret += tmp; else ret -= tmp; } return (ret + 1.0)/2.0; }
public static MachineStatus Calc(MachineStatus st, List <long> Inputs, Action <string, long, long> outputFunc, CalcMode calcMode = default) { while (st.pc < st.memory.Length) { var opcode = st.memory[st.pc] % 100; var arg1Mode = ArgMode(st.memory[st.pc], 100); var arg2Mode = ArgMode(st.memory[st.pc], 1000); var arg3Mode = ArgMode(st.memory[st.pc], 10000); long getArg1() { switch (opcode) { case 1: case 2: case 3: case 4: case 5: case 6: case 7: case 8: case 9: var addr = st.memory[st.pc + 1]; long arg = addr; if (arg1Mode == 0) { arg = st.memory[addr]; } if (arg1Mode == 2) { arg = st.memory[addr + st.RelativeBase]; } return(arg); } return(0); } long getArg2() { switch (opcode) { case 1: case 2: case 5: case 6: case 7: case 8: var addr = st.memory[st.pc + 2]; long arg = addr; if (arg2Mode == 0) { arg = st.memory[addr]; } if (arg2Mode == 2) { arg = st.memory[addr + st.RelativeBase]; } return(arg); } return(0); } long getArg3() { switch (opcode) { case 7: case 8: var addr = st.memory[st.pc + 3]; long arg = addr; if (arg3Mode == 2) { arg = st.memory[addr + st.RelativeBase]; } return(arg); } return(0); } var arg1 = getArg1(); var arg2 = getArg2(); var arg3 = getArg3(); switch (opcode) { case 1: var addrt = st.memory[st.pc + 3]; if (arg3Mode == 2) { addrt = addrt + st.RelativeBase; } st.memory[addrt] = arg1 + arg2; st.pc = st.pc + 4; break; case 2: addrt = st.memory[st.pc + 3]; if (arg3Mode == 2) { addrt = addrt + st.RelativeBase; } st.memory[addrt] = arg1 * arg2; st.pc = st.pc + 4; break; case 3: var addr31 = st.memory[st.pc + 1]; if (arg1Mode == 2) { addr31 = st.RelativeBase + addr31; } if (Inputs.Count > 0) { st.memory[addr31] = Inputs[0]; Inputs.RemoveAt(0); st.pc = st.pc + 2; if (calcMode == CalcMode.RunToFirstInput) { st.ReturnMode = ReturnMode.ProcessedInput; return(st); } } else { st.ReturnMode = ReturnMode.WaitingForInput; return(st); } break; case 4: arg1 = getArg1(); outputFunc("Output {0} {1}", st.pc, arg1); st.pc = st.pc + 2; if (calcMode == CalcMode.RunToFirstOutput) { st.Result = arg1; st.ReturnMode = ReturnMode.ProducedOutput; } break; case 5: //JNZ if (arg1 != 0) { st.pc = arg2; } else { st.pc = st.pc + 3; } break; case 6: //JZ if (arg1 == 0) { st.pc = arg2; } else { st.pc = st.pc + 3; } break; case 7: //LT addrt = st.memory[st.pc + 3]; if (arg3Mode == 2) { addrt = addrt + st.RelativeBase; } if (arg1 < arg2) { st.memory[addrt] = 1; } else { st.memory[addrt] = 0; } st.pc = st.pc + 4; break; case 8: //EQ addrt = st.memory[st.pc + 3]; if (arg3Mode == 2) { addrt = addrt + st.RelativeBase; } if (arg1 == arg2) { st.memory[addrt] = 1; } else { st.memory[addrt] = 0; } st.pc = st.pc + 4; break; case 9: //Set Relative Base st.RelativeBase += arg1; st.pc += 2; break; case 99: { st.ReturnMode = ReturnMode.RanToHalt; st.Result = st.memory[0]; return(st); } } } return(st); }
public Object Eva(String str, CalcMode calcMode, IntegerFormat fmt, IntegerBits numBits, bool updateAnswer) { Int64 result = 0; if (str.Length < 1) return false; try { m_numFmt = fmt; switch (fmt) { case IntegerFormat.DEC: Object obj = m_calcEngine.Evaluate(str, calcMode, numBits, fmt); if (obj != null && updateAnswer) { if (m_calcEngine.Variables.ContainsKey("ans")) UpdateVariable("ans", obj); else AddVariable("ans", obj); } return obj; case IntegerFormat.HEX: return Int64.Parse(str, System.Globalization.NumberStyles.HexNumber); case IntegerFormat.BIN: if (ParseBinStr(str, ref result)) return result; else throw new ArgumentException(); default: return null; } } catch (Exception _ex) { throw _ex; } }
public static object FormatValue(object val, CalcMode calcMode, IntegerBits intBits, IntegerFormat intFmt) { double v; if (val is string) return val; if (val is double) { v = (double)val; } // handle booleans if (val is bool) { v = 1.0; } // handle nulls if (val == null) { v = 0; } // handle everything else v = (double)Convert.ChangeType(val, typeof(double)); if (calcMode == CalcMode.FLOAT) { return (double)v; } else if (calcMode == CalcMode.INTEGER_SIGNED) { if (intBits == IntegerBits.BITS_64) { return (Int64)v; } else if (intBits == IntegerBits.BITS_32) { return (Int32)v; } else if (intBits == IntegerBits.BITS_16) { return (Int16)v; } else if (intBits == IntegerBits.BITS_8) { return (SByte)v; } else { throw new Exception("Invalid Integer Bits"); } } else if (calcMode == CalcMode.INTEGER_UNSIGNED) { if (intBits == IntegerBits.BITS_64) { return (UInt64)v; } else if (intBits == IntegerBits.BITS_32) { return (UInt32)v; } else if (intBits == IntegerBits.BITS_16) { return (UInt16)v; } else if (intBits == IntegerBits.BITS_8) { return (Byte)v; } else { throw new Exception("Invalid Integer Bits"); } } else { throw new Exception("Invalid Calculate Mode"); } }