public static void Matches(List <string> expected, List <string> actual)
{
try {
Objects.each(expected, actual, Matches);
} catch (Exception e) {
throw Bomb.toss("Expected list equality, but actual\n" + Objects.toShortString(actual) + "\ndid not match\n" + Objects.toShortString(expected), e);
}
}
public void testCdsSlippageTable()
{
var spreadBps = O.list(double.NegativeInfinity, -1.0, 0.0, 50.0, 100.0, 125.0, 500.0, 1000.0, 1200.0, double.PositiveInfinity);
var expectedSlippages = O.list(3.0, 3.0, 3.0, 6.5, 10.0, 10.8333, 20.0, 30.0, 30.0, 30.0);
O.each(spreadBps, expectedSlippages,
(bp, slippage) => AlmostEqual(slippage, CdsSlippageTable.slippageInBps(bp), 0.0001));
}
void requireFerretHasOrders(params Order[] orders)
{
if (O.isEmpty(orders))
{
ferret.requireNoMessage(); return;
}
O.wait(() => ferret.hasMessages(orders.Length));
O.each(orders, ferret.get(), requireOrderMatches);
AreEqual(orders.Length, LiveOrders.ORDERS.ordersSubmitted(systemId, symbol().name).size());
}
static void stopProcesses(string key)
{
O.each(O.copy(processes.get(key)), process => {
if (!process.HasExited)
{
LogC.info("killing pid " + process.Id);
process.Kill();
}
processes.get(key).Remove(process);
});
LogC.info("all processes killed for " + key);
}
static SystemArguments arguments(IEnumerable <Symbol> symbols, LiveSystem liveSystem, RunMode mode, Type type)
{
O.each(symbols, symbol => MsivTable.MSIVS.insert(symbol.name, liveSystem.siv()));
liveSystem.setQClassName(type.FullName);
liveSystem.populateDetailsIfNeeded(false);
return(new SystemArguments(symbols, new Parameters {
{ "LeadBars", 5 },
{ "systemId", liveSystem.id() },
{ "RunMode", (double)mode },
{ "lookback", 2 }
}));
}
public void testFilterBasedOnSiv()
{
addOrders();
var gui = new FakeOrderTrackerGUI();
var orderTable = gui.tracker.orderTable();
gui.selectedSystem = "NDayBreak-daily-1.0";
gui.setMarket("RE.TEST.TY.1C");
gui.doAllWork();
AreEqual(2, orderTable.count());
O.each(orderTable.rows(), row => AreEqual("NDayBreak-daily-1.0", row["system"]));
}
void restart(string host)
{
if (host.Equals("unknown"))
{
alertUser("Cannot restart system that has not been started"); return;
}
clearRestarts();
O.each(statusGrid.selectedRows(), (i, last, row) => {
var id = (int)row["id"];
var restartTime = O.now().AddSeconds(10 * i);
restarts.replace(id, restartTime, () => statusTracker.restart(host, id));
});
}
public void testForeignExchangeFXConversion()
{
symbol().setBigPointValue(5000);
var collector = new StatisticsCollector(arguments());
doSomeTrades(collector);
O.each(O.list(-90000.0, 369000, -253500, -907000, 304500, 91000), collector.pnl(), (a, b) => AlmostEqual(a, b, 1e-8));
var metrics = collector.metrics();
AreEqual(1, metrics["QWinningTrades"]);
AlmostEqual(91500, metrics["QAverageWin"], 1e-8);
AlmostEqual(-577500, metrics["QAverageLoss"], 1e-8);
AlmostEqual(-486000, metrics["QNetProfit"], 1e-8);
}
public object liveParameters(string system, string pv)
{
try {
var parameters = Parameters.liveParameters(system, pv);
var result = new object[parameters.Count, 2];
var i = 0;
O.each(parameters, e => {
// name value
result[i, 0] = e.Key;
result[i, 1] = e.Value;
i++;
});
return(result);
}
catch (Exception e) {
return(loggedError("failed to retrieve live parameters for " + system + " " + pv, e));
}
}
public void testForeignExchangeFXConversionCanBeTurnedOff()
{
symbol().setBigPointValue(5000);
var args = arguments();
args.runInNativeCurrency = true;
var collector = new StatisticsCollector(args);
doSomeTrades(collector);
O.each(O.list(-15000.0, 60000, -90000, 130000, -35000, 70000), collector.pnl(), (a, b) => AlmostEqual(a, b, 1e-8));
var metrics = collector.metrics();
AreEqual(2, metrics["QWinningTrades"]);
AlmostEqual(60000, metrics["QAverageWin"], 1e-8);
AlmostEqual(0, metrics["QAverageLoss"], 1e-8);
AlmostEqual(120000, metrics["QNetProfit"], 1e-8);
}
public MyInstaller()
{
Installers.Add(new ServiceProcessInstaller {
Account = ServiceAccount.LocalSystem
});
var q = Program.qAssembly();
O.each(q.GetTypes(), type => {
if (!type.IsSubclassOf(typeof(ServiceBase)))
{
return;
}
var service = (ServiceBase)type.GetConstructor(Type.EmptyTypes).Invoke(new object[0]);
Installers.Add(new MyServiceInstaller(type)
{
StartType = ServiceStartMode.Disabled,
ServiceName = service.ServiceName
});
});
}
public DataTable table()
{
var result = new QDataTable();
result.addTypedColumn("Metric", typeof(string));
O.each(O.sort(Keys, (a, b) => {
if (a.Equals(b))
{
return(0);
}
if (a.Equals("ALL"))
{
return(-1);
}
return(b.Equals("ALL") ? 1 : a.CompareTo(b));
}), symbol => result.addTypedColumn(symbol.Replace(".", "_"), typeof(double)));
var example = O.first(Values);
O.each(O.sort(example.Keys), metric => addRow(metric, result));
return(result);
}
public override void setUp()
{
base.setUp();
currentDate = date("2009-01-01");
O.each(symbols, symbol => {
var subSymbolSystem = symbolSystem(symbol);
subSymbolSystem.richCheap.enterTestMode();
subSymbolSystem.dv01.enterTestMode();
subSymbolSystem.spread.enterTestMode();
subSymbolSystem.dtd.enterTestMode();
});
O.zeroTo(leadBars(), i => processBar(new[] {
bar(0, 1, 1, 0, 0.01, 1),
bar(1, 1, 1, 0, 0.02, 1),
bar(2, 1, 1, 0, 0.03, 1),
bar(3, 1, 1, 0, 0.04, 1),
bar(4, 1, 1, 0, 0.05, 1)
}));
}
protected override void OnStop()
{
O.each(processes.keys(), stopProcesses);
}
void hasPositions(Position[] expected)
{
O.each(system.positions(SYMBOL), O.list(expected), (a, b) => a.requireMatches(b));
}
protected override void OnStop()
{
O.each(processes, process => process.Kill());
}
public void testMetricCalcs()
{
var collector = new StatisticsCollector(arguments());
addClosedPosition(collector, 100.0, 1);
addClosedPosition(collector, 90.0, 2);
addClosedPosition(collector, -90.25, 3);
addClosedPosition(collector, 0, 4);
addClosedPosition(collector, -98.25, 5);
var position = addOpenPosition(collector, 95.0, 10);
addBar(collector, position, 96, 1);
AreEqual(11.50 * symbol().bigPointValue, collector.netProfit());
addBar(collector, position, 97, 1);
AreEqual(21.50 * symbol().bigPointValue, collector.netProfit());
addBar(collector, position, 92, 1);
addBar(collector, position, 97, 1);
var expectedMetrics = new Dictionary <string, double> {
{ "QDownsideDeviation", 50000 },
{ "QStandardDeviation", 41298.4563876182 },
{ "QStandardDeviationWeekly", 0 },
{ "QStandardDeviationMonthly", 0 },
{ "QSharpeRatio", 3.99276123210182 },
{ "QSharpeRatioWeekly", 0 },
{ "QSharpeRatioMonthly", 0 },
{ "QNetProfitPerMaxDrawdown", 21500 / 50000.0 },
{ "QLargestLossPerAverageLoss", 98250 / 94250.0 },
{ "QLargestLossPerGrossLoss", 98250 / 188500.0 },
{ "QLargestWinPerAverageWin", 100000 / 95000.0 },
{ "QLargestWinPerGrossProfit", 100000 / 190000.0 },
{ "QLargestWinPerNetProfit", 100000 / 21500.0 },
{ "QWinLossRatio", 1.00795755968170 },
{ "QAverageTrade", 21500 / 6.0 },
{ "QExpectancy", -0.196816976127321 },
{ "QTradesPerBar", 1.5 },
{ "QExpectancyScore", -0.295225464190981 },
{ "QLargestWinningTrade", 100000 },
{ "QLargestLosingTrade", -98250 },
{ "QAverageLoss", -94250 },
{ "QAverageWin", 95000 },
{ "QRealizedNetProfit", 1500 },
{ "QRealizedGrossLoss", -188500 },
{ "QRealizedGrossProfit", 190000 },
{ "QAverageProfit", 300 },
{ "QNetProfit", 21500 },
{ "QUnrealizedNetProfit", 20000 },
{ "QWinningTradesPct", 0.40 },
{ "QLosingTradesPct", 0.40 },
{ "QNeutralTrades", 1 },
{ "QWinningTrades", 2 },
{ "QLosingTrades", 2 },
{ "QLongWinningTrades", 2 },
{ "QLongLosingTrades", 2 },
{ "QShortWinningTrades", 0 },
{ "QShortLosingTrades", 0 },
{ "QMaxConsecutiveWinningTrades", 2 },
{ "QMaxConsecutiveLosingTrades", 1 },
{ "QTotalFinishedTrades", 5 },
{ "QTotalTrades", 6 },
{ "QAverageLosingBarsHeld", 4 },
{ "QAverageWinningBarsHeld", 1.5 },
{ "QAverageBarsHeld", 3 },
{ "QWinningBarsHeld", 3 },
{ "QLosingBarsHeld", 8 },
{ "QTotalBarsHeld", 15 },
{ "QMaxDrawdown", -50000 },
{ "QKRatio", -0.077151674981046 },
{ "QAnnualizedNetProfit", 2617625 },
{ "QCalmarRatio", 52.3525 },
{ "QConditionalTenPercentileCalmarRatio", 0 },
{ "QConditionalTwentyPercentileCalmarRatio", 0 },
{ "QAverageDrawdown", -50000 },
{ "QAverageDrawdownTime", 2 },
{ "QAverageDrawdownRecoveryTime", 1 },
{ "QTenPercentileDrawdown", 0 },
{ "QConditionalTenPercentileDrawdown", 0 },
{ "QTwentyPercentileDrawdown", 0 },
{ "QConditionalTwentyPercentileDrawdown", 0 },
{ "QSortinoRatio", 4.74463644550349 },
{ "QOmegaRatio", 1.43 },
{ "QUpsidePotentialRatio", 0.476666666666667 },
{ "QTotalSlippage", 156.25 },
{ "QAverageSlippagePerWinningTrade", 31.25 },
{ "QAverageSlippagePerLosingTrade", 31.25 }
};
var metrics = collector.metrics();
O.each(expectedMetrics, (name, value) => AlmostEqual(value, Bomb.missing(metrics, name), 1e-10));
AreEqual(expectedMetrics.Count, metrics.Count);
}
void kill()
{
clearRestarts();
O.each(statusGrid.selectedRows(), row => StatusTracker.kill((int)row["id"]));
}
