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 FFPFog()
{
this.fogMode = FogMode.None;
this.calcMode = FFPFog.CalcMode.PerVertex;
this.passOverrideParams = false;
}
/**
* Constructor
*
* @param cm the calculation mode
*/
public CalcModeRecord(CalcMode cm)
: base(Type.CALCMODE)
{
calculationMode = cm;
}
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");
}
}
