Compare commits

..
Author SHA1 Message Date
John Colvin a67b32fd33 ui-tweak (DJ): Display 'volume' just below 'day change' in ladder 2021-01-07 11:36:35 -06:00
John Colvin 3da8fbd25d feat (DJ): Give bid/ask cells with markets a lighter background in ladder
There is a small chance this will impact performance when
a large number of ladders (50+) are open.  Therefore, this
behavior can be toggled on/off in config, via
LadderKnobs.lighten_market_background.
2021-01-07 11:18:13 -06:00
John Colvin a8cd07cbd2 refactor: Consolidate tick tests after tricky merge
The branches that were merged, DJ_ICE and
DJ_ICE_ladder_price_aggregation, both added new
tick tests.  The former put them in a new file,
"TickTests.cs," while the latter added them
to "SecurityTests.cs."  This commit places all
tick tests in "TickTests.cs."
2021-01-07 10:37:02 -06:00
John Colvin badb463e03 Merge remote-tracking branch 'origin/DJ_ICE_ladder_price_aggregation' into DJ_ICE 2021-01-06 12:08:39 -06:00
John Colvin b6a942d6b2 Add tooltips to ladder left-panel price points 2021-01-06 11:00:51 -06:00
John Colvin 7d8bc13282 Tailor default ladder price point settings for DJ 2021-01-06 11:00:51 -06:00
Pete Fisher cbad79b909 fixed use_onixs 2021-01-06 11:00:51 -06:00
Pedro Pinto 58768567d1 Added operator id to tag 116. 2021-01-06 11:00:51 -06:00
Pedro Pinto 2475ca3662 Used clearing account to populate tag 116 (ATID) 2021-01-06 11:00:51 -06:00
John Colvin f12b8fedc0 feat (DJ): Display settings for ladder left-panel price points
* Add background and font settings for all price points

* Indicate 'day change' sign with modal settings (positive,
  zero, and negative) for background and font color

* Hide 'day change' leading zeros in tick part

* Don't show 'day change' zero integer part (e.g.,
  '25' instead of '0.25')
2021-01-06 11:00:51 -06:00
John Colvin ed920c7c5a Move security/tick data classes to spark_core
* spark_core is the appropriate project for such
  'vocabulary' types.

* unit tests in the spark_tests project can now
  reference these types (this was the immediate
  impetus for the move).
2021-01-04 18:23:27 -06:00
John Colvin db20473949 add some docker scripts (start_docker.sh, docker_bash.sh) 2021-01-04 10:12:20 -06:00
John Colvin 5bf8162fcf vscode (build): change linux build task to run in docker
* prompts user for configuration (debug or release)

* looks for docker instance named "${USER}s_docker"
2021-01-04 10:10:23 -06:00
Taha Afzal 447d3303d1 Time based throttles code complete 2020-09-28 09:57:29 -04:00
Taha Afzal 5693fc4444 Merge branch 'DJ_ICE' of bitbucket.org:bluetradesys/spark into DJ_ICE 2020-09-27 22:48:30 -04:00
Taha Afzal 8896066e2c Time based price throttles 2020-09-25 09:49:19 -04:00
John Colvin 4992f4e0cf config toggle to show/hide ladder scrollbar for dj (defaults to hide) 2020-09-24 16:25:43 -05:00
John Colvin 3503946011 add quote-time-throttle params to SyntheticEditor gui 2020-09-21 19:28:41 -05:00
John Colvin d31d8648f1 frozen price lines in ladder (for dj) 2020-09-09 16:39:53 -04:00
Taha Afzal 2c15f83c85 merge fix 2020-08-26 09:49:16 -04:00
Taha Afzal f9dfb04fca tooltip change 2020-08-25 23:02:02 -04:00
Taha Afzal 680b19b6fb Enable Hedging and Lean Ticks Offset 2020-08-25 22:58:15 -04:00
John Colvin f790b8f59b RiskManagement view updates when imported row overwrites existing one 2020-08-20 11:14:56 -05:00
John Colvin fbed8e5428 fix AdminModel.delete_risk_limits: don't increment i at end of iteration when an item is removed 2020-08-14 13:15:35 -05:00
John Colvin 524f3be25a RiskManagementWindow - imported rows weren't filtered by account 2020-08-14 11:21:49 -05:00
John Colvin 9823b44083 RiskManagementWindow - hook up menu display vm 2020-08-14 11:04:14 -05:00
John Colvin 30feda72bb Merged DJ_ICE_proprietary_risk into DJ_ICE 2020-08-14 10:54:47 -05:00
John Colvin 2d0e63546d Merge branch 'DJ_ICE' into DJ_ICE_proprietary_risk 2020-08-14 10:53:26 -05:00
John Colvin cc02fa1c84 risk limits import dialog (for dj) 2020-08-13 14:13:44 -05:00
Taha Afzal 6139d53e49 Merge branch 'DJ_ICE' of bitbucket.org:bluetradesys/spark into DJ_ICE 2020-08-12 15:04:34 -04:00
Taha Afzal 7f3c2e75a3 Fixed the qty in the leg fills for spreads with different exchange_qty_mults 2020-08-12 15:04:15 -04:00
John Colvin 0f61e24ae5 fix ColumnBase.SortDirection binding to DIYGridColumnModel 2020-08-12 13:00:03 -05:00
John Colvin 8da2ebee5c SelectionModel should only select the pending selection once (was reselecting it every time the items changed) 2020-08-12 12:59:19 -05:00
Pedro Pinto a1faf685eb CMake, you suck. 2020-08-11 15:59:40 -04:00
Pedro Pinto 9e2b01a723 Cleaned up branch for delivery to DJ 2020-08-11 13:54:27 -04:00
John Colvin d03c74f270 remove unused 'actual_width' prop from DIYGridColumnModel 2020-08-05 15:11:06 -05:00
John Colvin 834a28916b synchronize column model's GridColumnSettings with the column view 2020-08-05 15:10:23 -05:00
John Colvin 43ccb4e3e7 fix risk management thread name typo 2020-08-05 12:20:24 -05:00
John Colvin 8761f313f5 remove with_reguard_to_price param from tick 'format' extension 2020-07-20 10:50:15 -05:00
John Colvin 3906ef6507 fix typo in ConvertUtils.update_value_type (was missing negation '!') 2020-07-19 13:28:09 -05:00
John Colvin 78055d79c6 fix tick unit tests, and reorganize security tests a bit 2020-07-19 13:27:12 -05:00
John Colvin 885a9dd939 add precision param (epsilon) to tickup/down methods 2020-07-19 13:20:00 -05:00
John Colvin 20c449de60 TickFactors are cached in a ThreadStatic dictionary rather than concurrent (no locks required) 2020-07-15 11:22:11 -05:00
John Colvin 52b487946a ticksize extension handles invalid tick props gracefully 2020-07-15 10:50:25 -05:00
John Colvin 98144ea939 remove unused parameter from TickTestHelper.full_ticks_from_zero 2020-07-14 15:46:06 -05:00
John Colvin 5e27a5fa7c fix ladder session low/high grid animation (was not using the ticks per row setting) 2020-07-14 15:39:55 -05:00
John Colvin 6cfc15ccd8 LadderGridHost invalidates '_spec' on connect_vm (not just on settings updates) 2020-07-14 15:38:21 -05:00
John Colvin 2de08c2c48 fix typo in LadderGridHost._spec getter (was accidentally returning the fallback value) 2020-07-14 15:27:03 -05:00
John Colvin fb6e05560b make tick unit tests more robust (test tick_up/down, use these methods to covalidate results) 2020-07-14 12:48:21 -05:00
John Colvin 1abf84337f include Sim ContractSpecs in tick unit tests 2020-07-14 11:53:57 -05:00
John Colvin d691e0aeee ladder settings dialog - fix 'when implied is > 0' label alignment 2020-07-14 11:01:32 -05:00
John Colvin 5e0f1b59fb added tick unit test (namely for 'full_ticks_from_zero' method) 2020-07-14 10:53:30 -05:00
John Colvin a234ecbf26 added 'full_ticks_from' method which accepts an origin price (instead of just an arbitrary 0) 2020-07-14 10:53:27 -05:00
John Colvin 062cabf075 TickUtils.full_ticks_from_zero checks pricebreak 2020-07-13 13:52:29 -05:00
John Colvin 39e1fd4a1a move LadderUtils methods to TickUtils (all were related to ticks) 2020-07-09 12:05:17 -05:00
John Colvin 4d902747df move tick data\utils to spark_core 2020-07-09 11:58:19 -05:00
John Colvin 50d0078556 add 'ticks per row' ladder setting 2020-07-09 11:45:31 -05:00
John Colvin d86b7c6c50 add TickUp/DownCommand dependency props to TickUpDownUInt 2020-07-08 12:48:45 -05:00
128 changed files with 4057 additions and 5767 deletions

No files matched your search

+14 -2
View File
@@ -48,9 +48,9 @@
}
},
{
"label": "linux build (Debug)",
"label": "linux_build",
"type": "shell",
"command": "cd build/ninja_debug; time ninja",
"command": "docker exec -i ${USER}s_docker bash -c \"cd build/ninja_${input:build_configuration} && ninja\"",
"group": {
"kind": "build",
"isDefault": true
@@ -59,5 +59,17 @@
"$gcc"
]
}
],
"inputs": [
{
"id": "build_configuration",
"type": "pickString",
"default": "debug",
"description": "Configuration:",
"options": [
"debug",
"release"
]
}
]
}
+7
View File
@@ -1,6 +1,8 @@
cmake_minimum_required(VERSION 3.5)
project(spark)
set (USE_ONIX "TRUE")
if (WIN32)
set (platform "windows")
else ()
@@ -40,6 +42,11 @@ else ()
-fPIC -Wall -pedantic -Wextra -Werror \
-Wno-missing-braces -Wno-ignored-qualifiers \
--std=c++17 -fdiagnostics-color")
if (${USE_ONIX})
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DUSE_ONIX")
endif()
set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_DEBUG} -fno-omit-frame-pointer -DNDEBUG -O3")
set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wno-undef")
add_subdirectory(src/server/sparkd)
+1 -1
View File
@@ -1 +1 @@
set(sources /home/eric/spark/doc/user/build.sh;content/_index.md;content/bts_spark/Glossary/_index.md;content/bts_spark/Help/_index.md;content/bts_spark/Help/about_spark.png;content/bts_spark/Help/image39.png;content/bts_spark/Help/image58.png;content/bts_spark/Launcher/_index.md;content/bts_spark/Launcher/image38.png;content/bts_spark/Launcher/image68.png;content/bts_spark/Logging-In-to-the-System/_index.md;content/bts_spark/Logging-In-to-the-System/image3.png;content/bts_spark/Logging-In-to-the-System/image64.png;content/bts_spark/Market/_index.md;content/bts_spark/Market/change_securities.png;content/bts_spark/Market/image11.png;content/bts_spark/Market/image14.png;content/bts_spark/Market/image20.png;content/bts_spark/Market/image21.png;content/bts_spark/Market/image23.png;content/bts_spark/Market/image24.png;content/bts_spark/Market/image34.png;content/bts_spark/Market/image49.png;content/bts_spark/Market/image53.png;content/bts_spark/Market/image66.png;content/bts_spark/Market/image69.png;content/bts_spark/Market/market_view.png;content/bts_spark/Market/settings_icon.png;content/bts_spark/Market/time_and_sales.png;content/bts_spark/My-Windows/_index.md;content/bts_spark/My-Windows/image15.png;content/bts_spark/My-Windows/image16.png;content/bts_spark/My-Windows/image37.png;content/bts_spark/Settings/_index.md;content/bts_spark/Settings/image51.png;content/bts_spark/Settings/image9.png;content/bts_spark/Spreader/_index.md;content/bts_spark/Spreader/image10.png;content/bts_spark/Spreader/image13.png;content/bts_spark/Spreader/image18.png;content/bts_spark/Spreader/image19.png;content/bts_spark/Spreader/image28.png;content/bts_spark/Spreader/image29.png;content/bts_spark/Spreader/image31.png;content/bts_spark/Spreader/image35.png;content/bts_spark/Spreader/image40.png;content/bts_spark/Spreader/image43.png;content/bts_spark/Spreader/image54.png;content/bts_spark/Spreader/image55.png;content/bts_spark/Spreader/image56.png;content/bts_spark/Spreader/image6.png;content/bts_spark/Spreader/image7.png;content/bts_spark/Spreader/image70.png;content/bts_spark/Spreader/image72.png;content/bts_spark/Spreader/image8.png;content/bts_spark/Trading/OrderTypes/index.md;content/bts_spark/Trading/_index.md;content/bts_spark/Trading/algo_studio.png;content/bts_spark/Trading/collapse_all_icon.png;content/bts_spark/Trading/cover_algo_control.png;content/bts_spark/Trading/expand_all_icon.png;content/bts_spark/Trading/image1.png;content/bts_spark/Trading/image17.png;content/bts_spark/Trading/image2.png;content/bts_spark/Trading/image25.png;content/bts_spark/Trading/image27.png;content/bts_spark/Trading/image33.png;content/bts_spark/Trading/image42.png;content/bts_spark/Trading/image44.png;content/bts_spark/Trading/image47.png;content/bts_spark/Trading/image48.png;content/bts_spark/Trading/image5.png;content/bts_spark/Trading/image50.png;content/bts_spark/Trading/image52.png;content/bts_spark/Trading/image57.png;content/bts_spark/Trading/image59.png;content/bts_spark/Trading/image60.png;content/bts_spark/Trading/image61.png;content/bts_spark/Trading/image62.png;content/bts_spark/Trading/image73.png;content/bts_spark/Trading/image74.png;content/bts_spark/Trading/join_algo_control.png;content/bts_spark/Trading/ladder.png;content/bts_spark/Trading/ladder_badges.png;content/bts_spark/Trading/ladder_main_part.png;content/bts_spark/Trading/lean_algo_control.png;content/bts_spark/Trading/mini_orderbook.png;content/bts_spark/Trading/oco_algo_control.png;content/bts_spark/Trading/offset_algo_control.png;content/bts_spark/Trading/pnl_calculation.png;content/bts_spark/Trading/pnl_window.png;content/bts_spark/Trading/recreate_icon.png;content/bts_spark/Trading/settings_icon.png;content/bts_spark/Trading/spark_menu_order_book.png;content/bts_spark/Trading/top_algo_control.png;content/bts_spark/Trading/trigger_algo_control.png;content/bts_spark/_index.md;content/release_notes/_index.md;content/system_requirements/_index.md;static/book.js;static/favicon.ico;static/image.js;templates/index.html;templates/page.html;templates/section.html;templates/shortcodes/back_button.html)
set(sources /home/ppinto/Dropbox/bts/spark/doc/user/build.sh;content/_index.md;content/bts_spark/Glossary/_index.md;content/bts_spark/Help/_index.md;content/bts_spark/Help/about_spark.png;content/bts_spark/Help/image39.png;content/bts_spark/Help/image58.png;content/bts_spark/Launcher/_index.md;content/bts_spark/Launcher/image38.png;content/bts_spark/Launcher/image68.png;content/bts_spark/Logging-In-to-the-System/_index.md;content/bts_spark/Logging-In-to-the-System/image3.png;content/bts_spark/Logging-In-to-the-System/image64.png;content/bts_spark/Market/_index.md;content/bts_spark/Market/change_securities.png;content/bts_spark/Market/image11.png;content/bts_spark/Market/image14.png;content/bts_spark/Market/image20.png;content/bts_spark/Market/image21.png;content/bts_spark/Market/image23.png;content/bts_spark/Market/image24.png;content/bts_spark/Market/image34.png;content/bts_spark/Market/image49.png;content/bts_spark/Market/image53.png;content/bts_spark/Market/image66.png;content/bts_spark/Market/image69.png;content/bts_spark/Market/market_view.png;content/bts_spark/Market/settings_icon.png;content/bts_spark/Market/time_and_sales.png;content/bts_spark/My-Windows/_index.md;content/bts_spark/My-Windows/image15.png;content/bts_spark/My-Windows/image16.png;content/bts_spark/My-Windows/image37.png;content/bts_spark/Settings/_index.md;content/bts_spark/Settings/image51.png;content/bts_spark/Settings/image9.png;content/bts_spark/Spreader/_index.md;content/bts_spark/Spreader/image10.png;content/bts_spark/Spreader/image13.png;content/bts_spark/Spreader/image18.png;content/bts_spark/Spreader/image19.png;content/bts_spark/Spreader/image28.png;content/bts_spark/Spreader/image29.png;content/bts_spark/Spreader/image31.png;content/bts_spark/Spreader/image35.png;content/bts_spark/Spreader/image40.png;content/bts_spark/Spreader/image43.png;content/bts_spark/Spreader/image54.png;content/bts_spark/Spreader/image55.png;content/bts_spark/Spreader/image56.png;content/bts_spark/Spreader/image6.png;content/bts_spark/Spreader/image7.png;content/bts_spark/Spreader/image70.png;content/bts_spark/Spreader/image72.png;content/bts_spark/Spreader/image8.png;content/bts_spark/Trading/OrderTypes/index.md;content/bts_spark/Trading/_index.md;content/bts_spark/Trading/algo_studio.png;content/bts_spark/Trading/collapse_all_icon.png;content/bts_spark/Trading/cover_algo_control.png;content/bts_spark/Trading/expand_all_icon.png;content/bts_spark/Trading/image1.png;content/bts_spark/Trading/image17.png;content/bts_spark/Trading/image2.png;content/bts_spark/Trading/image25.png;content/bts_spark/Trading/image27.png;content/bts_spark/Trading/image33.png;content/bts_spark/Trading/image42.png;content/bts_spark/Trading/image44.png;content/bts_spark/Trading/image47.png;content/bts_spark/Trading/image48.png;content/bts_spark/Trading/image5.png;content/bts_spark/Trading/image50.png;content/bts_spark/Trading/image52.png;content/bts_spark/Trading/image57.png;content/bts_spark/Trading/image59.png;content/bts_spark/Trading/image60.png;content/bts_spark/Trading/image61.png;content/bts_spark/Trading/image62.png;content/bts_spark/Trading/image73.png;content/bts_spark/Trading/image74.png;content/bts_spark/Trading/join_algo_control.png;content/bts_spark/Trading/ladder.png;content/bts_spark/Trading/ladder_badges.png;content/bts_spark/Trading/ladder_main_part.png;content/bts_spark/Trading/lean_algo_control.png;content/bts_spark/Trading/mini_orderbook.png;content/bts_spark/Trading/oco_algo_control.png;content/bts_spark/Trading/offset_algo_control.png;content/bts_spark/Trading/pnl_calculation.png;content/bts_spark/Trading/pnl_window.png;content/bts_spark/Trading/recreate_icon.png;content/bts_spark/Trading/settings_icon.png;content/bts_spark/Trading/spark_menu_order_book.png;content/bts_spark/Trading/top_algo_control.png;content/bts_spark/Trading/trigger_algo_control.png;content/bts_spark/_index.md;content/release_notes/_index.md;content/system_requirements/_index.md;static/book.js;static/favicon.ico;static/image.js;templates/index.html;templates/page.html;templates/section.html;templates/shortcodes/back_button.html)
+19 -2
View File
@@ -109,6 +109,22 @@ namespace mbts.spark {
public AccountTuple? get_default_account() =>
_account_map.Select(kv => new AccountTuple(kv.Key, kv.Value)).TryFirst();
public async Task<Result<AdminServiceOperationResult>[]> set_risk_limits(IReadOnlyDictionary<uint, IEnumerable<(uint, RiskLimits)>> state) {
var results = await Task.WhenAll(state.Select(impl));
return results;
async Task<Result<AdminServiceOperationResult>> impl(KeyValuePair<uint, IEnumerable<(uint, RiskLimits)>> kv) {
var prlimits = new ProprietaryRiskLimits();
foreach (var (sec, lim) in kv.Value) {
var api_lim = AccountSecurityRiskLimitsDataHelper.from_client_data(sec, lim);
prlimits.SecurityLimits.Add(api_lim);
}
return await _service.update_proprietary_risk_limits_async(new ProprietaryRiskLimitsAPIArgument {
AccountId = kv.Key,
ProprietaryRiskLimits = prlimits
});
}
}
public Task<(bool success, string error_msg)> add_or_update_risk_limits(uint account_key, IEnumerable<(uint security_key, RiskLimits limits)> new_limits) {
return _modify_risk_limits("Updating Risk Limits", account_key, add_limits);
//
@@ -130,9 +146,10 @@ namespace mbts.spark {
//
ProprietaryRiskLimits remove_secs(ProprietaryRiskLimits prlimits) {
var sec_key_set = new HashSet<uint>(security_keys);
for (int i = 0; i < prlimits.SecurityLimits.Count; i++) {
if (sec_key_set.Contains(prlimits.SecurityLimits[i].SecurityKey))
for (int i = 0; i < prlimits.SecurityLimits.Count;) {
if (sec_key_set.Contains(prlimits.SecurityLimits[i].SecurityKey)) {
prlimits.SecurityLimits.RemoveAt(i);
} else i++;
}
return prlimits;
}
+5 -2
View File
@@ -22,6 +22,9 @@ namespace bts.admin.risk {
public override int GetHashCode() =>
EqualityComparer.auto_phase(security.GetHashCode(), account.GetHashCode());
public static bool operator ==(AccountSecurityKey a, AccountSecurityKey b) => a.Equals(b);
public static bool operator !=(AccountSecurityKey a, AccountSecurityKey b) => !a.Equals(b);
}
readonly struct AccountSecurityRiskLimits : IEquatable<AccountSecurityRiskLimits> {
@@ -138,9 +141,9 @@ namespace bts.admin.risk {
api_data.MinSellPrice,
api_data.MaxBuyPrice));
public static AccountSecurityRiskLimits with(this AccountSecurityRiskLimits cli_data, RiskLimits? limits = null, AccountTuple? account = null, SecurityImmutable? security = null) =>
public static AccountSecurityRiskLimits with(this AccountSecurityRiskLimits cli_data, RiskLimits? limits = null, AccountTuple? account = null, SecurityImmutable? security = null, AccountSecurityKey? key = null) =>
new AccountSecurityRiskLimits(
cli_data.key,
key ?? cli_data.key,
limits ?? cli_data.limits,
account: account ?? new AccountTuple(cli_data.account_key, cli_data.account_name),
security: security ?? cli_data.security);
@@ -114,6 +114,8 @@ namespace bts.shell {
public static QuoteInsideMarketDistanceWithTravel QuoteInsideMarketDistanceWithTravel => new QuoteInsideMarketDistanceWithTravel { Priority = RulePriority };
public static QuoteInsideMarketDistance QuoteInsideMarketDistance => new QuoteInsideMarketDistance { Priority = RulePriority };
public static QuoteInsideMarketDistanceThrottle QuoteInsideMarketDistanceThrottle => new QuoteInsideMarketDistanceThrottle();
public static QuoteTimeBasedThrottle QuoteTimeBasedThrottle => new QuoteTimeBasedThrottle { DelayToImprove = 0, DelayToRun = 0 };
#endregion
#region PreHedge
@@ -10,13 +10,13 @@ namespace mbts.spark {
public override string man_page { get; } = string.Empty;
public override bool get_value(LegSpreaderParamsTuple leg_tup) =>
leg_tup.leg_params.EnableHedging;
leg_tup.leg_params.SendHedge is null || leg_tup.leg_params.SendHedge.Val;
public override void set_value(LegSpreaderParamsTuple leg_tup, bool value) =>
leg_tup.leg_params.EnableHedging = value;
public override bool has_errors(IReadOnlyCollection<LegSpreaderParamsTuple> leg_tups) =>
!leg_tups.Any(lt => lt.leg_params.EnableHedging);
public override void set_value(LegSpreaderParamsTuple leg_tup, bool value) {
if (leg_tup.leg_params.SendHedge is null)
leg_tup.leg_params.SendHedge = new bts.spark.NullableBoolean();
leg_tup.leg_params.SendHedge.Val = value;
}
}
}
}
}
@@ -0,0 +1,21 @@
using mbts.ui.spark;
using System;
namespace mbts.spark {
partial class SyntheticEditorVM {
class LeanOffsetTicksModel : RowModelBase<int> {
public override string display_name { get; } = "Lean Offset Ticks";
public override string help_text { get; } = "Improvement (in ticks) to the lean market";
public override string man_page { get; } = string.Empty;
public override int get_value(LegSpreaderParamsTuple leg_tup) =>
leg_tup.leg_params.QuoteParams?.LeanOffsetTicks ?? 0;
public override void set_value(LegSpreaderParamsTuple leg_tup, int value) {
if (leg_tup.leg_params.QuoteParams is null)
leg_tup.leg_params.QuoteParams = new bts.spark.QuoteParams();
leg_tup.leg_params.QuoteParams.LeanOffsetTicks = value;
}
}
}
}
@@ -0,0 +1,40 @@
using bts.shell;
using bts.spark;
using mbts.ui.spark;
using System.Collections.Generic;
namespace mbts.spark {
partial class SyntheticEditorVM {
class QuoteTimeThrottleDelayToImproveModel : RowModelBase<uint> {
readonly IDictionary<int, uint> _value_store = new Dictionary<int, uint>();
public override string display_name { get; } = "Delay to Improve (ms)";
public override string help_text { get; } = string.Empty;
public override string man_page { get; } = string.Empty;
public override ParameterSection[] section_path { get; } = new[] { Sections.Quote, Subsections.TimeThrottle };
public void apply_value(LegSpreaderParamsTuple leg_tup) =>
_get_throttle(leg_tup).DelayToImprove = _value_from_store(leg_tup);
public override uint get_value(LegSpreaderParamsTuple leg_tup) =>
_get_throttle(leg_tup) is QuoteTimeBasedThrottle throttle ?
throttle.DelayToImprove :
_value_from_store(leg_tup);
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) {
_value_store[leg_tup.id] = value;
if (_get_throttle(leg_tup) is QuoteTimeBasedThrottle throttle)
throttle.DelayToImprove = value;
}
protected override bool _get_enabled(LegSpreaderParamsTuple leg_tup) =>
_get_throttle(leg_tup) != null;
QuoteTimeBasedThrottle _get_throttle(LegSpreaderParamsTuple leg_tup) =>
leg_tup.leg_params.QuoteParams.TimeBasedThrottle;
uint _value_from_store(LegSpreaderParamsTuple leg_tup) =>
_value_store.GetValueOrDefault(leg_tup.id, _ => SyntheticDataHelper.Defaults.QuoteTimeBasedThrottle.DelayToImprove);
}
}
}
@@ -0,0 +1,40 @@
using bts.shell;
using bts.spark;
using mbts.ui.spark;
using System.Collections.Generic;
namespace mbts.spark {
partial class SyntheticEditorVM {
class QuoteTimeThrottleDelayToRunModel : RowModelBase<uint> {
readonly IDictionary<int, uint> _value_store = new Dictionary<int, uint>();
public override string display_name { get; } = "Delay To Run (ms)";
public override string help_text { get; } = string.Empty;
public override string man_page { get; } = string.Empty;
public override ParameterSection[] section_path { get; } = new[] { Sections.Quote, Subsections.TimeThrottle };
public void apply_value(LegSpreaderParamsTuple leg_tup) =>
_get_throttle(leg_tup).DelayToRun = _value_from_store(leg_tup);
public override uint get_value(LegSpreaderParamsTuple leg_tup) =>
_get_throttle(leg_tup) is QuoteTimeBasedThrottle throttle ?
throttle.DelayToRun :
_value_from_store(leg_tup);
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) {
_value_store[leg_tup.id] = value;
if (_get_throttle(leg_tup) is QuoteTimeBasedThrottle throttle)
throttle.DelayToRun = value;
}
protected override bool _get_enabled(LegSpreaderParamsTuple leg_tup) =>
_get_throttle(leg_tup) != null;
QuoteTimeBasedThrottle _get_throttle(LegSpreaderParamsTuple leg_tup) =>
leg_tup.leg_params.QuoteParams.TimeBasedThrottle;
uint _value_from_store(LegSpreaderParamsTuple leg_tup) =>
_value_store.GetValueOrDefault(leg_tup.id, _ => SyntheticDataHelper.Defaults.QuoteTimeBasedThrottle.DelayToRun);
}
}
}
@@ -0,0 +1,38 @@
using bts.shell;
using mbts.ui.spark;
namespace mbts.spark {
partial class SyntheticEditorVM {
class QuoteTimeThrottleEnabledModel : RowModelBase<bool> {
readonly QuoteTimeThrottleDelayToRunModel _delay_to_run;
readonly QuoteTimeThrottleDelayToImproveModel _delay_to_improve;
public QuoteTimeThrottleEnabledModel(QuoteTimeThrottleDelayToRunModel delay_to_run, QuoteTimeThrottleDelayToImproveModel delay_to_improve) {
_delay_to_run = delay_to_run;
_delay_to_improve = delay_to_improve;
}
public override string display_name { get; } = string.Empty;
public override string help_text { get; } = string.Empty;
public override string man_page { get; } = string.Empty;
public override ParameterSection[] section_path { get; } = new[] { Sections.Quote, Subsections.TimeThrottle };
public override bool get_value(LegSpreaderParamsTuple leg_tup) =>
leg_tup.leg_params.QuoteParams.TimeBasedThrottle != null;
public override void set_value(LegSpreaderParamsTuple leg_tup, bool value) {
if (value) {
if (leg_tup.leg_params.QuoteParams.TimeBasedThrottle == null) {
leg_tup.leg_params.QuoteParams.TimeBasedThrottle = SyntheticDataHelper.Defaults.QuoteTimeBasedThrottle;
_delay_to_run.apply_value(leg_tup);
_delay_to_improve.apply_value(leg_tup);
}
} else {
leg_tup.leg_params.QuoteParams.TimeBasedThrottle = null;
}
_delay_to_run.set_enabled(leg_tup, value);
_delay_to_improve.set_enabled(leg_tup, value);
}
}
}
}
@@ -108,6 +108,10 @@ namespace mbts.spark {
"Reduces re-quoting updates by defining a region on either side " +
"of the working quoting order, inside which quote updates will not be sent.");
public static ParameterSection TimeThrottle =>
new ParameterSection("Time Throttle", true,
"Reduces re-quoting updates by requiring a minimum amount of time to elapse between quotes.");
public static ParameterSection Conditional =>
new ParameterSection("Conditional", true,
"Reduces re-quoting updates by only quoting if N ticks away from the opposite " +
@@ -196,6 +196,9 @@ namespace mbts.spark {
var quote_throttle_outside_ticks = new QuoteThrottleOutsideTicksModel();
var quote_throttle_inside_ticks = new QuoteThrottleInsideTicksModel();
var quote_time_throttle_delay_to_run = new QuoteTimeThrottleDelayToRunModel();
var quote_time_throttle_delay_to_improve = new QuoteTimeThrottleDelayToImproveModel();
var conditional_quoting_ticks = new ConditionalQuotingTicksModel();
var conditional_quoting_price_type = new ConditionalQuotingPriceTypeModel();
@@ -223,17 +226,24 @@ namespace mbts.spark {
_quantity_model,
_price_mult_model,
is_quote_model,
//new EnableHedgeModel(), //TAHA_SPREADER
new EnableHedgeModel(), //TAHA_SPREADER
new HedgeRatioModel(),
//new MinLeanQtyModel(), //TAHA_SPREADER
new LeanOffsetTicksModel(),
//new QuoteHiddenModel(),
new QuoteQueueHolderModel(),
new MarketDataTypeModel(),
new ShowQuantityEnabledModel(show_quantity_quantity),
show_quantity_quantity,
// Throttle
new QuoteThrottleEnabledModel(quote_throttle_inside_ticks, quote_throttle_outside_ticks),
quote_throttle_inside_ticks,
quote_throttle_outside_ticks,
// Time Throttle
new QuoteTimeThrottleEnabledModel(quote_time_throttle_delay_to_run, quote_time_throttle_delay_to_improve),
quote_time_throttle_delay_to_run,
quote_time_throttle_delay_to_improve,
new ConditionalQuoteEnabledModel(conditional_quoting_ticks, conditional_quoting_price_type),
conditional_quoting_ticks,
//conditional_quoting_price_type,
@@ -6,6 +6,7 @@ using bts.utils;
using mbts.ui;
using mbts.ui.settings;
using mbts.ui.spark;
using mbts.ui.utility.text;
using ProtoBuf;
using System;
using System.Collections.Generic;
@@ -13,6 +14,7 @@ using System.Collections.Immutable;
using System.ComponentModel;
using System.Linq;
using System.Windows;
using System.Windows.Media;
namespace mbts.spark {
// IMPORTANT: BE SURE TO ADD ANY NEW PROPERTIES TO THE EQUALS FUNCTION!
@@ -166,6 +168,10 @@ namespace mbts.spark {
[ProtoContract]
class LadderMarketBreakLine : IEquatable<LadderMarketBreakLine> {
public enum RefreshMode {
Auto,
Manual
}
// this class is 100% mutable (there are literally 0 readonly members),
// so GetHashCode must return the same hash for every instance.
static readonly int _type_hash = typeof(LadderMarketBreakLine).GetHashCode();
@@ -173,6 +179,8 @@ namespace mbts.spark {
public bool show { get; set; }
[ProtoMember(2)]
public uint color { get; set; }
[ProtoMember(3)]
public RefreshMode refresh_mode { get; set; }
public uint? color_nullable {
get {
@@ -185,7 +193,8 @@ namespace mbts.spark {
public bool Equals(LadderMarketBreakLine other) =>
other != null &&
other.show == show &&
other.color == color;
other.color == color &&
other.refresh_mode == refresh_mode;
public override bool Equals(object obj) =>
Equals(obj as LadderMarketBreakLine);
@@ -317,6 +326,127 @@ namespace mbts.spark {
public static bool operator !=(LadderMiniOrderBookSettings a, LadderMiniOrderBookSettings b) => !a.Equals(b);
}
[ProtoContract]
class LadderPanelPricePointSettings : IEquatable<LadderPanelPricePointSettings> {
public static LadderPanelPricePointSettings Default =>
new LadderPanelPricePointSettings {
day_change = new DaySettings {
// (neutral)
font = _default_font,
background_color = Colors.Transparent.rgb_color(),
// negative
negative_font_color = Colors.White.rgb_color(),
negative_background_color = Colors.Red.rgb_color(),
// positive
positive_font_color = Colors.White.rgb_color(),
positive_background_color = Colors.Green.rgb_color()
},
session_low = _default_item,
session_high = _default_item,
open = _default_item,
settlement = _default_item,
volume = _default_item
};
[ProtoMember(1)]
public DaySettings day_change { get; set; }
[ProtoMember(2)]
public ItemSettings session_low { get; set; }
[ProtoMember(3)]
public ItemSettings session_high { get; set; }
[ProtoMember(4)]
public ItemSettings open { get; set; }
[ProtoMember(5)]
public ItemSettings settlement { get; set; }
[ProtoMember(6)]
public ItemSettings volume { get; set; }
public bool Equals(LadderPanelPricePointSettings other) =>
other != null &&
day_change.safe_equals(other.day_change) &&
session_high.safe_equals(other.session_high) &&
session_high.safe_equals(other.session_high) &&
open.safe_equals(other.open) &&
settlement.safe_equals(other.settlement) &&
volume.safe_equals(other.volume);
static FontParamsProto _default_font =>
new FontParamsProto {
font_color = Colors.Black.rgb_color(),
font_size = FontSizes.Regular,
typeface = new TypefaceProto(TextUtils.StandardFontFamilyName, FontWeights.Bold.ToOpenTypeWeight())
};
static ItemSettings _default_item =>
new ItemSettings {
font = _default_font,
background_color = Colors.Transparent.rgb_color()
};
[ProtoContract]
readonly struct SignedColorPair : IEquatable<SignedColorPair> {
[ProtoMember(1)]
public uint positive_color { get; }
[ProtoMember(2)]
public uint negative_color { get; }
public bool Equals(SignedColorPair other) =>
positive_color == other.positive_color &&
negative_color == other.negative_color;
}
[ProtoContract]
public class ItemSettings : IEquatable<ItemSettings> {
[ProtoMember(1)]
public FontParamsProto font { get; set; }
[ProtoMember(2)]
public uint background_color { get; set; }
[ProtoMember(3)]
public bool show_label { get; set; }
public bool Equals(ItemSettings other) =>
other != null &&
font.safe_equals(other.font) &&
background_color == other.background_color &&
show_label == other.show_label;
}
[ProtoContract]
public class DaySettings : IEquatable<DaySettings> {
[ProtoMember(1)]
public FontParamsProto font { get; set; }
// [neutral] background
[ProtoMember(2)]
public uint background_color { get; set; }
[ProtoMember(3)]
public bool show_label { get; set; }
// negative
[ProtoMember(4)]
public uint negative_font_color { get; set; }
[ProtoMember(5)]
public uint negative_background_color { get; set; }
// positive
[ProtoMember(6)]
public uint positive_font_color { get; set; }
[ProtoMember(7)]
public uint positive_background_color { get; set; }
public uint neutral_foreground => font?.font_color ?? 0;
public bool Equals(DaySettings other) =>
other != null &&
font.safe_equals(other.font) &&
background_color == other.background_color &&
show_label == other.show_label &&
negative_font_color == other.negative_font_color &&
negative_background_color == other.negative_background_color &&
positive_font_color == other.positive_font_color &&
positive_background_color == other.positive_background_color;
}
}
// IMPORTANT: BE SURE TO ADD ANY NEW PROPERTIES TO THE EQUALS FUNCTION!
// 1 important reason at this time:
// From the settings dialog, default settings will only be persisted when they are NOT EQUAL to the current default settings.
@@ -334,6 +464,7 @@ namespace mbts.spark {
// this class is 100% mutable (there are literally 0 readonly members),
// so GetHashCode must return the same hash for every instance.
static readonly int _type_hash = typeof(LadderSettings).GetHashCode();
uint _ticks_per_row;
// Default proto constructor
// Added this so that when clients upgrade to a version with new settings,
@@ -425,6 +556,7 @@ namespace mbts.spark {
auto_clear_visible = true,
clear_visible = true,
order_entry_panel_initial_width = _default_order_entry_panel_width,
panel_price_point_settings = LadderPanelPricePointSettings.Default,
zoom_slider_visible = false,
zoom_factor = _default_zoom_factor,
net_change = NetChangeTerms.None,
@@ -603,8 +735,16 @@ namespace mbts.spark {
[ProtoMember(61), DefaultValue(true)]
public bool status_message_visible { get; set; }
[ProtoMember(62)]
public uint ticks_per_row {
get => Math.Max(_ticks_per_row, 1);
set => _ticks_per_row = value;
}
[ProtoMember(900)]
public LadderOrderLimits ladder_order_limits { get; set; }
[ProtoMember(901)]
public LadderPanelPricePointSettings panel_price_point_settings { get; set; }
public void sanitize() =>
sanitize(this);
@@ -639,6 +779,8 @@ namespace mbts.spark {
s.mini_ob = new LadderMiniOrderBookSettings(s.mini_ob.value.with(sorting_criterion: bts.shell.orderbook.OrderBookStartupData.default_mini_grid.general.sorting_criterion));
#pragma warning restore CS0612 // Type or member is obsolete
s.row_height = LadderRender.measure_row_height(s);
if (s.panel_price_point_settings is null)
s.panel_price_point_settings = LadderPanelPricePointSettings.Default;
return s;
}
@@ -712,7 +854,9 @@ namespace mbts.spark {
a.max_clip == b.max_clip &&
a.price_display_format == b.price_display_format &&
a.status_message_visible == b.status_message_visible &&
a.ladder_order_limits.safe_equals(b.ladder_order_limits);
a.ladder_order_limits.safe_equals(b.ladder_order_limits) &&
a.panel_price_point_settings.safe_equals(b.panel_price_point_settings) &&
a._ticks_per_row == b._ticks_per_row;
public bool Equals(LadderSettings other) =>
profile_equals(this, other) &&
@@ -1,13 +1,16 @@
using bts.api;
using bts.api.orderman;
using bts.shell.orderbook;
using bts.utils;
using mbts.persist;
using mbts.spark.utilities;
using mbts.ui;
using mbts.ui.shell;
using mbts.ui.spark;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
@@ -52,9 +55,9 @@ namespace mbts.spark {
public event Action piq_changed;
LadderModel model => _owner.model;
Dictionary<uint, (OrderRecordImmutable order, uint? p, AlgoData? algo, AlgoDefinitionMetadata? meta)> _orders = new Dictionary<uint, (OrderRecordImmutable order, uint? p, AlgoData? algo, AlgoDefinitionMetadata? meta)>();
ImmutableDictionary<uint, OrderSecurity> _orders = ImmutableDictionary<uint, OrderSecurity>.Empty;
public LadderOrderVM((OrderRecordImmutable, uint?, AlgoData?, AlgoDefinitionMetadata?) op, double real_price, LadderVM owner, IBus bus, IObservable<LadderSettings.BadgeStyle> bs) {
public LadderOrderVM(ImmutableDictionary<uint, OrderSecurity> orders, double real_price, LadderVM owner, IBus bus, IObservable<LadderSettings.BadgeStyle> bs) {
_owner = owner;
_bus = bus;
_bs = bs;
@@ -78,8 +81,7 @@ namespace mbts.spark {
double get_font_size(LadderSettings s) => s.orders_column.font_size;
Brush get_foreground(LadderSettings s) => s.orders_column.foreground.rgb_brush();
double get_row_height(LadderSettings s) => s.row_height;
//
add_order(op);
_orders = orders;
_dispose = Disposable.Create(
_bs.Subscribe(badge => {
@@ -175,41 +177,6 @@ namespace mbts.spark {
RaisePropertyChanged(nameof(text_lines));
}
/// <summary>
/// Add Order performs an add the first time it's called via the constructor. When it's called, directly
/// it really serves as an update/replace. Also note that since the min_piq is a separate piece of state representing
/// the lowest piq of the orders the badge represents, we must reevaluate if that has changed on said update.
/// </summary>
public void add_order((OrderRecordImmutable order, uint? p, AlgoData? algo, AlgoDefinitionMetadata? meta) new_op) {
_orders[new_op.order.Key] = new_op;
// reevaluate min piq if this order's piq is less
if (new_op.p.HasValue) {
// if this lovm only represents 1 order and the piq is now different, regardless of what it is that's our piq
if (_orders.Count == 1 && new_op.p.Value != min_piq) {
min_piq = new_op.p.Value;
} else if (new_op.p.Value < min_piq) {
min_piq = new_op.p.Value;
}
}
}
public void remove_order(uint order_key) {
_orders.Remove(order_key);
// on a remove, potentially the order w/ the lowest piq has been removed, so
// if the min() is now > than the current min_piq, update the min_piq
var prospective_piq = _orders.Select(op => op.Value.p).Where(piq => piq.HasValue).Min();
if (prospective_piq > min_piq) {
min_piq = prospective_piq;
}
}
//public void update(OrderRecordImmutable neworder) {
// Log.assert(neworder.Key == id, $"OrderVM.update was called with an order with a different Key({neworder.Key}) from original({id})");
// using (detect_property_changes()) {
// _init(neworder);
// }
//}
public uint security_key => _owner.security.Id;
public double price { get => double.IsNaN(_phantom_price) ? _real_price : _phantom_price; }
public uint? min_piq {
@@ -261,9 +228,13 @@ namespace mbts.spark {
public CustomOrderDefinition.CustomOneofCase algo_type { get => _algo_type.Value; private set => _algo_type.Value = value; }
public string algo_studio_abbreviation { get => _algo_studio_abbreviation.Value; private set => _algo_studio_abbreviation.Value = value; }
public IReadOnlyList<uint> order_keys => _orders.Keys.ToReadOnlyList();
public IEnumerable<OrderRecordImmutable> root_orders => _root_nodes();
public void sync_orders(ImmutableDictionary<uint, OrderSecurity> new_orders) {
_orders = new_orders;
min_piq = new_orders.Count == 0 ? null : new_orders.Values.Select(o => o.piq).Min();
}
void _cancel_order() {
foreach (var order in _root_nodes()) {
model.order_gateway.cancel_order(order).ignore();
@@ -296,14 +267,16 @@ namespace mbts.spark {
// I checked with Eric and he guesses that what is happening is that the Popup is throwing away the grid, but the binding doesn't remove the columns from that grid
//
// I think returning a new OrderbookVM is okay at the moment since this Popup window will not be saving any state at this time
var price_filter = new filters.DoubleMinMaxState();
price_filter.minimum.value = real_price;
price_filter.maximum.value = real_price;
var ticks = _owner.spec.full_ticks_from_zero(real_price);
if (!ticks.HasValue) {
// this is an unexpected code path, but not necessarily a reason to crash, so log a warning and return null
return null;
}
var min_price = _owner.spec.tickup(0, ticks.Value);
var max_price = _owner.spec.tickup(min_price, 1);
var state = new bts.shell.orderbook.OrderBookStartupData(
new bts.shell.orderbook.FilterStates {
security_criteria = SecurityCriteria.from_securities(_owner.security),
price = price_filter,
statuses = new[] { OrderStatus.Working },
order_types = AlgoID.exchange_algo_keys
},
@@ -311,7 +284,8 @@ namespace mbts.spark {
use_defaults: false
);
var settings_man = new WindowSettingsManager<OrderBookGridSettings>.DisconnectedImpl(state.orderbook_grid);
var obvm = new OrderBookVM(_owner.bus, null, _owner.model.order_gateway, settings_man, true);
var obvm = new OrderBookVM(_owner.bus, null, _owner.model.order_gateway, settings_man, true,
global_filter: o => o.order.order.ui_price() >= min_price - MathUtils.epsilon && o.order.order.ui_price() <= max_price - MathUtils.epsilon);
_owner.settings.Subscribe(s => settings_man.instance_settings = settings_man.instance_settings.with(s.mini_ob.value));
obvm.columns.Insert(0, new OrderBookVM.AttachDetachColumn(typeof(MiniOrderBookView)));
obvm.columns.Insert(0, new OrderBookVM.CommitColumn());
@@ -0,0 +1,116 @@
using bts.proto;
using mbts.ui;
using mbts.ui.shell;
using System.Windows;
using System.Windows.Media;
using mbts.ui.utility.text;
using FontFamily = System.Windows.Media.FontFamily;
namespace mbts.spark {
class LadderPanelPricePointVM : ViewModelBase, IValueFactoryVM<LadderPanelPricePointSettings.ItemSettings> {
Color _background_color = Colors.Transparent, _font_color = Colors.Black;
FontFamily _font_family = TextUtils.StandardFontFamily;
double _font_size = FontSizes.Small;
FontWeight _font_weight = FontWeights.Bold;
bool _show = true, _show_label = true;
public Color background_color { get => _background_color; set => Set(ref _background_color, value); }
public Color font_color { get => _font_color; set => Set(ref _font_color, value); }
public FontFamily font_family { get => _font_family; set => Set(ref _font_family, value); }
public double font_size { get => _font_size; set => Set(ref _font_size, value); }
public FontWeight font_weight { get => _font_weight; set => Set(ref _font_weight, value); }
public bool show {
get => _show;
set {
if (Set(ref _show, value))
RaisePropertyChanged(nameof(actual_show_label));
}
}
public bool show_label {
get => _show_label;
set {
if (Set(ref _show_label, value))
RaisePropertyChanged(nameof(actual_show_label));
}
}
public bool actual_show_label => _show && _show_label;
public LadderPanelPricePointSettings.ItemSettings create() =>
new LadderPanelPricePointSettings.ItemSettings {
font = new FontParamsProto {
font_color = font_color.rgb_color(),
font_size = font_size,
typeface = new TypefaceProto(font_family.name_or_default(), font_weight.ToOpenTypeWeight())
},
background_color = background_color.rgb_color(),
show_label = show_label
};
public void load_from(LadderPanelPricePointSettings.ItemSettings value) {
if (value is null)
return;
load_from(value.font);
show_label = value.show_label;
background_color = value.background_color.argb_color();
}
protected void load_from(FontParamsProto font) {
if (font is null) {
font_weight = FontWeights.Bold;
font_size = FontSizes.Small;
show_label = true;
} else {
font_family = string.IsNullOrEmpty(font.font_family) ?
TextUtils.StandardFontFamily :
new FontFamily(font.font_family);
font_weight = FontWeight.FromOpenTypeWeight(font.font_weight);
font_size = font.font_size;
font_color = font.font_color.argb_color();
}
}
}
class LadderPanelRelativePricePointVM : LadderPanelPricePointVM, IValueFactoryVM<LadderPanelPricePointSettings.DaySettings> {
Color
_negative_font_color = Colors.Red,
_negative_background_color = Colors.Transparent,
_positive_font_color = Colors.Green,
_positive_background_color = Colors.Transparent;
// negative
public Color negative_font_color { get => _negative_font_color; set => Set(ref _negative_font_color, value); }
public Color negative_background_color { get => _negative_background_color; set => Set(ref _negative_background_color, value); }
// positive
public Color positive_font_color { get => _positive_font_color; set => Set(ref _positive_font_color, value); }
public Color positive_background_color { get => _positive_background_color; set => Set(ref _positive_background_color, value); }
public void load_from(LadderPanelPricePointSettings.DaySettings value) {
if (value is null)
return;
load_from(value.font);
show_label = value.show_label;
background_color = value.background_color.argb_color();
// negative
negative_font_color = value.negative_font_color.argb_color();
negative_background_color = value.negative_background_color.argb_color();
// positive
positive_font_color = value.positive_font_color.argb_color();
positive_background_color = value.positive_background_color.argb_color();
}
public new LadderPanelPricePointSettings.DaySettings create() {
var base_settings = base.create();
return new LadderPanelPricePointSettings.DaySettings {
font = base_settings.font,
show_label = base_settings.show_label,
background_color = base_settings.background_color,
// negative
negative_font_color = negative_font_color.rgb_color(),
negative_background_color = negative_background_color.rgb_color(),
// positive
positive_font_color = positive_font_color.rgb_color(),
positive_background_color = positive_background_color.rgb_color()
};
}
}
}
@@ -16,6 +16,7 @@ using mbts.ui.spark;
using mbts.ui.utility;
using mbts.utils;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Collections.ObjectModel;
@@ -31,6 +32,10 @@ using TextUtils = mbts.ui.utility.text.TextUtils;
namespace mbts.spark {
class LadderSettingsVM : DisposableViewModelBase, IWindowSettingsVM<LadderSettings>, IValueFactory<LadderSettings>, IObservable<LadderSettings>, ITemplateSelectorKey {
public static Type PanelPricePointType => typeof(PanelPricePointVM);
public static Type PanelRelativePricePointType => typeof(PanelRelativePricePointVM);
public static Type PanelVisibilityType => typeof(OrderEntryPanelItemVisibilityVM);
readonly Property<LadderSettings.BadgeStyle> _badge_style;
readonly Property<uint> _alternate_order_size, _max_clip;
readonly DelegateProperty<double> _row_height;
@@ -40,6 +45,7 @@ namespace mbts.spark {
readonly ObservableKeyedCollection<AccountTuple?, uint> _accounts = new ObservableKeyedCollection<AccountTuple?, uint>(AccountTuple.nullable_key_fn);
readonly ObservableKeyedCollection<AlgoDefinitionVM, AlgoKey> _algo_definitions = new ObservableKeyedCollection<AlgoDefinitionVM, AlgoKey>(d => d.key);
readonly OrdersModel _model;
readonly SecurityImmutable _security;
uint? _desired_account;
AlgoID? _desired_algo;
TimeInForce _default_time_in_force;
@@ -48,6 +54,7 @@ namespace mbts.spark {
double _order_entry_panel_width, _zoom_factor;
bool _auto_clear, _show_warn_on_cross, _enforce_max_clip, _enforce_max_settlement_cross_ticks;
int _max_settlement_cross_ticks;
uint _ticks_per_row;
LadderSettings _current;
LadderColumnSettingsVM
_orders = new OrdersColumnSettingsVM(),
@@ -61,17 +68,11 @@ namespace mbts.spark {
_bid_mkt_line = new LadderMarketBreakLineVM("Bid"),
_ask_mkt_line = new LadderMarketBreakLineVM("Ask"),
_mid_mkt_line = new LadderMarketBreakLineVM("Mid"),
_session_low_mkt_line = new LadderMarketBreakLineVM("Session Low", 2, 1),
_session_high_mkt_line = new LadderMarketBreakLineVM("Session High", 2, 1, false),
_session_range_fill = new LadderMarketBreakLineVM("Session Range", 0, 0, false);
_session_low_mkt_line = new LadderMarketBreakLineVM("Session Low", 2, 1, can_edit_refresh_mode: false),
_session_high_mkt_line = new LadderMarketBreakLineVM("Session High", 2, 1, false, can_edit_refresh_mode: false),
_session_range_fill = new LadderMarketBreakLineVM("Session Range", 0, 0, false, can_edit_refresh_mode: false);
OrderEntryPanelItemVisibilityVM
_zoom_slider_visbility = new OrderEntryPanelItemVisibilityVM("Zoom Slider"),
_day_visibility = new OrderEntryPanelItemVisibilityVM("Day Change"),
_high_visibility = new OrderEntryPanelItemVisibilityVM("High"),
_low_visibility = new OrderEntryPanelItemVisibilityVM("Low"),
_open_visibility = new OrderEntryPanelItemVisibilityVM("Open"),
_settle_visibility = new OrderEntryPanelItemVisibilityVM("Settle"),
_volume_visibility = new OrderEntryPanelItemVisibilityVM("Volume"),
_account_visibility = new OrderEntryPanelItemVisibilityVM("Account"),
_tif_visibility = new OrderEntryPanelItemVisibilityVM("Time In Force"),
_order_type_visibility = new OrderEntryPanelItemVisibilityVM("Order Type"),
@@ -85,10 +86,18 @@ namespace mbts.spark {
_cancel_sells_visibility = new OrderEntryPanelItemVisibilityVM("Cancel Sells"),
_cancel_all_visibility = new OrderEntryPanelItemVisibilityVM("Cancel All"),
_status_message_visibility = new OrderEntryPanelItemVisibilityVM("Status Message");
PanelRelativePricePointVM
_day_change = new PanelRelativePricePointVM("Day Change");
PanelPricePointVM
_session_high = new PanelPricePointVM("High"),
_session_low = new PanelPricePointVM("Low"),
_open = new PanelPricePointVM("Open"),
_settlement = new PanelPricePointVM("Settle"),
_volume_panel_item = new PanelPricePointVM("Volume");
public LadderSettingsVM(OrdersModel model, SecurityImmutable security) {
_model = model;
is_synthetic = security.ContractCase == Security.ContractOneofCase.Synthetic;
_security = security;
favorite_algos_vm = new FavoriteAlgosVM(_algo_definitions);
size_presets = new ObservableEditableCollection<IMutableValueWrapperVM<uint>>(_create_size_preset_vm);
size_presets.CollectionChanged += (s, e) => RaisePropertyChanged(nameof(size_presets_text));
@@ -110,6 +119,9 @@ namespace mbts.spark {
accounts_view = new ListCollectionView<AccountTuple?>(_accounts) {
CustomSort = Comparer<AccountTuple>.Default.to_nullable().to_non_generic()
};
// cmds
tick_up_ticks_per_row_cmd = new DelegateCommand(increment_ticks_per_row);
tick_down_ticks_per_row_cmd = new DelegateCommand(decrement_ticks_per_row);
// update
_update = new DeferrableActionWrapper(() => result_changed?.Invoke());
mini_ob.result_changed += _update.execute;
@@ -155,6 +167,26 @@ namespace mbts.spark {
}
AccountTuple? account_factory(uint key, string name) => new AccountTuple(key, name);
AlgoDefinitionVM algo_factory(AlgoData data) => AlgoDefinitionVM.create(_model, data);
void increment_ticks_per_row() {
var tpr = ticks_per_row;
for (uint i = 1; i < 100; i++) {
var new_tpr = TickUtils.fit_ticks_per_row_to_dollars(security.ContractSpec, ticks_per_row + i);
if (new_tpr != tpr) {
ticks_per_row = new_tpr;
break;
}
}
}
void decrement_ticks_per_row() {
var tpr = ticks_per_row;
for (uint i = 1; i < tpr; i++) {
var new_tpr = TickUtils.fit_ticks_per_row_to_dollars(security.ContractSpec, tpr - i);
if (new_tpr != tpr) {
ticks_per_row = new_tpr;
break;
}
}
}
}
public event Action result_changed;
@@ -177,6 +209,16 @@ namespace mbts.spark {
get => _alternate_order_size.Value;
set => _alternate_order_size.Value = value;
}
public uint ticks_per_row {
get => _ticks_per_row;
set => Set(ref _ticks_per_row, value, dependent_props: nameof(rounded_ticks_per_row));
}
public ICommand tick_up_ticks_per_row_cmd { get; }
public ICommand tick_down_ticks_per_row_cmd { get; }
// since settings profiles may be shared among ladders
// of different securities/tick sizes, the ticks per row setting
// may need to be rounded to a number that is a factor of $1.00
public uint? rounded_ticks_per_row => TickUtils.fit_ticks_per_row_to_dollars(_security.ContractSpec, ticks_per_row);
public MarketSizeDisplayVM size_display { get; } = new MarketSizeDisplayVM();
public SimpleGridSettingsVM mini_ob { get; } = new SimpleGridSettingsVM(OrderBookGridSettingsManager.hard_column_flags);
@@ -209,7 +251,7 @@ namespace mbts.spark {
public FavoriteAlgosVM favorite_algos_vm { get; }
public double row_height => _row_height.Value;
public bool is_synthetic { get; }
public bool is_synthetic => _security.ContractCase == Security.ContractOneofCase.Synthetic;
public IEnumerable<LadderColumnSettingsVM> column_items {
get {
@@ -248,15 +290,15 @@ namespace mbts.spark {
}
}
public IEnumerable<OrderEntryPanelItemVisibilityVM> order_entry_panel_items {
public IEnumerable order_entry_panel_items {
get {
yield return _zoom_slider_visbility;
yield return _day_visibility;
yield return _high_visibility;
yield return _low_visibility;
yield return _open_visibility;
yield return _settle_visibility;
yield return _volume_visibility;
yield return _day_change;
yield return _session_high;
yield return _session_low;
yield return _open;
yield return _settlement;
yield return _volume_panel_item;
yield return _account_visibility;
yield return _tif_visibility;
yield return _order_type_visibility;
@@ -295,12 +337,12 @@ namespace mbts.spark {
yield return _session_range_fill;
// left panel
yield return _zoom_slider_visbility;
yield return _day_visibility;
yield return _high_visibility;
yield return _low_visibility;
yield return _open_visibility;
yield return _settle_visibility;
yield return _volume_visibility;
yield return _day_change;
yield return _session_high;
yield return _session_low;
yield return _open;
yield return _settlement;
yield return _volume_panel_item;
yield return _account_visibility;
yield return _tif_visibility;
yield return _order_type_visibility;
@@ -326,6 +368,7 @@ namespace mbts.spark {
_current = settings;
badge_style = settings.badge_style;
alternate_order_size = settings.alternate_order_size;
ticks_per_row = settings.ticks_per_row;
favorite_algos_vm.load_from(settings.favorite_algos);
size_display.load_from(settings.size_display);
size_presets.SetItems(settings.calculator_buttons.empty_if_null().Select(s => _create_size_preset_vm((uint)s)));
@@ -359,12 +402,18 @@ namespace mbts.spark {
zoom_factor = settings.zoom_factor;
// left-panel (show/hide)
_zoom_slider_visbility.show = settings.zoom_slider_visible;
_day_visibility.show = settings.day_visible;
_high_visibility.show = settings.high_visible;
_low_visibility.show = settings.low_visible;
_open_visibility.show = settings.open_visible;
_settle_visibility.show = settings.settle_visible;
_volume_visibility.show = settings.volume_visible;
_day_change.show = settings.day_visible;
_day_change.load_from(settings.panel_price_point_settings.day_change);
_session_high.show = settings.high_visible;
_session_high.load_from(settings.panel_price_point_settings.session_high);
_session_low.show = settings.low_visible;
_session_low.load_from(settings.panel_price_point_settings.session_low);
_open.show = settings.open_visible;
_open.load_from(settings.panel_price_point_settings.open);
_settlement.show = settings.settle_visible;
_settlement.load_from(settings.panel_price_point_settings.settlement);
_volume_panel_item.show = settings.volume_visible;
_volume_panel_item.load_from(settings.panel_price_point_settings.volume);
_account_visibility.show = settings.account_visible;
_tif_visibility.show = settings.tif_visible;
_order_type_visibility.show = settings.order_type_visible;
@@ -407,6 +456,7 @@ namespace mbts.spark {
}
clone.badge_style = badge_style;
clone.alternate_order_size = alternate_order_size;
clone.ticks_per_row = ticks_per_row;
clone.favorite_algos = favorite_algos_vm.create();
clone.size_display = size_display.create();
clone.calculator_buttons = size_presets.Select(vm => (int)vm.value).ToArray();
@@ -426,6 +476,15 @@ namespace mbts.spark {
clone.session_low_line = _session_low_mkt_line.get_settings();
clone.session_high_line = _session_high_mkt_line.get_settings();
clone.session_range_fill = _session_range_fill.get_settings();
// left-panel price items
clone.panel_price_point_settings = new LadderPanelPricePointSettings {
day_change = _day_change.create(),
open = _open.create(),
session_low = _session_low.create(),
session_high = _session_high.create(),
volume = _volume_panel_item.create(),
settlement = _settlement.create(),
};
// left-panel (defaults)
clone.default_time_in_force = default_time_in_force;
// - account
@@ -440,12 +499,12 @@ namespace mbts.spark {
clone.order_entry_panel_initial_width = _order_entry_panel_width;
clone.zoom_factor = zoom_factor;
// left-panel (components)
clone.day_visible = _day_visibility.show;
clone.high_visible = _high_visibility.show;
clone.low_visible = _low_visibility.show;
clone.open_visible = _open_visibility.show;
clone.settle_visible = _settle_visibility.show;
clone.volume_visible = _volume_visibility.show;
clone.day_visible = _day_change.show;
clone.high_visible = _session_high.show;
clone.low_visible = _session_low.show;
clone.open_visible = _open.show;
clone.settle_visible = _settlement.show;
clone.volume_visible = _volume_panel_item.show;
clone.account_visible = _account_visibility.show;
clone.tif_visible = _tif_visibility.show;
clone.order_type_visible = _order_type_visibility.show;
@@ -601,12 +660,14 @@ namespace mbts.spark {
public class LadderMarketBreakLineVM : ViewModelBase {
readonly Property<Color> _color;
readonly Property<bool> _show;
LadderMarketBreakLine.RefreshMode _refresh_mode;
public LadderMarketBreakLineVM(string name, int column_index = 0, int column_span = 5, bool show_session_range = true) {
public LadderMarketBreakLineVM(string name, int column_index = 0, int column_span = 5, bool show_session_range = true, bool can_edit_refresh_mode = true) {
this.name = name;
this.column_index = column_index;
this.column_span = column_span;
this.show_session_range = show_session_range;
this.can_edit_refresh_mode = can_edit_refresh_mode;
palettes = new ObservableCollection<ColorPaletteVM>(ColorPalette.all_presets().Select(p => new ColorPaletteVM(p)));
_color = backing(nameof(color), Colors.Black);
_show = backing(nameof(show), false);
@@ -618,21 +679,25 @@ namespace mbts.spark {
public Color color { get => _color.Value; set => _color.Value = value; }
public bool show { get => _show.Value; set => _show.Value = value; }
public bool show_session_range { get; }
public bool can_edit_refresh_mode { get; }
public LadderMarketBreakLine.RefreshMode refresh_mode { get => _refresh_mode; set => Set(ref _refresh_mode, value); }
public ObservableCollection<ColorPaletteVM> palettes { get; }
public void assign_from(LadderMarketBreakLine settings) {
color = settings.color.rgb_color();
show = settings.show;
refresh_mode = settings.refresh_mode;
}
public LadderMarketBreakLine get_settings() =>
new LadderMarketBreakLine {
color = new BTSColor(color).ToUint(),
show = show
show = show,
refresh_mode = refresh_mode
};
}
public class OrderEntryPanelItemVisibilityVM : ViewModelBase {
public class OrderEntryPanelItemVisibilityVM : ViewModelBase, ITemplateSelectorKey {
readonly Property<bool> _show;
public OrderEntryPanelItemVisibilityVM(string name) {
@@ -643,6 +708,63 @@ namespace mbts.spark {
public string name { get; }
public bool show { get => _show.Value; set => _show.Value = value; }
string ITemplateSelectorKey.key => LadderSettingsPanelTemplateKeys.VisibilityItem;
}
public class PanelPricePointVM : LadderPanelPricePointVM, ITemplateSelectorKey {
ObservableCollection<ColorPaletteVM>
_font_color_palettes,
_background_color_palettes;
public PanelPricePointVM(string name) =>
this.name = name;
public string name { get; }
public ObservableCollection<ColorPaletteVM> font_color_palettes => _font_color_palettes ??
(_font_color_palettes = ColorPalette.all_presets().to_viewmodels());
public ObservableCollection<ColorPaletteVM> background_color_palettes => _background_color_palettes ??
(_background_color_palettes = ColorPalette.all_presets().to_viewmodels());
string ITemplateSelectorKey.key => LadderSettingsPanelTemplateKeys.PricePoint;
}
public class PanelRelativePricePointVM : LadderPanelRelativePricePointVM, ITemplateSelectorKey {
ObservableCollection<ColorPaletteVM>
_negative_font_color_palettes,
_negative_background_color_palettes,
_neutral_font_color_palettes,
_neutral_background_color_palettes,
_positive_font_color_palettes,
_positive_background_color_palettes;
public PanelRelativePricePointVM(string name) =>
this.name = name;
public string name { get; }
//negative
public ObservableCollection<ColorPaletteVM> negative_font_color_palettes => _negative_font_color_palettes ??
(_negative_font_color_palettes = ColorPalette.all_presets().to_viewmodels());
public ObservableCollection<ColorPaletteVM> negative_background_color_palettes => _negative_background_color_palettes ??
(_negative_background_color_palettes = ColorPalette.all_presets().to_viewmodels());
// neutral
public ObservableCollection<ColorPaletteVM> neutral_font_color_palettes => _neutral_font_color_palettes ??
(_neutral_font_color_palettes = ColorPalette.all_presets().to_viewmodels());
public ObservableCollection<ColorPaletteVM> neutral_background_color_palettes => _neutral_background_color_palettes ??
(_neutral_background_color_palettes = ColorPalette.all_presets().to_viewmodels());
// positive
public ObservableCollection<ColorPaletteVM> positive_font_color_palettes => _positive_font_color_palettes ??
(_positive_font_color_palettes = ColorPalette.all_presets().to_viewmodels());
public ObservableCollection<ColorPaletteVM> positive_background_color_palettes => _positive_background_color_palettes ??
(_positive_background_color_palettes = ColorPalette.all_presets().to_viewmodels());
string ITemplateSelectorKey.key => LadderSettingsPanelTemplateKeys.RelativePricePoint;
}
public class VolumeColumnVM : ViewModelBase {
@@ -1,4 +1,5 @@
using bts.api;
using bts.api.core;
using bts.api.orderman;
using bts.proto;
using bts.shell;
@@ -9,6 +10,8 @@ using mbts.spark.utilities;
using mbts.ui;
using mbts.ui.shell;
using mbts.ui.spark;
using mbts.ui.utility;
using mbts.user.settings;
using mbts.utils;
using System;
using System.Collections.Generic;
@@ -27,12 +30,11 @@ namespace mbts.spark {
readonly IBus _bus;
readonly LadderModel _model;
readonly Property<double> _high, _low, _change, _open, _settlement, _left_panel_width, _zoom_factor;
//readonly Property<double> _window_width, _window_height;
readonly Property<double> _session_high, _session_low, _day_change, _open, _settlement, _left_panel_width, _zoom_factor;
readonly Property<uint> _orders_column_width, _bid_column_width, _price_column_width, _ask_column_width, _last_column_width, _volume_column_width, _piq_column_width;
readonly Property<ulong> _volume;
readonly Property<bool> _auto_clear;
readonly PropertyAutoWrapper<LadderSettings, bool> _show_day, _show_high, _show_low, _show_open, _show_settle, _show_volume, _show_account,
readonly PropertyAutoWrapper<LadderSettings, bool> _show_day, _show_high, _show_low, _show_open, _show_settlement, _show_volume, _show_account,
_show_tif, _show_order_type, _show_size_preset, _show_auto_clear, _show_clear, _show_cancel_buys,
_show_cancel_sells, _show_cancel_all, _show_zoom, _show_status_message;
readonly PropertyAutoWrapper<LadderSettings, Brush> _bid_background, _bid_foreground, _ask_background, _ask_foreground;
@@ -49,8 +51,10 @@ namespace mbts.spark {
ulong _last_trade_time = 0;
IEqualityComparer<double> _equality;
Dictionary<double, LadderOrderVM> _slot_price_vs_orders;
ImmutableSortedDictionary<double, LadderOrderVM> _order_price_index;
IReadOnlyDictionary<uint, OrderSecurity> _cache = DictionaryHelper.empty<uint, OrderSecurity>();
ImmutableDictionary<AlgoKey, LadderFavoriteAlgoItem> _favorite_algo_map = ImmutableDictionary<AlgoKey, LadderFavoriteAlgoItem>.Empty;
ContractSpecificationImmutable? _spec;
public static LadderVM create(IBus bus, LadderModel model, LadderSettings init, IObservable<LadderSettings> settings) =>
new LadderVM(bus, model, init, settings, new OrderPropertiesEditorVM(model.order_gateway, Observable.Return(model.security_md), settings.Select(s => new InlineOrderProperties(model.order_gateway, s))));
@@ -65,15 +69,16 @@ namespace mbts.spark {
_bus = bus;
_model = model;
current_settings = init;
_order_price_index = ImmutableSortedDictionary.Create<double, LadderOrderVM>(spec.price_comparer());
this.settings = settings;
_equality = TickUtils.tick_equality_comparer(_model.security.ContractSpec);
display_quantity_divisor = model.order_gateway.security_auxiliary_model.get_display_quantity_divisor(model.security);
size_calculator.display_divisor = display_quantity_divisor;
_slot_price_vs_orders = new Dictionary<double, LadderOrderVM>(_equality);
this.order_properties_vm = order_properties_vm;
_high = backing(nameof(high), double.NaN);
_low = backing(nameof(low), double.NaN);
_change = backing(nameof(change), double.NaN);
_session_high = backing(nameof(session_high), double.NaN);
_session_low = backing(nameof(session_low), double.NaN);
_day_change = backing(nameof(day_change), double.NaN);
_open = backing(nameof(open), double.NaN);
_settlement = backing(nameof(settlement), double.NaN);
// init window-specific settings: these properties should not observe settings updates; they are independent from the settings dialog, so it doesn't make sense that the settings dialog should cause them to change.
@@ -108,7 +113,7 @@ namespace mbts.spark {
(_show_high = bool_prop(nameof(show_high), s => s.high_visible)).set,
(_show_low = bool_prop(nameof(show_low), s => s.low_visible)).set,
(_show_open = bool_prop(nameof(show_open), s => s.open_visible)).set,
(_show_settle = bool_prop(nameof(show_settle), s => s.settle_visible)).set,
(_show_settlement = bool_prop(nameof(show_settlement), s => s.settle_visible)).set,
(_show_volume = bool_prop(nameof(show_volume), s => s.volume_visible)).set,
(_show_account = bool_prop(nameof(show_account), s => s.account_visible)).set,
(_show_tif = bool_prop(nameof(show_tif), s => s.tif_visible)).set,
@@ -122,6 +127,8 @@ namespace mbts.spark {
(_show_zoom = bool_prop(nameof(show_zoom), s => s.zoom_slider_visible)).set,
(_show_status_message = bool_prop(nameof(show_status_message), s => s.status_message_visible)).set,
s => {
// invalidate spec in case 'ticks per row' changed
_spec = null;
if (
Set(ref _show_account_position, s.account_position_visible, nameof(show_account_position)) |
Set(ref _show_day_position, s.day_position_visible, nameof(show_day_position)) |
@@ -139,8 +146,15 @@ namespace mbts.spark {
_piq_column_width.set(s.piq_column.width);
_volume_column_width.set(s.volume_column.general.width);
// left panel/zoom
day_change_style.load_from(s.panel_price_point_settings.day_change);
open_style.load_from(s.panel_price_point_settings.open);
session_low_style.load_from(s.panel_price_point_settings.session_low);
session_high_style.load_from(s.panel_price_point_settings.session_high);
settlement_style.load_from(s.panel_price_point_settings.settlement);
volume_style.load_from(s.panel_price_point_settings.volume);
_left_panel_width.set(s.order_entry_panel_initial_width);
_zoom_factor.set(s.zoom_factor);
RaisePropertyChanged(nameof(day_change_font_color), nameof(day_change_background_color));
}
};
PropertyAutoWrapper<LadderSettings, bool> bool_prop(string name, Func<LadderSettings, bool> get_bool) =>
@@ -159,71 +173,41 @@ namespace mbts.spark {
settings_command = new DelegateCommand(() => request_settings_dialog?.Invoke());
orders = new ObservableCollection<LadderOrderVM>();
_day_change.Changed += (o, n) => RaisePropertyChanged(nameof(day_change_font_color), nameof(day_change_background_color));
var orders_source = settings.Select(s => s.ticks_per_row).DistinctUntilChanged()
.SelectManyInSeries(tpr => {
var spec = TickUtils.multiply_tick_size(security.ContractSpec, tpr);
var price_comp = Comparer<double>.Create((a, b) =>
CompareUtils.nullable_compare(spec.full_ticks_from_zero(a), spec.full_ticks_from_zero(b)));
return _order_price_source(model.orders, price_comp, p => TickUtils.normalize_price(spec, p));
});
_dispose = Disposable.Create(
settings.OnDispatcher().Subscribe(settings_observer),
get_order_properties_editor_hooks(),
bus.subscribe(SparkTags.LogActivity).OnDispatcher().Subscribe(status_update),
// we need to hook this up to model.orders which is filtered for just the security
model.orders.OnDispatcher().Subscribe(working => {
orders_source.OnDispatcher().Subscribe(tup => {
// Here we manage N orders to 1 price slot in the ladder
Dictionary<double, HashSet<uint>> orders_used_in_this_update = new Dictionary<double, HashSet<uint>>(_equality);
_cache = working.state;
foreach (var os in _cache.Values) {
var wo = os.order;
var slot_price_target = wo.ui_price();
var order_type = wo.order_type();
var filled = wo.filled();
if (_slot_price_vs_orders.TryGetValue(slot_price_target, out LadderOrderVM slot_vm)) {
slot_vm.add_order((wo, os.piq, os.algo, os.meta));
} else {
slot_vm = new LadderOrderVM((wo, os.piq, os.algo, os.meta), slot_price_target, this, _bus, settings.Select(s => s.badge_style).OnDispatcher());
_slot_price_vs_orders[slot_price_target] = slot_vm;
}
// keep track of slot prices vs orders; we use this below to remove orders from the LadderOrderVMs
// that are not found in this callback run
if (!orders_used_in_this_update.TryGetValue(slot_price_target, out HashSet<uint> orders_at_level)) {
orders_at_level = new HashSet<uint>();
}
orders_at_level.Add(wo.Key);
orders_used_in_this_update[slot_price_target] = orders_at_level;
_cache = tup.map;
/// remove empty price slots (the vm will be disposed automatically when it is removed from <see cref="orders"/>)
var removed_prices = _slot_price_vs_orders.Keys.Except(tup.price_index.Keys).ToList();
foreach (var p in removed_prices)
_slot_price_vs_orders.Remove(p);
// add or update current price slots
foreach (var kv in tup.price_index) {
_slot_price_vs_orders.AddOrUpdate(kv.Key,
order_vm => order_vm.sync_orders(kv.Value),
() => new LadderOrderVM(kv.Value, kv.Key, this, _bus, settings.Select(s => s.badge_style).OnDispatcher()));
}
// remove any orders from the lovm that aren't in here
foreach(var kvp in orders_used_in_this_update) {
var slot_vm = _slot_price_vs_orders[kvp.Key];
foreach(var existing_order_key in slot_vm.order_keys) {
if (!kvp.Value.Contains(existing_order_key)) {
slot_vm.remove_order(existing_order_key);
}
}
}
// update dirty brushes and text
foreach (var lovm in _slot_price_vs_orders.Values) {
lovm.update();
}
// complete removal of slots that were not updated
// orders_used_in_this_update.Keys are the price levels in the update
foreach (var slot_price in _slot_price_vs_orders.Keys.ToList()) {
if (!orders_used_in_this_update.Keys.Contains(slot_price)) {
_slot_price_vs_orders.TryGetValue(slot_price, out LadderOrderVM removal_candidate);
if (removal_candidate != null) {
removal_candidate.Dispose();
}
_slot_price_vs_orders.Remove(slot_price);
}
}
// sync the collection
orders.sync_with(_slot_price_vs_orders.Values);
// update badge colors, text, etc.
foreach (var lovm in orders)
lovm.update();
}),
WorkLoop.Start($"Ladder '{security}'", _tick),
ObservableAutoWrapper.dispose_on_removed(orders, true),
Disposable.Create(() => _on_disposed_impl?.Invoke(true))
);
IDisposable get_order_properties_editor_hooks() {
@@ -299,17 +283,34 @@ namespace mbts.spark {
remove => _on_disposed_impl -= value;
}
public SecurityImmutable security => _model.security;
public ContractSpecificationImmutable spec => _spec ?? (
_spec = TickUtils.multiply_tick_size(security.ContractSpec, current_settings?.ticks_per_row ?? 1)).Value;
public uint display_quantity_divisor { get; }
public LadderSettings current_settings { get; private set; }
public double high => _high.Value;
public double low => _low.Value;
public double change => _change.Value;
// left panel values
public double session_high => _session_high.Value;
public double session_low => _session_low.Value;
public double day_change => _day_change.Value;
public double open => _open.Value;
public double settlement => _settlement.Value;
public double position => _position;
public double day_position => _day_position;
public double raw_day_position => _raw_day_position;
public ulong volume => _volume.Value;
// left panel styles
public LadderPanelRelativePricePointVM day_change_style { get; } = new LadderPanelRelativePricePointVM();
public Color day_change_font_color => day_change > 0 ?
day_change_style.positive_font_color :
(day_change < 0 ? day_change_style.negative_font_color : day_change_style.font_color);
public Color day_change_background_color => day_change > 0 ?
day_change_style.positive_background_color :
(day_change < 0 ? day_change_style.negative_background_color : day_change_style.background_color);
public LadderPanelPricePointVM open_style { get; } = new LadderPanelPricePointVM();
public LadderPanelPricePointVM settlement_style { get; } = new LadderPanelPricePointVM();
public LadderPanelPricePointVM session_high_style { get; } = new LadderPanelPricePointVM();
public LadderPanelPricePointVM session_low_style { get; } = new LadderPanelPricePointVM();
public LadderPanelPricePointVM volume_style { get; } = new LadderPanelPricePointVM();
//
public bool auto_clear { get => _auto_clear.Value; set => _auto_clear.set(value); }
public CalculatorLogic size_calculator { get; } = new CalculatorLogic(0);
/// Important: <see cref="order_properties_vm"/> can be null.
@@ -328,7 +329,7 @@ namespace mbts.spark {
public bool show_high => _show_high.view;
public bool show_low => _show_low.view;
public bool show_open => _show_open.view;
public bool show_settle => _show_settle.view;
public bool show_settlement => _show_settlement.view;
public bool show_volume => _show_volume.view;
public bool show_account => _show_account.view;
public bool show_tif => _show_tif.view;
@@ -344,6 +345,11 @@ namespace mbts.spark {
public bool show_cancel_all => _show_cancel_all.view;
public bool show_zoom => _show_zoom.view;
public bool show_status_message => _show_status_message.view;
public TickDisplaySettings day_change_display_settings =>
TickDisplaySettings.Default.with(
pad_with_leading_zeros: false,
show_zero_integer: false);
// left panel scroll props
public double left_panel_view_port_height {
get => _left_panel_view_port_height;
@@ -409,11 +415,11 @@ namespace mbts.spark {
double _max_left_panel_scroll_position =>
Math.Max(0, _left_panel_extent_height - _left_panel_view_port_height);
internal OrderRecordImmutable get_root_at_price((OrderRecordImmutable order, uint? _, AlgoData? __, AlgoDefinitionMetadata? meta) op) {
internal OrderRecordImmutable get_root_at_price(OrderSecurity op) {
var order = op.order;
double p = order.ui_price();
double p = _normalize_price(order.ui_price());
foreach (var o in lineage(order.ParentKey)) {
if (_equality.Equals(p, o.ui_price()))
if (_equality.Equals(p, _normalize_price(o.ui_price())))
order = o;
}
return order;
@@ -447,6 +453,14 @@ namespace mbts.spark {
if (order_properties_vm.selected_algo_definition != null)
rv.default_algo = AlgoID.from_algo_key(order_properties_vm.selected_algo_definition.key);
}
rv.panel_price_point_settings = new LadderPanelPricePointSettings {
day_change = day_change_style.create(),
open = open_style.create(),
settlement = settlement_style.create(),
session_low = session_low_style.create(),
session_high = session_high_style.create(),
volume = volume_style.create()
};
return rv;
}
@@ -542,6 +556,64 @@ namespace mbts.spark {
}
}
static IObservable<(ImmutableSortedDictionary<double, ImmutableDictionary<uint, OrderSecurity>> price_index, IReadOnlyDictionary<uint, OrderSecurity> map)> _order_price_source(
IObservable<TableUpdate<OrderSecurity, uint>> source,
IComparer<double> price_comp,
Func<double, double> normalize_price) {
//
return Observable.Create<(ImmutableSortedDictionary<double, ImmutableDictionary<uint, OrderSecurity>>, IReadOnlyDictionary<uint, OrderSecurity>)>(o => {
var state = ImmutableSortedDictionary.Create<double, ImmutableDictionary<uint, OrderSecurity>>(price_comp);
var sub = source.Subscribe(table => {
var bd = state.ToBuilder();
// removes
var removes = table.removed.Concat(table.changes.Where(price_changed).Old());
foreach (var old_order in removes) {
var price = get_price(old_order);
if (bd.TryGetValue(price, out var index)) {
var new_index = index.Remove(old_order.order.Key);
if (new_index.Count == 0) {
bd.Remove(price);
} else {
bd[price] = new_index;
}
}
}
// changes
var changes = table.changes.Where(ch => !price_changed(ch)).New();
foreach (var changed_order in changes) {
var price = get_price(changed_order);
bd[price] = bd[price].SetItem(changed_order.order.Key, changed_order);
}
// adds
var adds = table.added.Concat(table.changes.Where(price_changed).New());
foreach (var new_order in adds) {
var price = get_price(new_order);
if (bd.TryGetValue(price, out var index)) {
bd[price] = index.Add(new_order.order.Key, new_order);
} else {
bd[price] = ImmutableDictionary.CreateRange(
new[] { new KeyValuePair<uint, OrderSecurity>(new_order.order.Key, new_order) });
}
}
o.OnNext((state = bd.ToImmutable(), table.state));
});
return sub;
});
bool price_changed(Change<OrderSecurity> ch) =>
price_comp.Compare(ch.New.order.ui_price(), ch.Old.order.ui_price()) != 0;
double get_price(OrderSecurity order) {
var p = order.order.ui_price();
if (!(normalize_price is null))
p = normalize_price(p);
return p;
}
}
double _normalize_price(double price) =>
TickUtils.normalize_price(spec, price);
bool _validate_price(Side side, double price, out string msg) {
msg = null;
if (!price.is_real()) {
@@ -562,17 +634,17 @@ namespace mbts.spark {
void _update_header() {
bool last_updated = md.get_last_trade(ref _last_trade_time, out NativePriceSize last, out DateTime time, out ulong volume);
if (_misc_time != _model.md.misc_timestamp || last_updated) {
_high.set(md.session_high);
_low.set(md.session_low);
_session_high.set(md.session_high);
_session_low.set(md.session_low);
_open.set(md.open_price);
_settlement.set(md.settlement_price);
if (!double.IsNaN(last.price)) {
_change.set(last.price - md.settlement_price);
_day_change.set(last.price - md.settlement_price);
} else {
ulong unused = 0;
_model.md.get_bbo(ref unused, out NativePriceSize bid, out NativePriceSize ask);
double mid = TickUtils.mid_tick(security.ContractSpec, bid.price, ask.price);
_change.set(mid - md.settlement_price);
_day_change.set(mid - md.settlement_price);
}
_volume.set(volume);
_misc_time = _model.md.misc_timestamp;
@@ -29,6 +29,8 @@ using System.Windows.Media.Animation;
namespace mbts.spark {
partial class LadderGridHost : Control {
const int _min_row_count = 501, _max_row_count = 2001;
static readonly bool _show_scrollbar = config.Configuration.get<bts.config.LadderKnobs>().show_scrollbar;
static readonly bool _lighten_market_cells = config.Configuration.get<bts.config.LadderKnobs>().lighten_market_cells;
int _row_count = _min_row_count;
@@ -82,6 +84,8 @@ namespace mbts.spark {
_ordershost = new LadderOrdersHost(this) { HorizontalAlignment = HorizontalAlignment.Left, VerticalAlignment = VerticalAlignment.Stretch };
var scrollViewerFactory = new FrameworkElementFactory(typeof(ScrollViewer));
scrollViewerFactory.SetValue(FocusableProperty, false);
if (!_show_scrollbar)
scrollViewerFactory.SetValue(ScrollViewer.VerticalScrollBarVisibilityProperty, ScrollBarVisibility.Hidden);
Template = new ControlTemplate() {
VisualTree = scrollViewerFactory
};
@@ -296,6 +300,18 @@ namespace mbts.spark {
Column[] columns { get; set; } = new Column[0];
IEnumerable<Column> _visible_columns => columns.Where(c => c.settings.show);
ContractSpecificationImmutable? _spec_backing;
ContractSpecificationImmutable _spec {
get {
if (_spec_backing.HasValue) {
return _spec_backing.Value;
} else if (_vm != null) {
_spec_backing = TickUtils.multiply_tick_size(security.ContractSpec, _settings?.ticks_per_row ?? 1);
return _spec_backing.Value;
}
return SecurityDataHelper.Defaults.ContractSpecificationImmutable;
}
}
public void drag_out_of_bounds() =>
_tactile_adorner?.drag_out_of_bounds();
@@ -303,7 +319,7 @@ namespace mbts.spark {
public void scroll_to_price(double price) {
if (_scrollViewer == null || _price_list.is_null_or_empty())
return;
if (security.ContractSpec.tickdiff(_price_list[0], price) is int target_row) {
if (_spec.tickdiff(_price_list[0], price) is int target_row) {
int visible_row_count = (int)(_scrollViewer.ActualHeight / _settings.row_height);
int curr_row = visible_row_count + (int)(_scrollViewer.VerticalOffset / _settings.row_height);
if ((target_row > curr_row && target_row < _row_count) || (target_row < (curr_row - visible_row_count) && target_row >= 0))
@@ -533,10 +549,10 @@ namespace mbts.spark {
_price_list == null ? double.NaN : _price_list[row];
uint? _bid_size_from_row(int row) =>
_size_from_row(row, _price_list, _bids, _vm.security.ContractSpec);
_size_from_row(row, _price_list, _bids, _spec);
uint? _ask_size_from_row(int row) =>
_size_from_row(row, _price_list, _asks, _vm.security.ContractSpec);
_size_from_row(row, _price_list, _asks, _spec);
uint _volume_from_row(int row) {
const int max_tries = 3;
@@ -634,7 +650,7 @@ namespace mbts.spark {
_vm.md.settlement_price,
_settings.net_change == LadderSettings.NetChangeTerms.Ticks,
column.settings,
security.ContractSpec);
_spec);
} else {
LadderRender.render_prices(
column.visual_tup.visual,
@@ -643,7 +659,7 @@ namespace mbts.spark {
_settings.row_height,
_price_list,
column.settings,
security.ContractSpec,
_spec,
_settings.price_display_format);
}
break;
@@ -661,7 +677,7 @@ namespace mbts.spark {
}
void render_market_col(NativePriceSize[] depth) {
var mid = LadderRender.index_of(_price_list, _last_origin_price, _price_comparer);
LadderRender.render_sizes(column.visual_tup.visual, column.visual_tup.glyph_context, mid, _price_list, depth, _settings.row_height, security.ContractSpec, column.settings, _fmt_mkt_depth_item);
LadderRender.render_sizes(column.visual_tup.visual, column.visual_tup.glyph_context, mid, _price_list, depth, _settings.row_height, _spec, column.settings, _fmt_mkt_depth_item, _lighten_market_cells);
}
}
_apply_column_visual_offset();
@@ -696,7 +712,12 @@ namespace mbts.spark {
} else {
_vm.OnDisposed += _on_vm_disposed;
_prices_updated = 0;
_price_comparer = Comparer<double>.Create((x, y) => security.ContractSpec.tick_equals(x, y) ? 0 : y.CompareTo(x));
// invalidate the contract spec here, as well as in the 'settings update' callback.
// While it is assumed that the settings IObservable will always fire at least once (on subscribe),
// this serves as a redundancy/fail-safe; it ensures that the vm's security's
// contract spec will be used, even if the settings sequence is empty.
_invalidate_spec();
_price_comparer = Comparer<double>.Create((x, y) => _spec.tick_equals(_normalize_price(x), _normalize_price(y)) ? 0 : y.CompareTo(x));
_price_dirty = true;
_piq_dirty = true;
// **use local vm to protect against re-assignment,
@@ -713,8 +734,10 @@ namespace mbts.spark {
// with meticulous attention to detail.
_tick_sub = Disposable.Create(() => local_vm.on_tick -= _tick);
_vm_sub = Disposable.Create(() => local_vm.request_recenter -= on_request_recenter);
void on_request_recenter() =>
void on_request_recenter() {
RecenterCommand?.ExecuteIfCan(null);
_refresh_frozen_mkt_lines();
}
}
}
@@ -783,6 +806,14 @@ namespace mbts.spark {
#endregion
void _refresh_frozen_mkt_lines() {
if (_price_list is null)
return;
_mkt_break_lines.refresh_frozen();
_refresh_bid_mkt_break();
_refresh_ask_mkt_break();
_refresh_mid_mkt_break();
}
void _on_vm_disposed(bool obj) =>
_dispose_resources();
@@ -814,6 +845,7 @@ namespace mbts.spark {
} else {
_scroll_to_row(_row_count / 2);
}
_refresh_frozen_mkt_lines();
}
}
@@ -888,13 +920,28 @@ namespace mbts.spark {
}
void _refresh_bid_mkt_break() =>
_render_mkt_break(_bid_mkt_break_vis, _mkt_break_lines.bid, _settings.bid_break_line.color);
_render_mkt_break(
_bid_mkt_break_vis,
_settings.bid_break_line.refresh_mode == LadderMarketBreakLine.RefreshMode.Manual ?
_mkt_break_lines.frozen_bid :
_mkt_break_lines.bid,
_settings.bid_break_line.color);
void _refresh_ask_mkt_break() =>
_render_mkt_break(_ask_mkt_break_vis, _mkt_break_lines.ask, _settings.ask_break_line.color);
_render_mkt_break(
_ask_mkt_break_vis,
_settings.ask_break_line.refresh_mode == LadderMarketBreakLine.RefreshMode.Manual ?
_mkt_break_lines.frozen_ask :
_mkt_break_lines.ask,
_settings.ask_break_line.color);
void _refresh_mid_mkt_break() =>
_render_mkt_break(_mid_mkt_break_vis, _mkt_break_lines.mid, _settings.mid_break_line.color);
_render_mkt_break(
_mid_mkt_break_vis,
_settings.mid_break_line.refresh_mode == LadderMarketBreakLine.RefreshMode.Manual ?
_mkt_break_lines.frozen_mid :
_mkt_break_lines.mid,
_settings.mid_break_line.color);
void _refresh_session_low_line() {
if (_settings.session_low_line.show && _mkt_break_lines.low_render_index.HasValue)
@@ -916,14 +963,14 @@ namespace mbts.spark {
if (!_settings.piq_column.show)
return;
int origin_index = LadderRender.index_of(_price_list, _mkt_break_lines.origin, _price_comparer);
LadderRender.render_piqs(_piq_vis_tup.visual, _last_vis_tup.glyph_context, origin_index, _price_list, _vm.price_vs_piq, _settings.row_height, security.ContractSpec, _settings.piq_column, _fmt_mkt_quantity);
LadderRender.render_piqs(_piq_vis_tup.visual, _last_vis_tup.glyph_context, origin_index, _price_list, _vm.price_vs_piq, _settings.row_height, _spec, _settings.piq_column, _fmt_mkt_quantity);
}
void _refresh_sizes() {
Log.assert_d(_price_list != null);
int origin_index = LadderRender.index_of(_price_list, _mkt_break_lines.origin, _price_comparer);
LadderRender.render_sizes(_bid_vis_tup.visual, _bid_vis_tup.glyph_context, origin_index, _price_list, _bids, _settings.row_height, security.ContractSpec, _settings.bid_column, _fmt_mkt_depth_item);
LadderRender.render_sizes(_ask_vis_tup.visual, _ask_vis_tup.glyph_context, origin_index, _price_list, _asks, _settings.row_height, security.ContractSpec, _settings.ask_column, _fmt_mkt_depth_item);
LadderRender.render_sizes(_bid_vis_tup.visual, _bid_vis_tup.glyph_context, origin_index, _price_list, _bids, _settings.row_height, _spec, _settings.bid_column, _fmt_mkt_depth_item, _lighten_market_cells);
LadderRender.render_sizes(_ask_vis_tup.visual, _ask_vis_tup.glyph_context, origin_index, _price_list, _asks, _settings.row_height, _spec, _settings.ask_column, _fmt_mkt_depth_item, _lighten_market_cells);
}
/// <summary>
@@ -951,7 +998,7 @@ namespace mbts.spark {
_price_list,
vapls,
_settings.row_height,
security.ContractSpec,
_spec,
_settings.volume_column,
last_index,
_get_last_arrow_string(),
@@ -988,8 +1035,8 @@ namespace mbts.spark {
void _refresh_prices() {
var prev_price_list = _price_list;
_price_list = (!(_settings.net_change == LadderSettings.NetChangeTerms.None)) ?
LadderRender.render_prices(_price_vis_tup.visual, _price_vis_tup.glyph_context, _mkt_break_lines.origin, _vm.md.settlement_price, _settings.net_change == LadderSettings.NetChangeTerms.Ticks, _row_count, _settings.row_height, _settings.price_column, security.ContractSpec) :
LadderRender.render_prices(_price_vis_tup.visual, _price_vis_tup.glyph_context, _mkt_break_lines.origin, _row_count, _settings.row_height, _settings.price_column, security.ContractSpec, _settings.price_display_format);
LadderRender.render_prices(_price_vis_tup.visual, _price_vis_tup.glyph_context, _mkt_break_lines.origin, _vm.md.settlement_price, _settings.net_change == LadderSettings.NetChangeTerms.Ticks, _row_count, _settings.row_height, _settings.price_column, _spec) :
LadderRender.render_prices(_price_vis_tup.visual, _price_vis_tup.glyph_context, _mkt_break_lines.origin, _row_count, _settings.row_height, _settings.price_column, _spec, _settings.price_display_format);
_ordershost.update_settings(_price_list, _price_comparer, _settings.row_height, _settings.orders_column);
if (prev_price_list != null) {
// maintain previous visible price range if possible
@@ -1017,8 +1064,8 @@ namespace mbts.spark {
SparkUtils.lazy_warn(!double.IsNaN(_mkt_break_lines.origin) && _mkt_break_lines.origin >= low && _mkt_break_lines.origin <= high,
() => fmt_log_msg($"market break ({_mkt_break_lines.origin}) is unacceptable for the market range ({low} - {high})"));
int prev_row_count = _row_count;
int n_ticks_to_low = security.ContractSpec.tickdiff(_mkt_break_lines.origin, low) ?? 0;
int n_ticks_to_high = security.ContractSpec.tickdiff(high, _mkt_break_lines.origin) ?? 0;
int n_ticks_to_low = _spec.tickdiff(_mkt_break_lines.origin, low) ?? 0;
int n_ticks_to_high = _spec.tickdiff(high, _mkt_break_lines.origin) ?? 0;
int desired_row_count = Math.Max(n_ticks_to_low, n_ticks_to_high) * 2 + 1;
_row_count = Math.Min(_max_row_count, desired_row_count);
if (_row_count != prev_row_count) {
@@ -1034,7 +1081,7 @@ namespace mbts.spark {
_last_price_range_calc_time = now;
//
string fmt_log_msg(string msg) =>
$"Ladder {security} (id:{security.Id}, low/high tick:{security.ContractSpec.LowTick}/{security.ContractSpec.HighTick}): {msg}.";
$"Ladder {security} (id:{security.Id}, low/high tick:{_spec.LowTick}/{_spec.HighTick}): {msg}.";
}
return prices_changed;
}
@@ -1080,31 +1127,46 @@ namespace mbts.spark {
prices != null && prices.Length > 0 ? prices[0].price : double.NaN;
double _get_bid_market_break() {
var raw_bid_break = _get_bid_market_break_raw();
return _normalize_price(raw_bid_break);
}
double _normalize_price(double price) =>
TickUtils.normalize_price(_spec, price);
double _get_bid_market_break_raw() {
double best_bid = _get_top_price(_bids);
double best_ask = _get_top_price(_asks);
return double.IsNaN(best_bid) ?
double.IsNaN(best_ask) ? _vm.settlement : security.ContractSpec.tickdown(best_ask) :
double.IsNaN(best_ask) ? _vm.settlement : _spec.tickdown(best_ask) :
best_bid;
}
double _get_ask_market_break() {
var raw_ask_break = _get_ask_market_break_raw();
return _normalize_price(raw_ask_break);
}
double _get_ask_market_break_raw() {
double best_bid = _get_top_price(_bids);
double best_ask = _get_top_price(_asks);
return double.IsNaN(best_ask) ?
double.IsNaN(best_bid) ? _vm.settlement : best_bid :
security.ContractSpec.tickdown(best_ask);
_spec.tickdown(best_ask);
}
double _get_mid_market_break() {
double best_bid = _get_top_price(_bids);
double best_ask = _get_top_price(_asks);
return double.IsNaN(best_bid) ?
double.IsNaN(best_ask) ? _vm.settlement : security.ContractSpec.tickdown(best_ask) :
double.IsNaN(best_ask) ? best_bid : TickUtils.mid_tick(security.ContractSpec, best_bid, best_ask);
double.IsNaN(best_ask) ? _vm.settlement : _spec.tickdown(best_ask) :
double.IsNaN(best_ask) ? best_bid : TickUtils.mid_tick(_spec, best_bid, best_ask);
}
double _get_session_low() => _vm.md.session_low;
double _get_session_high() => _vm.md.session_high;
double _get_session_low() => _normalize_price(_get_session_low_raw());
double _get_session_high() => _normalize_price(_get_session_high_raw());
double _get_session_low_raw() => _vm.md.session_low;
double _get_session_high_raw() => _vm.md.session_high;
void _render_mkt_break(DrawingVisual vis, double price, uint color) =>
LadderRender.render_mkt_break(vis, _row_for_price(price), _settings.row_height, color);
@@ -1113,6 +1175,9 @@ namespace mbts.spark {
LadderRender.render_single_grid_line(vis, row, _settings.row_height, color, _price_column.x_left, _settings.price_column.width);
#endregion
void _invalidate_spec() =>
_spec_backing = null;
void _settings_updated(LadderSettings s) {
bool init;
double prev_row_height;
@@ -1126,6 +1191,7 @@ namespace mbts.spark {
/// The viewmodel will always have the most up-to-date settings, so ignore <see cref="s"/> and just get it from <see cref="_vm"/>.
/// This is a workaround for the global settings-defaults issue: when defaults are updated, some properties are inadvertantly overwritten, such as column-widths, etc.
_settings = _vm.get_save_state();
_invalidate_spec();
_bid_vis_tup.glyph_context = glyph_context(s.bid_column);
_ask_vis_tup.glyph_context = glyph_context(s.ask_column);
_price_vis_tup.glyph_context = glyph_context(s.price_column);
@@ -1170,6 +1236,7 @@ namespace mbts.spark {
}
}
}
_refresh_frozen_mkt_lines();
_visualHost.AddVisualChild(_mid_mkt_break_vis);
_visualHost.AddVisualChild(_ask_mkt_break_vis);
_visualHost.AddVisualChild(_bid_mkt_break_vis);
@@ -1265,7 +1332,8 @@ namespace mbts.spark {
// Note: The values contained here do NOT necessarily represent true data, as they will be NaN/null if their respective visual is hidden in LadderSettings
class MarketBreakLines {
readonly LadderGridHost _owner;
double _bid, _ask, _mid, _origin, _session_low, _session_high;
double _bid = double.NaN, _ask = double.NaN, _mid = double.NaN, _origin, _session_low, _session_high;
double _frozen_bid = double.NaN, _frozen_ask = double.NaN, _frozen_mid = double.NaN, _frozen_origin = double.NaN;
int? _low_index, _high_index;
public MarketBreakLines(LadderGridHost owner) =>
@@ -1279,6 +1347,11 @@ namespace mbts.spark {
public bool session_range_dirty => session_low_dirty || session_high_dirty;
public bool origin_dirty { get; private set; }
public double frozen_bid => double.IsNaN(_frozen_bid) ? (_frozen_bid = _bid) : _frozen_bid;
public double frozen_ask => double.IsNaN(_frozen_ask) ? (_frozen_ask = _ask) : _frozen_ask;
public double frozen_mid => double.IsNaN(_frozen_mid) ? (_frozen_mid = _mid) : _frozen_mid;
public double frozen_origin => double.IsNaN(_frozen_origin) ? (_frozen_origin = _origin) : _frozen_origin;
public double bid => _bid;
public double ask => _ask;
public double mid => _mid;
@@ -1318,11 +1391,18 @@ namespace mbts.spark {
}
int _get_session_range_size() =>
_owner.security.spec_or_default().tickdiff(_session_high, _session_low) ?? 0;
_owner._spec.tickdiff(_session_high, _session_low) ?? 0;
LadderSettings _settings => _owner._settings;
public void refresh_frozen() {
_refresh(true);
}
public void refresh() {
_refresh(false);
}
void _refresh(bool update_frozen) {
bid_dirty = ConvertUtils.update_value_type(ref _bid, _settings.bid_break_line.show ? _owner._get_bid_market_break() : double.NaN);
ask_dirty = ConvertUtils.update_value_type(ref _ask, _settings.ask_break_line.show ? _owner._get_ask_market_break() : double.NaN);
mid_dirty = ConvertUtils.update_value_type(ref _mid, _settings.mid_break_line.show ? _owner._get_mid_market_break() : double.NaN);
@@ -1342,6 +1422,11 @@ namespace mbts.spark {
if (double.IsNaN(new_origin))
new_origin = _owner._get_bid_market_break();
origin_dirty = ConvertUtils.update_value_type(ref _origin, new_origin);
if (update_frozen) {
_frozen_bid = _bid;
_frozen_ask = _ask;
_frozen_mid = _mid;
}
}
}
}
@@ -130,6 +130,8 @@ namespace mbts.spark {
if (e.ChangedButton == MouseButton.Middle) {
// create the new popup window in here
var obvm = order.create_orderbook_vm();
if (obvm is null)
return;
await Task.Delay(100); // Wait for obvm to load rows collection before showing UI to avoid a flash
var view = new MiniOrderBookView(obvm);
var popup = new System.Windows.Controls.Primitives.Popup {
@@ -46,6 +46,7 @@ namespace mbts.spark {
public static readonly Thickness row_padding = new Thickness(6);
const string tick_separator_period = ".";
const string tick_separator_dash = "-";
const int GRID_LINE_HEIGHT = 1;
// IMPORTANT: this method ONLY WORKS if Badges use the BadgeRender.margin/border_thickness/padding values.
// TODO: elminate the dependency on BadgeRender.margin/border_thickness/padding by integrating them into settings.
@@ -85,7 +86,7 @@ namespace mbts.spark {
public static GlyphRun[] format_prices(double[] prices, double reference_price, bool format_in_tick_terms, double row_height, LadderColumnSettings settings, GlyphContext glyph_context, ContractSpecificationImmutable spec) {
var result = new GlyphRun[prices.Length];
Parallel.For(0, prices.Length, i =>
result[i] = format_text(spec.format(prices[i], reference_price, format_in_tick_terms), i, row_height, settings, glyph_context));
result[i] = format_text(spec.format(prices[i] - reference_price, format_in_tick_terms), i, row_height, settings, glyph_context));
return result;
}
public static GlyphRun[] format_prices(double[] prices, double row_height, LadderColumnSettings settings, GlyphContext glyph_context, ContractSpecificationImmutable spec, LadderSettings.PriceDisplayFormat price_display_format) {
@@ -156,7 +157,7 @@ namespace mbts.spark {
// draw grid lines
for (int row = 1; row < rowcount; ++row) {
double y = row * row_height;
dc.DrawRectangle(brush, null, new Rect(0, y, 500, 1));
dc.DrawRectangle(brush, null, new Rect(0, y, 500, GRID_LINE_HEIGHT));
}
}
}
@@ -170,9 +171,11 @@ namespace mbts.spark {
double row_height,
ContractSpecificationImmutable spec,
LadderColumnSettings settings,
Func<NativePriceSize, string> fmt
) {
Func<NativePriceSize, string> fmt,
bool lighten_market_cells) {
//var background = new SolidColorBrush(settings.background.rgb_color());
var mkt_background = lighten_market_cells ?
settings.background.rgb_color().blend_with(Colors.White).to_brush() : null;
using (var dc = dv.RenderOpen())
using (_draw_with_clip(dc, settings, row_height, prices.Length)) {
//dc.DrawRectangle(background, null, new Rect(0, 0, settings.width, prices.Length * row_height));
@@ -181,15 +184,32 @@ namespace mbts.spark {
var foreground = settings.foreground.rgb_brush();
int curr_index = origin_index;
double curr_price = prices[curr_index];
for (int i = 0; i < rungs.Length; i++) {
if (rungs[i].is_nan) break;
double price = rungs[i].price;
NativePriceSize curr_size = NativePriceSize.NO_MARKET;
var row_tick_groups = rungs
.TakeWhile(nps => !nps.is_nan)
.AggregateConsecutiveGroups(() => NativePriceSize.NO_MARKET,
(aggr, rung) => rung.with(
direct_size: aggr.direct_size + rung.direct_size,
implied_size: aggr.implied_size + rung.implied_size),
rung => {
//spec.round_to_tick(rung.price);
var ticks = spec.full_ticks_from_zero(rung.price);
return ticks.HasValue ? spec.tickup(0, ticks.Value) : rung.price;
});
foreach (var rung in row_tick_groups) {
//double price = spec.round_to_tick(rung.price);
var ticks = spec.full_ticks_from_zero(rung.price);
var price = ticks.HasValue ? spec.tickup(0, ticks.Value) : rung.price;
// prices are in descending order, so get diff from curr_price - price
int tick_diff = spec.tickdiff_unchecked(curr_price, price);
curr_index += tick_diff;
curr_price = price;
if (curr_index >= 0 && curr_index < prices.Length) {
var gr = format_text(fmt(rungs[i]), curr_index, row_height, settings, glyph_context);
if (mkt_background != null)
dc.DrawRectangle(mkt_background, null,
new Rect(0, curr_index * row_height + GRID_LINE_HEIGHT,
settings.width, row_height - GRID_LINE_HEIGHT));
var gr = format_text(fmt(rung), curr_index, row_height, settings, glyph_context);
dc.DrawGlyphRun(foreground, gr);
} else break;
}
@@ -50,6 +50,18 @@
<cv:KeyValue Key="{u:Int 0}" Value="{u:Visibility Collapsed}"/>
</cv:ValueMap>
<c:BadgeTextLinesConverter x:Key="BadgeTextLinesConverter"/>
<cv:ValueMap x:Key="RefreshModeToBooleanConverter">
<cv:KeyValue Key="{x:Static Manual, MemberType={u:Nested sp:LadderMarketBreakLine.RefreshMode}}">
<cv:KeyValue.Value>
<sys:Boolean>false</sys:Boolean>
</cv:KeyValue.Value>
</cv:KeyValue>
<cv:KeyValue Key="{x:Static Auto, MemberType={u:Nested sp:LadderMarketBreakLine.RefreshMode}}">
<cv:KeyValue.Value>
<sys:Boolean>true</sys:Boolean>
</cv:KeyValue.Value>
</cv:KeyValue>
</cv:ValueMap>
<Style x:Key="ColumnBackground" TargetType="Rectangle">
<Setter Property="Grid.RowSpan" Value="3"/>
@@ -161,6 +173,191 @@
</Setter>
</Style>
<Style x:Key="LeftPanelPriceFontColorPopup" TargetType="c:PopupControl">
<Setter Property="Width" Value="60"/>
<Setter Property="Margin" Value="4,2"/>
<Setter Property="HorizontalAlignment" Value="Left"/>
</Style>
<Style x:Key="LeftPanelPricePopupLabel" TargetType="TextBlock">
<Setter Property="HorizontalAlignment" Value="Left"/>
<Setter Property="VerticalAlignment" Value="Center"/>
<Setter Property="Margin" Value="2,0"/>
</Style>
<Style x:Key="LeftPanelPricePopup" TargetType="c:PopupControl">
<Setter Property="Background" Value="{StaticResource ComboBox.Static.Background}"/>
<Setter Property="HorizontalAlignment" Value="Stretch"/>
<Setter Property="Padding" Value="6,2"/>
<Setter Property="PopupContainerStyle">
<Setter.Value>
<Style TargetType="Border" BasedOn="{StaticResource PopupContainerStyleBase}">
<Setter Property="Padding" Value="4"/>
</Style>
</Setter.Value>
</Setter>
<Setter Property="MinHeight" Value="24"/>
<Setter Property="Header" Value="..."/>
<Setter Property="Content" Value="{Binding}"/>
<Setter Property="ShowExpanderArrow" Value="False"/>
<Setter Property="ContentTemplate">
<Setter.Value>
<DataTemplate>
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="*"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush}}"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush}}"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush}}"/>
<RowDefinition Height="Auto"/>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="*"/>
</Grid.ColumnDefinitions>
<c:FontPicker
Grid.ColumnSpan="2"
SelectedFontFamily="{Binding font_family}"
SelectedFontSize="{Binding font_size}"
SelectedFontWeight="{Binding font_weight}"
/>
<TextBlock Grid.Row="2" Style="{StaticResource LeftPanelPricePopupLabel}" Margin="4,0">Font Color</TextBlock>
<c:ColorPickerPopup
Grid.Row="2"
Grid.Column="1"
Palettes="{Binding font_color_palettes}"
SelectedColor="{Binding font_color}"
Style="{StaticResource LeftPanelPriceFontColorPopup}"
/>
<TextBlock Grid.Row="4" Style="{StaticResource LeftPanelPricePopupLabel}">Background Color</TextBlock>
<c:ColorPickerPopup
Grid.Row="4"
Grid.Column="1"
Palettes="{Binding background_color_palettes}"
SelectedColor="{Binding background_color}"
Style="{StaticResource LeftPanelPriceFontColorPopup}"
/>
<CheckBox Grid.Row="6" IsChecked="{Binding show_label}">Show Label</CheckBox>
</Grid>
</DataTemplate>
</Setter.Value>
</Setter>
</Style>
<Style x:Key="LeftPanelRelativePricePopup" TargetType="c:PopupControl" BasedOn="{StaticResource LeftPanelPricePopup}">
<Setter Property="ContentTemplate">
<Setter.Value>
<DataTemplate>
<Grid Grid.IsSharedSizeScope="True">
<Grid.RowDefinitions>
<RowDefinition Height="*"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush}}"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush}}"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush}}"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush}}"/>
<RowDefinition Height="Auto"/>
</Grid.RowDefinitions>
<c:FontPicker
SelectedFontFamily="{Binding font_family}"
SelectedFontSize="{Binding font_size}"
SelectedFontWeight="{Binding font_weight}"
/>
<GroupBox Grid.Row="2" Header="Negative">
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto" SharedSizeGroup="Label"/>
<ColumnDefinition Width="*"/>
</Grid.ColumnDefinitions>
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush}}"/>
<RowDefinition Height="Auto"/>
</Grid.RowDefinitions>
<TextBlock Style="{StaticResource LeftPanelPricePopupLabel}">Font Color</TextBlock>
<c:ColorPickerPopup
Grid.Column="1"
Palettes="{Binding negative_font_color_palettes}"
SelectedColor="{Binding negative_font_color}"
Style="{StaticResource LeftPanelPriceFontColorPopup}"
/>
<TextBlock Grid.Row="2" Style="{StaticResource LeftPanelPricePopupLabel}">Background Color</TextBlock>
<c:ColorPickerPopup
Grid.Row="2"
Grid.Column="1"
Palettes="{Binding negative_background_color_palettes}"
SelectedColor="{Binding negative_background_color}"
Style="{StaticResource LeftPanelPriceFontColorPopup}"
/>
</Grid>
</GroupBox>
<GroupBox Grid.Row="4" Header="Zero">
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto" SharedSizeGroup="Label"/>
<ColumnDefinition Width="*"/>
</Grid.ColumnDefinitions>
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush}}"/>
<RowDefinition Height="Auto"/>
</Grid.RowDefinitions>
<TextBlock Style="{StaticResource LeftPanelPricePopupLabel}">Font Color</TextBlock>
<c:ColorPickerPopup
Grid.Column="1"
Palettes="{Binding font_color_palettes}"
SelectedColor="{Binding font_color}"
Style="{StaticResource LeftPanelPriceFontColorPopup}"
/>
<TextBlock Grid.Row="2" Style="{StaticResource LeftPanelPricePopupLabel}">Background Color</TextBlock>
<c:ColorPickerPopup
Grid.Row="2"
Grid.Column="1"
Palettes="{Binding background_color_palettes}"
SelectedColor="{Binding background_color}"
Style="{StaticResource LeftPanelPriceFontColorPopup}"
/>
</Grid>
</GroupBox>
<GroupBox Grid.Row="6" Header="Positive">
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto" SharedSizeGroup="Label"/>
<ColumnDefinition Width="*"/>
</Grid.ColumnDefinitions>
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush}}"/>
<RowDefinition Height="Auto"/>
</Grid.RowDefinitions>
<TextBlock Style="{StaticResource LeftPanelPricePopupLabel}">Font Color</TextBlock>
<c:ColorPickerPopup
Grid.Column="1"
Palettes="{Binding positive_font_color_palettes}"
SelectedColor="{Binding positive_font_color}"
Style="{StaticResource LeftPanelPriceFontColorPopup}"
/>
<TextBlock Grid.Row="2" Style="{StaticResource LeftPanelPricePopupLabel}">Background Color</TextBlock>
<c:ColorPickerPopup
Grid.Row="2"
Grid.Column="1"
Palettes="{Binding positive_background_color_palettes}"
SelectedColor="{Binding positive_background_color}"
Style="{StaticResource LeftPanelPriceFontColorPopup}"
/>
</Grid>
</GroupBox>
<CheckBox Grid.Row="8" IsChecked="{Binding show_label}">Show Label</CheckBox>
</Grid>
</DataTemplate>
</Setter.Value>
</Setter>
</Style>
<Style x:Key="LadderColumnSample" TargetType="Border">
<Setter Property="Grid.Column" Value="6"/>
<Setter Property="Background" Value="{Binding background, Converter={StaticResource ColorToBrushConverter}}"/>
@@ -455,6 +652,68 @@
</DataTemplate>
</u:TemplateSelectorKeyValue>
</u:KeyedTemplateSelector>
<u:KeyedTemplateSelector x:Key="OrderEntryPanelItemTemplateSelector">
<u:TemplateSelectorKeyValue Key="{x:Static usp:LadderSettingsPanelTemplateKeys.VisibilityItem}">
<DataTemplate>
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto" SharedSizeGroup="A"/>
<ColumnDefinition Width="*" SharedSizeGroup="B"/>
</Grid.ColumnDefinitions>
<Border Margin="0,5,5,0">
<CheckBox Content="{Binding name}" FlowDirection="RightToLeft" IsChecked="{Binding show}">
<CheckBox.Resources>
<Style TargetType="{x:Type Path}">
<Setter Property="FlowDirection" Value="LeftToRight" />
</Style>
</CheckBox.Resources>
</CheckBox>
</Border>
</Grid>
</DataTemplate>
</u:TemplateSelectorKeyValue>
<u:TemplateSelectorKeyValue Key="{x:Static usp:LadderSettingsPanelTemplateKeys.PricePoint}">
<DataTemplate>
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto" SharedSizeGroup="A"/>
<ColumnDefinition Width="*" SharedSizeGroup="B"/>
</Grid.ColumnDefinitions>
<Border Margin="0,5,5,0">
<CheckBox Content="{Binding name}" FlowDirection="RightToLeft" IsChecked="{Binding show}">
<CheckBox.Resources>
<Style TargetType="{x:Type Path}">
<Setter Property="FlowDirection" Value="LeftToRight" />
</Style>
</CheckBox.Resources>
</CheckBox>
</Border>
<c:PopupControl Grid.Column="1" Margin="4,2" Style="{StaticResource LeftPanelPricePopup}"/>
</Grid>
</DataTemplate>
</u:TemplateSelectorKeyValue>
<u:TemplateSelectorKeyValue Key="{x:Static usp:LadderSettingsPanelTemplateKeys.RelativePricePoint}">
<DataTemplate>
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto" SharedSizeGroup="A"/>
<ColumnDefinition Width="*" SharedSizeGroup="B"/>
</Grid.ColumnDefinitions>
<Border Margin="0,5,5,0">
<CheckBox Content="{Binding name}" FlowDirection="RightToLeft" IsChecked="{Binding show}">
<CheckBox.Resources>
<Style TargetType="{x:Type Path}">
<Setter Property="FlowDirection" Value="LeftToRight" />
</Style>
</CheckBox.Resources>
</CheckBox>
</Border>
<c:PopupControl Grid.Column="1" Margin="4,2" Style="{StaticResource LeftPanelRelativePricePopup}"/>
</Grid>
</DataTemplate>
</u:TemplateSelectorKeyValue>
</u:KeyedTemplateSelector>
</UserControl.Resources>
<TabControl>
<TabControl.ItemContainerStyle>
@@ -525,10 +784,12 @@
<ColumnDefinition SharedSizeGroup="c2"/>
<ColumnDefinition SharedSizeGroup="c3"/>
<ColumnDefinition SharedSizeGroup="c4"/>
<ColumnDefinition SharedSizeGroup="c5"/>
</Grid.ColumnDefinitions>
<TextBlock Grid.Column="1" HorizontalAlignment="Center" Margin="6,0" Text="Show" VerticalAlignment="Center"/>
<TextBlock Grid.Column="2" HorizontalAlignment="Center" Margin="6,0" Text="Color" VerticalAlignment="Center"/>
<TextBlock Grid.Column="3" Grid.ColumnSpan="2" HorizontalAlignment="Center" Margin="6,0" Text="Sample" VerticalAlignment="Center"/>
<TextBlock Grid.Column="2" HorizontalAlignment="Center" Margin="6,0" Text="Auto Refresh" VerticalAlignment="Center"/>
<TextBlock Grid.Column="3" HorizontalAlignment="Center" Margin="6,0" Text="Color" VerticalAlignment="Center"/>
<TextBlock Grid.Column="4" Grid.ColumnSpan="2" HorizontalAlignment="Center" Margin="6,0" Text="Sample" VerticalAlignment="Center"/>
</Grid>
<ItemsControl Grid.Row="1" ItemsSource="{Binding mkt_break_items}" Margin="8,0">
<ItemsControl.ItemTemplate>
@@ -540,20 +801,28 @@
<ColumnDefinition SharedSizeGroup="c2"/>
<ColumnDefinition SharedSizeGroup="c3"/>
<ColumnDefinition SharedSizeGroup="c4"/>
<ColumnDefinition SharedSizeGroup="c5"/>
</Grid.ColumnDefinitions>
<Border Grid.Column="0" Background="{u:BTSColor header}" Padding="6,3">
<TextBlock VerticalAlignment="Center" Text="{Binding name}" Foreground="{u:BTSColor header_text}"/>
</Border>
<CheckBox Grid.Column="1" HorizontalAlignment="Center" VerticalAlignment="Center" IsChecked="{Binding show}"/>
<c:ColorPickerPopup
<CheckBox
Grid.Column="2"
HorizontalAlignment="Center"
VerticalAlignment="Center"
IsChecked="{Binding refresh_mode, Converter={StaticResource RefreshModeToBooleanConverter}, Mode=TwoWay}"
IsEnabled="{Binding can_edit_refresh_mode}"
/>
<c:ColorPickerPopup
Grid.Column="3"
BorderBrush="Transparent"
BorderThickness="0"
PopupPlacement="Left"
Palettes="{Binding palettes}"
SelectedColor="{Binding color}"
/>
<Grid Grid.Column="3" Grid.ColumnSpan="2" Height="27">
<Grid Grid.Column="4" Grid.ColumnSpan="2" Height="27">
<Grid.ColumnDefinitions>
<ColumnDefinition/>
<ColumnDefinition/>
@@ -623,7 +892,7 @@
</Rectangle.Fill>
</Rectangle>
</Grid>
<Rectangle Grid.Column="1" Grid.ColumnSpan="5" Fill="DimGray" Height="1" HorizontalAlignment="Stretch" VerticalAlignment="Bottom"/>
<Rectangle Grid.Column="1" Grid.ColumnSpan="6" Fill="DimGray" Height="1" HorizontalAlignment="Stretch" VerticalAlignment="Bottom"/>
</Grid>
</DataTemplate>
</ItemsControl.ItemTemplate>
@@ -656,7 +925,7 @@
ItemsSource="{Binding format_options}"
SelectedItem="{Binding selected_format}"
/>
<StackPanel Grid.Row="1" Grid.ColumnSpan="2" Orientation="Horizontal">
<StackPanel Grid.Row="1" Grid.ColumnSpan="2" Orientation="Horizontal" VerticalAlignment="Top">
<TextBlock
Margin="{StaticResource MarginIndentChild}"
Text="when implied is > 0"
@@ -670,6 +939,7 @@
IsEnabled="{Binding can_choose_alternate_implied_format}"
ItemsSource="{Binding alternate_implied_format_options}"
SelectedItem="{Binding selected_alternate_implied_format}"
VerticalAlignment="Top"
/>
</StackPanel>
<Border Grid.Column="2" HorizontalAlignment="Left" VerticalAlignment="Top" Margin="12,4,0,0" Background="Transparent" BorderBrush="DimGray" BorderThickness="1" ToolTip="Sample Output">
@@ -728,7 +998,38 @@
Visibility="{Binding is_synthetic, Converter={StaticResource NetChangeGroupBoxIsVisibleVisibilityConverter}}"
Padding="4"
>
<c:RadioButtonsControl ItemsSource="{Binding price_format_options}" ItemTemplate="{StaticResource EnumDescriptionTemplate}" SelectedItem="{Binding price_format}"/>
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="{Binding Source={StaticResource HorizontalPush2}}"/>
<ColumnDefinition Width="*"/>
</Grid.ColumnDefinitions>
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush1}}"/>
<RowDefinition Height="*"/>
</Grid.RowDefinitions>
<TextBlock>Ticks Per Row</TextBlock>
<Grid Grid.Column="2">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*"/>
<ColumnDefinition Width="Auto"/>
</Grid.ColumnDefinitions>
<c:TickUpDownUInt
Maximum="100"
TickUpCommand="{Binding DataContext.tick_up_ticks_per_row_cmd, RelativeSource={RelativeSource AncestorType=usp:LadderSettingsView}}"
TickDownCommand="{Binding DataContext.tick_down_ticks_per_row_cmd, RelativeSource={RelativeSource AncestorType=usp:LadderSettingsView}}"
Value="{Binding DataContext.ticks_per_row, RelativeSource={RelativeSource AncestorType=usp:LadderSettingsView}}"
/>
<TextBlock
Grid.Column="1"
Margin="2,0,0,0"
Text="{Binding DataContext.rounded_ticks_per_row, RelativeSource={RelativeSource AncestorType=usp:LadderSettingsView}, StringFormat='({0})'}"
ToolTip="The ticks per row parameter may need to be adjusted to fit evenly into dollars."
/>
</Grid>
<c:RadioButtonsControl Grid.Row="2" Grid.ColumnSpan="3" ItemsSource="{Binding price_format_options}" ItemTemplate="{StaticResource EnumDescriptionTemplate}" SelectedItem="{Binding price_format}"/>
</Grid>
</GroupBox>
<GroupBox
Grid.Row="1"
@@ -909,27 +1210,23 @@
<TextBlock VerticalAlignment="Center">Left Panel Width</TextBlock>
<Grid Grid.Column="2">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="{Binding Source={StaticResource HorizontalPush}}"/>
<ColumnDefinition Width="*"/>
<ColumnDefinition Width="{Binding Source={StaticResource HorizontalPush}}"/>
<ColumnDefinition Width="{Binding Source={StaticResource SliderValueTextWidth}}"/>
<ColumnDefinition Width="Auto"/>
</Grid.ColumnDefinitions>
<Slider Grid.Column="2" Minimum="{x:Static sp:LadderView.MinLeftPanelWidth}" Maximum="{x:Static sp:LadderView.MaxLeftPanelWidth}" Value="{Binding order_entry_panel_width}"/>
<TextBlock Grid.Column="4" VerticalAlignment="Center" Text="{Binding order_entry_panel_width, StringFormat='0.00'}"/>
<Slider Grid.Column="0" Minimum="{x:Static sp:LadderView.MinLeftPanelWidth}" Maximum="{x:Static sp:LadderView.MaxLeftPanelWidth}" Value="{Binding order_entry_panel_width}"/>
<TextBlock Grid.Column="2" VerticalAlignment="Center" Text="{Binding order_entry_panel_width, StringFormat='0.00'}"/>
</Grid>
<!--Zoom Factor-->
<TextBlock Grid.Row="2" VerticalAlignment="Center">Zoom Factor</TextBlock>
<Grid Grid.Row="2" Grid.Column="2">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="{Binding Source={StaticResource HorizontalPush}}"/>
<ColumnDefinition Width="*"/>
<ColumnDefinition Width="{Binding Source={StaticResource HorizontalPush}}"/>
<ColumnDefinition Width="{Binding Source={StaticResource SliderValueTextWidth}}"/>
<ColumnDefinition Width="Auto"/>
</Grid.ColumnDefinitions>
<Slider Grid.Column="2" Minimum="{x:Static sp:LadderView.MinZoomFactor}" Maximum="{x:Static sp:LadderView.MaxZoomFactor}" Value="{Binding zoom_factor}"/>
<TextBlock Grid.Column="4" VerticalAlignment="Center" Text="{Binding zoom_factor, StringFormat='0.00'}"/>
<Slider Grid.Column="0" Minimum="{x:Static sp:LadderView.MinZoomFactor}" Maximum="{x:Static sp:LadderView.MaxZoomFactor}" Value="{Binding zoom_factor}"/>
<TextBlock Grid.Column="2" VerticalAlignment="Center" Text="{Binding zoom_factor, StringFormat='0.00'}"/>
</Grid>
<!--
- Note the 'Delays' in the 'SelectedItem' bindings; this is a workaround for a wpf quirk when the DataContext switches (i.e., when the selected Profile changes in the ShellSettingsDialog).
@@ -944,7 +1241,7 @@
<ComboBox Grid.Row="6" Grid.Column="2" ItemsSource="{Binding time_in_force_options}" SelectedItem="{Binding default_time_in_force, Delay=1}"/>
<!--Algo-->
<TextBlock Grid.Row="8" Grid.Column="0" VerticalAlignment="Center">Algo</TextBlock>
<ComboBox Grid.Row="8" Grid.Column="6" ItemsSource="{Binding Source={StaticResource AlgoDefinitionsViewSource}}" SelectedItem="{Binding default_algo, Delay=1}">
<ComboBox Grid.Row="8" Grid.Column="2" ItemsSource="{Binding Source={StaticResource AlgoDefinitionsViewSource}}" SelectedItem="{Binding default_algo, Delay=1}">
<ComboBox.GroupStyle>
<GroupStyle ContainerStyle="{StaticResource ComboBox.DelineatedGroupContainerStyle}"/>
</ComboBox.GroupStyle>
@@ -966,30 +1263,16 @@
</Grid>
</GroupBox>
<GroupBox Grid.Column="2" Header="Show/Hide" Padding="8,4">
<ItemsControl Grid.IsSharedSizeScope="True" ItemsSource="{Binding order_entry_panel_items}">
<ItemsControl
Grid.IsSharedSizeScope="True"
ItemsSource="{Binding order_entry_panel_items}"
ItemTemplateSelector="{StaticResource OrderEntryPanelItemTemplateSelector}"
>
<ItemsControl.ItemsPanel>
<ItemsPanelTemplate>
<UniformGrid Columns="2" Focusable="False"/>
</ItemsPanelTemplate>
</ItemsControl.ItemsPanel>
<ItemsControl.ItemTemplate>
<DataTemplate>
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto" SharedSizeGroup="A" />
</Grid.ColumnDefinitions>
<Border Margin="0,5,5,0">
<CheckBox Content="{Binding name}" FlowDirection="RightToLeft" IsChecked="{Binding show}">
<CheckBox.Resources>
<Style TargetType="{x:Type Path}">
<Setter Property="FlowDirection" Value="LeftToRight" />
</Style>
</CheckBox.Resources>
</CheckBox>
</Border>
</Grid>
</DataTemplate>
</ItemsControl.ItemTemplate>
</ItemsControl>
</GroupBox>
<!--
@@ -37,4 +37,10 @@ namespace mbts.ui.spark {
public static uint GetVolumeComponentValue(DependencyObject d) => (uint)d.GetValue(VolumeComponentValueProperty);
public static void SetVolumeComponentValue(DependencyObject d, uint value) => d.SetValue(VolumeComponentValueProperty, value);
}
class LadderSettingsPanelTemplateKeys {
public static string VisibilityItem = nameof(VisibilityItem);
public static string PricePoint = nameof(PricePoint);
public static string RelativePricePoint = nameof(RelativePricePoint);
}
}
@@ -37,7 +37,7 @@
<converters:ResponsiveTextConverter x:Key="HighTextConverter" LongText="High:" ShortText="H:" Threshold="99" />
<converters:ResponsiveTextConverter x:Key="LowTextConverter" LongText="Low:" ShortText="L:" Threshold="99" />
<converters:ResponsiveTextConverter x:Key="OpenTextConverter" LongText="Open:" ShortText="O:" Threshold="99" />
<converters:ResponsiveTextConverter x:Key="SettleTextConverter" LongText="Settle:" ShortText="S:" Threshold="99" />
<converters:ResponsiveTextConverter x:Key="SettlementTextConverter" LongText="Settle:" ShortText="S:" Threshold="99" />
<converters:ResponsiveTextConverter x:Key="VolumeTextConverter" LongText="Volume:" ShortText="V:" Threshold="99" />
<converters:DoubleSubtractionConverter x:Key="DoubleSubtractionConverter" Value="4" />
<converters:DoubleSubtractionConverter x:Key="HeightDoubleSubtractionConverter" Value="6" />
@@ -277,6 +277,23 @@
</Setter.Value>
</Setter>
</Style>
<!-- Left Panel Price Points -->
<Style x:Key="LeftPanelPricePointLabel" TargetType="TextBlock">
<Setter Property="Margin" Value="0,1,0,4"/>
<Setter Property="VerticalAlignment" Value="Top"/>
</Style>
<Style x:Key="LeftPanelPricePointBorder" TargetType="Border">
<Setter Property="Grid.Column" Value="2"/>
<Setter Property="HorizontalAlignment" Value="Stretch"/>
<Setter Property="Margin" Value="0,0,0,2"/>
<Setter Property="Padding" Value="1"/>
</Style>
<Style x:Key="LeftPanelPricePointText" TargetType="TextBlock">
<Setter Property="FontWeight" Value="Bold"/>
<Setter Property="Foreground" Value="{mbts:BTSColor UI.default_text}"/>
</Style>
<sys:Double x:Key="MaxZoomFactor">1.5</sys:Double>
<sys:Double x:Key="MinZoomFactor">0.5</sys:Double>
</ResourceDictionary>
@@ -345,107 +362,188 @@
<ColumnDefinition Width="6"/>
<ColumnDefinition Width="Auto"/>
</Grid.ColumnDefinitions>
<!-- Day -->
<TextBlock Grid.Column="0" Grid.Row="0"
Text="{Binding left_panel_width, Converter={StaticResource DayTextConverter}}"
Margin="0,0,0,4"
Visibility="{Binding show_day, Converter={StaticResource BooleanToVisibilityConverter}}"/>
<TextBlock Grid.Column="2" Grid.Row="0" FontWeight="Bold"
Margin="0,0,0,4"
Foreground="{Binding change, Converter={StaticResource NumericSignBrushConverter}}"
Visibility="{Binding show_day, Converter={StaticResource BooleanToVisibilityConverter}}">
<TextBlock.Text>
<MultiBinding Converter="{StaticResource TickDisplayConverter}" Mode="OneWay">
<Binding Path="change"/>
<Binding Path="security.ContractSpec"/>
</MultiBinding>
</TextBlock.Text>
</TextBlock>
<!-- High -->
<TextBlock Grid.Column="0" Grid.Row="1"
Text="{Binding left_panel_width, Converter={StaticResource HighTextConverter}}"
Margin="0,0,0,4"
Visibility="{Binding show_high, Converter={StaticResource BooleanToVisibilityConverter}}"/>
<TextBlock Grid.Column="2" Grid.Row="1" Foreground="{mbts:BTSColor UI.default_text}" FontWeight="Bold"
Margin="0,0,0,4"
Visibility="{Binding show_high, Converter={StaticResource BooleanToVisibilityConverter}}">
<TextBlock.Text>
<MultiBinding Converter="{StaticResource TickDisplayConverter}" Mode="OneWay">
<Binding Path="high"/>
<Binding Path="security.ContractSpec"/>
</MultiBinding>
</TextBlock.Text>
</TextBlock>
<!-- Low -->
<TextBlock Grid.Column="0" Grid.Row="2"
Text="{Binding left_panel_width, Converter={StaticResource LowTextConverter}}"
Margin="0,0,0,4"
Visibility="{Binding show_low, Converter={StaticResource BooleanToVisibilityConverter}}"/>
<TextBlock Grid.Column="2" Grid.Row="2" Foreground="{mbts:BTSColor UI.default_text}" FontWeight="Bold"
Margin="0,0,0,4"
Visibility="{Binding show_low, Converter={StaticResource BooleanToVisibilityConverter}}">
<TextBlock.Text>
<MultiBinding Converter="{StaticResource TickDisplayConverter}" Mode="OneWay">
<Binding Path="low"/>
<Binding Path="security.ContractSpec"/>
</MultiBinding>
</TextBlock.Text>
</TextBlock>
<!-- Open -->
<TextBlock Grid.Column="0" Grid.Row="3"
Text="{Binding left_panel_width, Converter={StaticResource OpenTextConverter}}"
Margin="0,0,0,4"
Visibility="{Binding show_open, Converter={StaticResource BooleanToVisibilityConverter}}"/>
<TextBlock Grid.Column="2" Grid.Row="3" FontWeight="Bold"
Margin="0,0,0,4"
Visibility="{Binding show_open, Converter={StaticResource BooleanToVisibilityConverter}}">
<TextBlock.Text>
<MultiBinding Converter="{StaticResource TickDisplayConverter}" Mode="OneWay">
<Binding Path="open"/>
<Binding Path="security.ContractSpec"/>
</MultiBinding>
</TextBlock.Text>
</TextBlock>
<!-- Settle -->
<TextBlock Grid.Column="0" Grid.Row="4"
Text="{Binding left_panel_width, Converter={StaticResource SettleTextConverter}}"
Margin="0,0,0,4"
Visibility="{Binding show_settle, Converter={StaticResource BooleanToVisibilityConverter}}"/>
<TextBlock Grid.Column="2" Grid.Row="4" FontWeight="Bold"
Margin="0,0,0,4"
Visibility="{Binding show_settle, Converter={StaticResource BooleanToVisibilityConverter}}">
<TextBlock.Text>
<MultiBinding Converter="{StaticResource TickDisplayConverter}" Mode="OneWay">
<Binding Path="settlement"/>
<Binding Path="security.ContractSpec"/>
</MultiBinding>
</TextBlock.Text>
</TextBlock>
<!-- Volume -->
<TextBlock Grid.Column="0" Grid.Row="5"
Text="{Binding left_panel_width, Converter={StaticResource VolumeTextConverter}}"
Margin="0,0,0,4"
Visibility="{Binding show_volume, Converter={StaticResource BooleanToVisibilityConverter}}"/>
<!-- Day Change -->
<TextBlock
Grid.Column="2"
Grid.Row="5"
FontWeight="Bold"
Margin="0,0,0,4"
Visibility="{Binding show_volume, Converter={StaticResource BooleanToVisibilityConverter}}"
Grid.Row="0"
Text="{Binding left_panel_width, Converter={StaticResource DayTextConverter}}"
Visibility="{Binding day_change_style.actual_show_label, Converter={StaticResource BooleanToVisibilityConverter}}"
Style="{StaticResource LeftPanelPricePointLabel}"
/>
<Border
Grid.Row="0"
Background="{Binding day_change_background_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
Visibility="{Binding show_day_change, Converter={StaticResource BooleanToVisibilityConverter}}"
ToolTip="Day Change"
Style="{StaticResource LeftPanelPricePointBorder}"
>
<TextBlock.Text>
<MultiBinding>
<MultiBinding.Converter>
<converters:MultiValueConverterPipe>
<x:Static MemberType="{x:Type converters:DynamicDoubleDivisorConverter}" Member="Instance"/>
<x:Static MemberType="{x:Type converters:ValueConverters}" Member="SimpleString"/>
</converters:MultiValueConverterPipe>
</MultiBinding.Converter>
<Binding Path="volume" Mode="OneWay"/>
<Binding Path="display_quantity_divisor" Mode="OneTime"/>
</MultiBinding>
</TextBlock.Text>
</TextBlock>
<TextBlock
FontFamily="{Binding day_change_style.font_family}"
FontSize="{Binding day_change_style.font_size}"
FontWeight="{Binding day_change_style.font_weight}"
Foreground="{Binding day_change_font_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
Style="{StaticResource LeftPanelPricePointText}"
>
<TextBlock.Text>
<MultiBinding Converter="{StaticResource TickDisplayConverter}" Mode="OneWay">
<Binding Path="day_change"/>
<Binding Path="security.ContractSpec"/>
<Binding Path="day_change_display_settings"/>
</MultiBinding>
</TextBlock.Text>
</TextBlock>
</Border>
<!-- Volume -->
<TextBlock
Grid.Column="0"
Grid.Row="1"
Text="{Binding left_panel_width, Converter={StaticResource VolumeTextConverter}}"
Visibility="{Binding volume_style.actual_show_label, Converter={StaticResource BooleanToVisibilityConverter}}"
Style="{StaticResource LeftPanelPricePointLabel}"
/>
<Border
Grid.Row="1"
Background="{Binding volume_style.background_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
Visibility="{Binding show_volume, Converter={StaticResource BooleanToVisibilityConverter}}"
ToolTip="Volume"
Style="{StaticResource LeftPanelPricePointBorder}"
>
<TextBlock
FontFamily="{Binding volume_style.font_family}"
FontSize="{Binding volume_style.font_size}"
FontWeight="{Binding volume_style.font_weight}"
Foreground="{Binding volume_style.font_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
Style="{StaticResource LeftPanelPricePointText}"
>
<TextBlock.Text>
<MultiBinding>
<MultiBinding.Converter>
<converters:MultiValueConverterPipe>
<x:Static MemberType="{x:Type converters:DynamicDoubleDivisorConverter}" Member="Instance"/>
<x:Static MemberType="{x:Type converters:ValueConverters}" Member="SimpleString"/>
</converters:MultiValueConverterPipe>
</MultiBinding.Converter>
<Binding Path="volume" Mode="OneWay"/>
<Binding Path="display_quantity_divisor" Mode="OneTime"/>
</MultiBinding>
</TextBlock.Text>
</TextBlock>
</Border>
<!-- High -->
<TextBlock
Grid.Row="2"
Text="{Binding left_panel_width, Converter={StaticResource HighTextConverter}}"
Visibility="{Binding session_high_style.actual_show_label, Converter={StaticResource BooleanToVisibilityConverter}}"
Style="{StaticResource LeftPanelPricePointLabel}"
/>
<Border
Grid.Row="2"
Background="{Binding session_high_style.background_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
Visibility="{Binding show_session_high, Converter={StaticResource BooleanToVisibilityConverter}}"
ToolTip="Session High"
Style="{StaticResource LeftPanelPricePointBorder}"
>
<TextBlock
FontFamily="{Binding session_high_style.font_family}"
FontSize="{Binding session_high_style.font_size}"
FontWeight="{Binding session_high_style.font_weight}"
Foreground="{Binding session_high_style.font_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
Style="{StaticResource LeftPanelPricePointText}"
>
<TextBlock.Text>
<MultiBinding Converter="{StaticResource TickDisplayConverter}" Mode="OneWay">
<Binding Path="session_high"/>
<Binding Path="security.ContractSpec"/>
</MultiBinding>
</TextBlock.Text>
</TextBlock>
</Border>
<!-- Low -->
<TextBlock
Grid.Row="3"
Text="{Binding left_panel_width, Converter={StaticResource LowTextConverter}}"
Visibility="{Binding session_low_style.actual_show_label, Converter={StaticResource BooleanToVisibilityConverter}}"
Style="{StaticResource LeftPanelPricePointLabel}"
/>
<Border
Grid.Row="3"
Background="{Binding session_low_style.background_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
Visibility="{Binding show_session_low, Converter={StaticResource BooleanToVisibilityConverter}}"
ToolTip="Session Low"
Style="{StaticResource LeftPanelPricePointBorder}"
>
<TextBlock
FontFamily="{Binding session_low_style.font_family}"
FontSize="{Binding session_low_style.font_size}"
FontWeight="{Binding session_low_style.font_weight}"
Foreground="{Binding session_low_style.font_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
Style="{StaticResource LeftPanelPricePointText}"
>
<TextBlock.Text>
<MultiBinding Converter="{StaticResource TickDisplayConverter}" Mode="OneWay">
<Binding Path="session_low"/>
<Binding Path="security.ContractSpec"/>
</MultiBinding>
</TextBlock.Text>
</TextBlock>
</Border>
<!-- Open -->
<TextBlock
Grid.Row="4"
Text="{Binding left_panel_width, Converter={StaticResource OpenTextConverter}}"
Visibility="{Binding open_style.actual_show_label, Converter={StaticResource BooleanToVisibilityConverter}}"
Style="{StaticResource LeftPanelPricePointLabel}"
/>
<Border
Grid.Row="4"
Background="{Binding open_style.background_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
Visibility="{Binding show_open, Converter={StaticResource BooleanToVisibilityConverter}}"
ToolTip="Open"
Style="{StaticResource LeftPanelPricePointBorder}"
>
<TextBlock
FontFamily="{Binding open_style.font_family}"
FontSize="{Binding open_style.font_size}"
FontWeight="{Binding open_style.font_weight}"
Foreground="{Binding open_style.font_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
Style="{StaticResource LeftPanelPricePointText}"
>
<TextBlock.Text>
<MultiBinding Converter="{StaticResource TickDisplayConverter}" Mode="OneWay">
<Binding Path="open"/>
<Binding Path="security.ContractSpec"/>
</MultiBinding>
</TextBlock.Text>
</TextBlock>
</Border>
<!-- Settlement -->
<TextBlock
Grid.Row="5"
Text="{Binding left_panel_width, Converter={StaticResource SettlementTextConverter}}"
Visibility="{Binding settlement_style.actual_show_label, Converter={StaticResource BooleanToVisibilityConverter}}"
Style="{StaticResource LeftPanelPricePointLabel}"
/>
<Border
Grid.Row="5"
Background="{Binding settlement_style.background_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
Visibility="{Binding show_settlement, Converter={StaticResource BooleanToVisibilityConverter}}"
ToolTip="Settlement"
Style="{StaticResource LeftPanelPricePointBorder}"
>
<TextBlock
FontFamily="{Binding settlement_style.font_family}"
FontSize="{Binding settlement_style.font_size}"
FontWeight="{Binding settlement_style.font_weight}"
Foreground="{Binding settlement_style.font_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
Style="{StaticResource LeftPanelPricePointText}"
>
<TextBlock.Text>
<MultiBinding Converter="{StaticResource TickDisplayConverter}" Mode="OneWay">
<Binding Path="settlement"/>
<Binding Path="security.ContractSpec"/>
</MultiBinding>
</TextBlock.Text>
</TextBlock>
</Border>
</Grid>
<!-- Account combobox -->
<ComboBox DataContext="{Binding order_properties_vm}" Margin="2,10,2,2"
@@ -52,6 +52,7 @@ namespace mbts.spark {
readonly CommonValueMonitor<SecurityImmutable?> _selected_security_mon = new CommonValueMonitor<SecurityImmutable?>();
readonly RightPanelModel _right_panel = new RightPanelModel();
readonly CustomStateSynchronizer _custom_state_sync;
readonly Func<OrderSecurityRootPair, bool> _global_filter;
OrderBookFillsGridSettings _cached_fills_settings = OrderBookStartupData.DefaultFillsGrid;
double
_raw_right_panel_width = OrderBookStartupData.Default.right_panel_width,
@@ -71,8 +72,8 @@ namespace mbts.spark {
FilterData _cached_filter_data;
public OrderBookVM(
IBus bus, INotificationService notification_service, OrdersModel model, IWindowSettingsManager<OrderBookGridSettings> settings_manager, bool rows_are_initially_expanded = false)
: this(bus, notification_service, model, OrdersModel.piq_enabled ? model.on_order_tuples_with_root_and_piq : model.on_order_tuples_with_root, settings_manager, rows_are_initially_expanded) { }
IBus bus, INotificationService notification_service, OrdersModel model, IWindowSettingsManager<OrderBookGridSettings> settings_manager, bool rows_are_initially_expanded = false, Func<OrderSecurityRootPair, bool> global_filter = null)
: this(bus, notification_service, model, OrdersModel.piq_enabled ? model.on_order_tuples_with_root_and_piq : model.on_order_tuples_with_root, settings_manager, rows_are_initially_expanded, global_filter) { }
public OrderBookVM(
IBus bus,
@@ -80,10 +81,12 @@ namespace mbts.spark {
OrdersModel model,
IObservable<TableUpdate<OrderSecurityRootPair, uint>> orders_source,
IWindowSettingsManager<OrderBookGridSettings> settings_manager,
bool rows_are_initially_expanded = false) {
bool rows_are_initially_expanded = false,
Func<OrderSecurityRootPair, bool> global_filter = null) {
_bus = bus;
_model = model;
_global_filter = global_filter;
_selected_params_mon = new OrderParamsAggregator(model.dynamic_helper, _selection_change_throttle, k => _cached_orders.TryGetValue(k, out var o) ? o.order : (OrderSecurityAlgo?)null);
ladder_vm = new LadderVMContainer(bus, model);
order_mod_vm = new OrderParamsVM(this, AlgoEditingPermissions.AllowEditValues);
@@ -611,7 +614,7 @@ namespace mbts.spark {
// resume column filter updates
_columns.filter_changed += _on_filter_changed;
grid_settings_manager.algo_tree_display_mode_changed += _on_filter_changed;
var new_filter = new FilterData(grid_settings_manager.algo_tree_display_mode, _columns.create_filter_states());
var new_filter = new FilterData(grid_settings_manager.algo_tree_display_mode, _columns.create_filter_states(), _global_filter);
var new_sort = _columns.get_sorting_data();
if (!new_filter.Equals(_cached_filter_data)) {
_cached_filter_data = new_filter;
@@ -686,7 +689,7 @@ namespace mbts.spark {
}
void _on_filter_changed() {
var fd = new FilterData(grid_settings_manager.algo_tree_display_mode, _columns.create_filter_states());
var fd = new FilterData(grid_settings_manager.algo_tree_display_mode, _columns.create_filter_states(), _global_filter);
if (!fd.Equals(_cached_filter_data)) {
_cached_filter_data = fd;
_row_collection.filter = fd.build_predicate();
@@ -970,13 +973,25 @@ namespace mbts.spark {
struct FilterData : IEquatable<FilterData> {
public readonly AlgoTreeDisplayMode algo_tree_display_mode;
public readonly FilterStates column_filters;
public readonly Func<OrderSecurityRootPair, bool> global_filter;
public FilterData(AlgoTreeDisplayMode algo_tree_display_mode, FilterStates column_filters) {
public FilterData(AlgoTreeDisplayMode algo_tree_display_mode, FilterStates column_filters, Func<OrderSecurityRootPair, bool> global_filter) {
this.algo_tree_display_mode = algo_tree_display_mode;
this.column_filters = column_filters;
this.global_filter = global_filter;
}
public Func<OrderSecurityRootPair, bool> build_predicate() {
if (global_filter == null)
return _build_predicate_core();
var core_pred = _build_predicate_core();
if (core_pred == null)
return global_filter;
var glbf = global_filter;
return new Func<OrderSecurityRootPair, bool>(o => glbf(o) && core_pred(o));
}
Func<OrderSecurityRootPair, bool> _build_predicate_core() {
var pred = column_filters.build_predicate();
if (algo_tree_display_mode == AlgoTreeDisplayMode.RootAndLeafNodes) {
if (pred == null) {
@@ -0,0 +1,105 @@
using bts.admin.risk;
using bts.api.core;
using bts.collections;
using mbts;
using mbts.ui;
using mbts.ui.utility;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reactive.Linq;
using Component = bts.shell.risk_management.RiskLimitsImportConflictsView.RiskLimitsComponent;
namespace bts.shell.risk_management {
static class RiskLimitsImporter {
/// <summary>
/// Parses the specified file and passes the results to the <paramref name="on_parsed"/> delegate.
/// If the parser encounters improperly formatted values, a dialog is automatically opened
/// </summary>
/// <returns>An IDisposable that will close the import-conflicts-dialog (if it was launched).</returns>
public static IDisposable import_limits(string file_name, IReadOnlyDictionary<uint, SecurityMD> security_map, IReadOnlyDictionary<uint, string> account_map, Action<IEnumerable<ParsedRiskLimits>> on_parsed) {
if (string.IsNullOrEmpty(file_name))
throw new ArgumentException("File name is null or empty.", nameof(file_name));
if (security_map is null)
throw new ArgumentNullException(nameof(security_map));
if (account_map is null)
throw new ArgumentNullException(nameof(account_map));
if (on_parsed is null)
throw new ArgumentNullException(nameof(on_parsed));
IReadOnlyList<ParsedRiskLimits> parsed_limit_items;
try {
parsed_limit_items = RiskLimitsParser.parse_rows(
File.ReadAllLines(file_name),
MappedDictionary.create(security_map, sec_md => sec_md.security),
account_map)
.ToList();
} catch (Exception ex) {
BTSMessageBox.Error($"Error importing limits: {ex}.", RiskManagementWindow.window_type_display_name);
return null;
}
var conflicts = RiskLimitsParser.get_conflicts(parsed_limit_items);
if (conflicts.Count > 0) {
// init vm
var vm = new RiskLimitsImportVM(parsed_limit_items.Count) {
security_map = security_map
};
// add rows
foreach (var kv in conflicts) {
var resolve_del = RiskLimitsParser.assign_component(kv.Key);
foreach (var text_groups in kv.Value) {
var eval = get_error_value(kv.Key);
var row = new RiskLimitsImportVM.Row(kv.Key, text_groups.Key, text_groups.Value, eval, eval);
vm.rows.Add(row);
vm.import_request += () => {
foreach (var pmf in text_groups.Value) {
if (resolve_del(pmf.result, row.value) is AccountSecurityRiskLimits resolved)
pmf.result = resolved;
}
};
}
}
var win = new RiskLimitsImportConflictsDialog {
DataContext = vm,
Title = RiskManagementWindow.window_type_display_name,
Topmost = true
};
IDisposable dispose = null;
vm.RequestClose += (s, e) => Disposable.dispose(ref dispose);
vm.import_request += () => {
on_parsed(parsed_limit_items);
Disposable.dispose(ref dispose);
};
Disposable.dispose(ref dispose);
vm.accounts.SetItems(account_map.Select(kv => new AccountTuple(kv.Key, kv.Value)).Cast<AccountTuple?>());
dispose = Disposable.Create(
vm,
Disposable.Create(close));
win.move_to_mouse(-200, -75);
win.Show();
return dispose;
void close() => WindowUtilities.force_close(win);
object get_error_value(Component component) {
switch (component) {
case Component.MaxNetLongPosition:
case Component.MaxNetShortPosition:
case Component.ClipLimit:
return 0;
case Component.MinPrice:
case Component.MaxPrice:
return double.NaN;
case Component.IsPositionLimitEnabled:
case Component.IsClipLimitEnabled:
case Component.IsPriceLimitEnabled:
return false;
default: return null;
}
}
} else {
on_parsed(parsed_limit_items);
}
return null;
}
}
}
@@ -0,0 +1,250 @@
using bts.admin.risk;
using bts.api;
using bts.collections;
using bts.utils;
using mbts.ui.utility;
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using RiskLimitsComponent = bts.shell.risk_management.RiskLimitsImportConflictsView.RiskLimitsComponent;
namespace bts.shell.risk_management {
class ParsedRiskLimits {
public readonly Guid unpersisted_id = Guid.NewGuid();
public AccountSecurityRiskLimits result { get; set; }
public (string text, bool success) security { get; set; }
public (string text, bool success) account { get; set; }
public (string text, bool success) max_long_position { get; set; }
public (string text, bool success) max_short_position { get; set; }
public (string text, bool success) is_position_limit_enabled { get; set; }
public (string text, bool success) clip_limit { get; set; }
public (string text, bool success) is_clip_limit_enabled { get; set; }
public (string text, bool success) min_price { get; set; }
public (string text, bool success) max_price { get; set; }
public (string text, bool success) is_price_limit_enabled { get; set; }
public bool Equals(ParsedRiskLimits other) => other != null && unpersisted_id == other.unpersisted_id;
public override bool Equals(object obj) => Equals(obj as ParsedRiskLimits);
public override int GetHashCode() => unpersisted_id.GetHashCode();
}
static class RiskLimitsParser {
public const string file_extension = "csv";
public static Func<AccountSecurityRiskLimits, object, object> assign_component(RiskLimitsComponent component) {
switch (component) {
case RiskLimitsComponent.Security: return (mf, val) => mf.with(key: new AccountSecurityKey(mf.account_key, ConvertUtils.try_convert<SecurityImmutable?>(val)?.Id ?? 0));
case RiskLimitsComponent.Account: return (mf, val) => mf.with(key: new AccountSecurityKey(ConvertUtils.try_convert<AccountTuple?>(val)?.id ?? 0, mf.key.security));
case RiskLimitsComponent.MaxNetLongPosition: return (mf, val) => mf.with(mf.limits.with(max_long_position: ConvertUtils.try_convert<uint>(val)));
case RiskLimitsComponent.MaxNetShortPosition: return (mf, val) => mf.with(mf.limits.with(max_short_position: ConvertUtils.try_convert<uint>(val)));
case RiskLimitsComponent.IsPositionLimitEnabled: return (mf, val) => mf.with(mf.limits.with(is_price_limit_enabled: ConvertUtils.try_convert<bool>(val)));
case RiskLimitsComponent.ClipLimit: return (mf, val) => mf.with(mf.limits.with(clip_limit: ConvertUtils.try_convert<uint>(val)));
case RiskLimitsComponent.IsClipLimitEnabled: return (mf, val) => mf.with(mf.limits.with(is_price_limit_enabled: ConvertUtils.try_convert<bool>(val)));
case RiskLimitsComponent.MinPrice: return (mf, val) => mf.with(mf.limits.with(min_price: ConvertUtils.try_convert(val, double.NaN)));
case RiskLimitsComponent.MaxPrice: return (mf, val) => mf.with(mf.limits.with(max_price: ConvertUtils.try_convert(val, double.NaN)));
case RiskLimitsComponent.IsPriceLimitEnabled: return (mf, val) => mf.with(mf.limits.with(is_price_limit_enabled: ConvertUtils.try_convert<bool>(val)));
default: throw new NotImplementedException();
}
}
public static ImmutableDictionary<RiskLimitsComponent, ImmutableDictionary<string, ImmutableList<ParsedRiskLimits>>> get_conflicts(IEnumerable<ParsedRiskLimits> parsed_limits) {
// Add all the components up front (a simple optimizatino since there aren't many),
// so there is no need to check for there existence as various conflicts are added.
// After all conflicts have been added, remove the empty entries.
var missing_components = EnumHelper.get_values<RiskLimitsComponent>()
.ToImmutableDictionary(c => c, c => ImmutableDictionary<string, ImmutableList<ParsedRiskLimits>>.Empty)
.ToBuilder();
foreach (var pmf in parsed_limits) {
if (!pmf.security.success) {
add_missing(RiskLimitsComponent.Security, pmf.security.text, pmf);
}
if (!pmf.account.success) {
add_missing(RiskLimitsComponent.Account, pmf.account.text, pmf);
}
if (!pmf.max_long_position.success) {
add_missing(RiskLimitsComponent.MaxNetLongPosition, pmf.max_long_position.text, pmf);
}
if (!pmf.max_short_position.success) {
add_missing(RiskLimitsComponent.MaxNetShortPosition, pmf.max_short_position.text, pmf);
}
if (!pmf.is_position_limit_enabled.success) {
add_missing(RiskLimitsComponent.IsPositionLimitEnabled, pmf.is_position_limit_enabled.text, pmf);
}
if (!pmf.clip_limit.success) {
add_missing(RiskLimitsComponent.ClipLimit, pmf.clip_limit.text, pmf);
}
if (!pmf.is_clip_limit_enabled.success) {
add_missing(RiskLimitsComponent.IsClipLimitEnabled, pmf.is_clip_limit_enabled.text, pmf);
}
if (!pmf.min_price.success) {
add_missing(RiskLimitsComponent.MinPrice, pmf.min_price.text, pmf);
}
if (!pmf.max_price.success) {
add_missing(RiskLimitsComponent.MaxPrice, pmf.max_price.text, pmf);
}
if (!pmf.is_price_limit_enabled.success) {
add_missing(RiskLimitsComponent.IsPriceLimitEnabled, pmf.is_price_limit_enabled.text, pmf);
}
}
// remove empty component conflicts
var empty_keys = missing_components.Where(kv => kv.Value.Count == 0).Select(kv => kv.Key).ToList();
missing_components.RemoveRange(empty_keys);
return missing_components.ToImmutable();
// local methods
void add_missing(RiskLimitsComponent component, string text, ParsedRiskLimits prl) {
if (!missing_components.TryGetValue(component, out var conflicts)) {
conflicts = ImmutableDictionary<string, ImmutableList<ParsedRiskLimits>>.Empty;
}
if (!conflicts.TryGetValue(text, out var affected)) {
affected = ImmutableList<ParsedRiskLimits>.Empty;
}
missing_components[component] = conflicts.SetItem(text, affected.Add(prl));
}
}
// This implementation prioritizes simplicity over speed.
// The security desc lookup could be better optimized, but the speed at which limits are imported is probably not a paramount concern.
public static IEnumerable<ParsedRiskLimits> parse_rows(IEnumerable<string> rows, IReadOnlyDictionary<uint, SecurityImmutable> security_map, IReadOnlyDictionary<uint, string> account_map) =>
parse_rows(rows,
reverse_lookup(MappedDictionary.create(security_map, s => s.ToString())),
reverse_lookup(account_map));
public static IEnumerable<ParsedRiskLimits> parse_rows(IEnumerable<string> rows, Func<string, uint> security_id_lookup, Func<string, uint> account_id_lookup) {
var columns = new[] {
(Headers.Security, Cells.security(security_id_lookup)),
(Headers.Account, Cells.account(account_id_lookup)),
(Headers.MaxNetLongPosition, Cells.max_long_position),
(Headers.MaxNetShortPosition, Cells.max_short_position),
(Headers.IsPositionLimitEnabled, Cells.is_position_limit_enabled),
(Headers.ClipLimit, Cells.clip_limit),
(Headers.IsClipLimitEnabled, Cells.is_clip_limit_enabled),
(Headers.MinPrice, Cells.min_price),
(Headers.MaxPrice, Cells.max_price),
(Headers.IsPriceLimitEnabled, Cells.is_price_limit_enabled)
}.ToDictionary(col => col.Item1, col => col.Item2.with_null_check());
return RowParser.parse_rows(rows, columns, Cells.delimiter);
}
public static Func<string, TKey> reverse_lookup<TKey>(IReadOnlyDictionary<TKey, string> map) {
var lookup = map.ToLookup(kv => kv.Value, kv => kv.Key);
return cell_text => lookup.Contains(cell_text) ? lookup[cell_text].First() : default;
}
static class Headers {
public const string
Security = "Security",
Account = "Account",
MaxNetLongPosition = "Max Long",
MaxNetShortPosition = "Max Short",
IsPositionLimitEnabled = "Enforce Position",
ClipLimit = "Clip",
IsClipLimitEnabled = "Enforce Clip",
MinPrice = "Min Price",
MaxPrice = "Max Price",
IsPriceLimitEnabled = "Enforce Price";
}
static class Cells {
public const char delimiter = ',';
public static RowParser.AssignColumnValue<ParsedRiskLimits> security(Func<string, uint> reverse_id_lookup) {
return impl;
void impl(ref ParsedRiskLimits pmf, string text) {
pmf.result = pmf.result.with(key: new AccountSecurityKey(pmf.result.key.account, reverse_id_lookup(text)));
pmf.security = (text, pmf.result.key.security != 0);
}
}
public static RowParser.AssignColumnValue<ParsedRiskLimits> account(Func<string, uint> reverse_id_lookup) {
return impl;
void impl(ref ParsedRiskLimits pmf, string text) {
pmf.result = pmf.result.with(key: new AccountSecurityKey(reverse_id_lookup(text), pmf.result.key.security));
pmf.account = (text, pmf.result.key.account != 0);
}
}
public static void max_long_position(ref ParsedRiskLimits pmf, string cell_text) {
if (uint.TryParse(cell_text, out uint v)) {
pmf.result = pmf.result.with(pmf.result.limits.with(max_long_position: v));
pmf.max_long_position = (cell_text, true);
} else {
pmf.max_long_position = (cell_text, false);
}
}
public static void max_short_position(ref ParsedRiskLimits pmf, string cell_text) {
if (uint.TryParse(cell_text, out uint v)) {
pmf.result = pmf.result.with(pmf.result.limits.with(max_short_position: v));
pmf.max_short_position = (cell_text, true);
} else {
pmf.max_short_position = (cell_text, false);
}
}
public static void is_position_limit_enabled(ref ParsedRiskLimits pmf, string cell_text) {
if (_try_parse_yes_no(cell_text, out var result)) {
pmf.result = pmf.result.with(pmf.result.limits.with(is_position_limit_enabled: result));
pmf.is_position_limit_enabled = (cell_text, true);
} else {
pmf.is_position_limit_enabled = (cell_text, false);
}
}
public static void clip_limit(ref ParsedRiskLimits pmf, string cell_text) {
if (uint.TryParse(cell_text, out uint v)) {
pmf.result = pmf.result.with(pmf.result.limits.with(clip_limit: v));
pmf.clip_limit = (cell_text, true);
} else {
pmf.clip_limit = (cell_text, false);
}
}
public static void is_clip_limit_enabled(ref ParsedRiskLimits pmf, string cell_text) {
if (_try_parse_yes_no(cell_text, out var result)) {
pmf.result = pmf.result.with(pmf.result.limits.with(is_clip_limit_enabled: result));
pmf.is_clip_limit_enabled = (cell_text, true);
} else {
pmf.is_clip_limit_enabled = (cell_text, false);
}
}
static bool _try_parse_yes_no(string text, out bool result) {
switch (text?.Trim()?.ToLower()) {
case "y": result = true; break;
case "n": result = false; break;
default: result = default; return false;
}
return true;
}
public static void min_price(ref ParsedRiskLimits pmf, string cell_text) {
if (double.TryParse(cell_text, out var v)) {
pmf.result = pmf.result.with(pmf.result.limits.with(min_price: v));
pmf.min_price = (cell_text, true);
} else {
pmf.min_price = (cell_text, false);
}
}
public static void max_price(ref ParsedRiskLimits pmf, string cell_text) {
if (double.TryParse(cell_text, out var v)) {
pmf.result = pmf.result.with(pmf.result.limits.with(max_price: v));
pmf.max_price = (cell_text, true);
} else {
pmf.max_price = (cell_text, false);
}
}
public static void is_price_limit_enabled(ref ParsedRiskLimits pmf, string cell_text) {
if (_try_parse_yes_no(cell_text, out var result)) {
pmf.result = pmf.result.with(pmf.result.limits.with(is_price_limit_enabled: result));
pmf.is_price_limit_enabled = (cell_text, true);
} else {
pmf.is_price_limit_enabled = (cell_text, false);
}
}
}
}
}
@@ -1,6 +1,8 @@
using bts.admin.risk;
using bts.api;
using bts.collections;
using bts.spark;
using bts.view;
using mbts;
using mbts.persist;
using mbts.spark;
@@ -18,15 +20,15 @@ using System.Windows.Data;
namespace bts.shell.risk_management {
class RiskManagementWindow : SparkWindow<RiskManagementSettings>, ISharedWindow {
const string
_window_type_id = "RiskManagement",
_window_type_display_name = "Risk Management";
public const string
window_type_id = "RiskManagement",
window_type_display_name = "Risk Management";
readonly IWindowSettingsManager<GridSettings> _settings_manager;
readonly AdminModel _model;
FrameworkElement _view;
IReadOnlyList<SparkCommand> _commands;
IDisposable _settings_sub, _securities_sub;
IDisposable _settings_sub, _securities_sub, _cmd_subscriptions;
RiskManagementSettings _settings;
RiskManagementVM _vm;
SimpleGridSettingsManagerVM<RiskManagementControl.Columns> _grid_settings_manager => _vm.grid_settings_manager;
@@ -39,17 +41,17 @@ namespace bts.shell.risk_management {
IWindowSettingsManager<GridSettings> settings_manager,
ISaveWindow<RiskManagementSettings> isw,
RiskManagementSettings settings)
: base(_window_type_display_name, bus, isw, Icons.Risk) {
: base(window_type_display_name, bus, isw, Icons.Risk) {
//
_settings_manager = settings_manager;
_settings = settings;
_model = model;
thread_id = mbts.config.Configuration.get<bts.config.MultiThreadedWindows>().risk_management ? "OrderBook" : null;
thread_id = mbts.config.Configuration.get<bts.config.MultiThreadedWindows>().risk_management ? window_type_id : null;
_securities_sub = bus.subscribe(SparkTags.SecuritiesTag).Subscribe(sec_map => _security_map = sec_map);
}
public override IEnumerable<SparkCommand> Commands => _commands;
public override string window_type => _window_type_id;
public override string window_type => window_type_id;
public override RiskManagementSettings SaveState =>
(_vm?.create() ?? RiskManagementSettings.Default).with(menu_display: _menu_display_vm.safe_create());
@@ -65,6 +67,7 @@ namespace bts.shell.risk_management {
public string thread_id { get; }
public override void Dispose() {
Disposable.dispose(ref _cmd_subscriptions);
_commands.empty_if_null().OfType<IDisposable>().DisposeAll();
Disposable.dispose(ref _securities_sub);
Disposable.dispose(ref _settings_sub);
@@ -79,31 +82,42 @@ namespace bts.shell.risk_management {
Log.assert(_settings_sub == null, "Grid settings subscription has already been initialized.");
// initialize everything: menu_display_vm, vm, settings subscription, and view
_menu_display_vm = _init_menu_display_vm(_settings.menu_display);
_vm = _init_vm(_model, _settings);
_vm = _init_vm(_bus.subscribe(SparkTags.SecuritiesTag), _model, _settings);
_settings_sub = _settings_manager.subscribe_current()
.OnDispatcher()
.Subscribe(gs => _vm.load_from(gs));
_commands = new List<SparkCommand>(_mk_commands());
(_commands, _cmd_subscriptions) = _mk_commands();
_view = new RiskManagementControl { DataContext = _vm };
}
protected override void OnParentViewCreated(SparkWindowView parent_view) =>
_menu_display_vm.safe_bind_to_view(parent_view);
static SparkMenuDisplayVM _init_menu_display_vm(SparkMenuDisplaySettings settings) {
var vm = new SparkMenuDisplayVM();
vm.load_from(settings);
return vm;
}
static RiskManagementVM _init_vm(AdminModel model, RiskManagementSettings settings) {
static RiskManagementVM _init_vm(IObservable<IReadOnlyDictionary<uint, SecurityMD>> securities_source, AdminModel model, RiskManagementSettings settings) {
var vm = new RiskManagementVM(model.account_security_risk_limits, model.on_account_tuples);
vm.request_update_limit += update_limit;
vm.load_from(settings);
var vm_sec_sub = securities_source.OnDispatcher().Subscribe(sec_map => vm.security_map = sec_map);
vm.OnDisposed += _ => Disposable.dispose(ref vm_sec_sub);
return vm;
void update_limit(AccountSecurityRiskLimits lim) =>
model.add_or_update_risk_limits(lim.account_key, new[] { (lim.security_key, lim.limits) }).ignore();
void update_limit(AccountSecurityRiskLimits lim) {
model.set_risk_limits(
MappedDictionary.create(
vm.build_account_limits_map(), acc_sec_lims => acc_sec_lims.Select(asl => (asl.security_key, asl.limits))))
.ignore();
}
}
IEnumerable<SparkCommand> _mk_commands() {
yield return new SparkCommandCommand("Add New Limits", Icons.AddBoxes, new DialogCommand(() => {
(List<SparkCommand> cmds, IDisposable subscriptions) _mk_commands() {
var subs = new List<IDisposable>();
var cmds = new List<SparkCommand>();
cmds.Add(new SparkCommandCommand("Add New Limits", Icons.AddBoxes, new DialogCommand(() => {
if (_vm is null)
return null;
var account_id = _vm.selected_account?.id ?? 0;
@@ -122,33 +136,60 @@ namespace bts.shell.risk_management {
}
}
}
}));
var edit_selected_rows_cmd = new DialogCommand(() => {
})));
var edit_cmd = new DialogCommand(() => {
if (!(_vm?.selected_account).HasValue)
return null;
var account_id = _vm.selected_account.Value.id;
var targets = _vm.selected_rows.Select(r => r.create()).ToList();
var targets = _vm.selected_rows.Select(r => r.data).ToList();
var init_state = RiskLimitsModification.aggregate_common_props(targets);
return mk_row_editor_dialog(init_state, commit, false);
void commit(RiskLimitsModification mod) =>
_model.add_or_update_risk_limits(account_id, targets.Select(r => (r.security_key, mod.apply(r.limits)))).ignore();
_vm.modify_rows(targets.WrapSelector(t => t.key, null), mod);
}, () => _vm.selected_rows.Count > 0, true, off_x: -300, off_y: -60);
_vm.selected_rows_changed += edit_selected_rows_cmd.RaiseCanExecuteChanged;
yield return new SparkCommandCommand("Edit Selected Rows", Icons.ModifyOrder, edit_selected_rows_cmd);
_vm.selected_rows_changed += edit_cmd.RaiseCanExecuteChanged;
cmds.Add(new SparkCommandCommand("Edit Selected Rows", Icons.ModifyOrder, edit_cmd));
var revert_selected_rows_cmd = ObservantCommand.create(() => _vm?.revert(_vm.selected_rows), out var revert_selected_rows_observer);
subs.Add(_vm.subscribe_selected_rows()
.Select(srs => srs.Count > 0)
.And(_vm.subscribe_has_dirty_rows())
.OnDispatcher()
.Subscribe(revert_selected_rows_observer));
cmds.Add(new SparkCommandCommand("Revert Selected Rows", Icons.UndoCircular, revert_selected_rows_cmd));
var delete_selected_rows_cmd = new DelegateCommand(() => {
cmds.Add(new SparkCommandCommand("Import Limits", Icons.Import,
FileDialogCommand.open_file(file => _vm?.import_limits(file), extensions: RiskLimitsParser.file_extension)));
var save_cmd = new SparkCommandCommand("Save", Icons.Disk, ObservantCommand.create(() => {
//_vm.selected_account.Value.id, _vm.rows.Where(r => r.)
var lims = _vm.build_account_limits_map();
var mlims = MappedDictionary.create(lims, l => l.Select(lim => (lim.security_key, lim.limits)));
_model.set_risk_limits(mlims).ignore();
}, out var save_observer));
cmds.Add(save_cmd);
subs.Add(_vm.subscribe_has_dirty_rows().OnDispatcher().Subscribe(save_observer));
var delete_cmd = new DelegateCommand(() => {
if (!(_vm?.selected_account).HasValue)
return;
var selected_rows = _vm.selected_rows;
var to_remove = _vm.selected_rows;
var account_id = _vm.selected_account.Value.id;
if (BTSMessageBox.Confirm($"Are you sure you want to delete the selected limits ({selected_rows.Count})?", "Delete Limits"))
_model.delete_risk_limits(account_id, selected_rows.Select(r => r.security_key)).ignore();
if (BTSMessageBox.Confirm($"Are you sure you want to delete the selected limits ({to_remove.Count})?", "Delete Limits")) {
// remove unpersisted limits first (i.e., imports), then delete the persisted ones.
foreach (var r in to_remove) {
if (!r.is_persisted) {
_vm.rows.RemoveSorted(r, _vm.row_comparer);
to_remove = to_remove.Remove(r);
}
}
_model.delete_risk_limits(account_id, to_remove.Select(r => r.security_key)).ignore();
}
}, () => _vm.selected_rows.Count > 0);
_vm.selected_rows_changed += delete_selected_rows_cmd.RaiseCanExecuteChanged;
_vm.selected_rows_changed += delete_cmd.RaiseCanExecuteChanged;
yield return new SparkCommandCommand("Delete", Icons.Trash, delete_selected_rows_cmd);
cmds.Add(new SparkCommandCommand("Delete", Icons.Trash, delete_cmd));
// wrap the grid settings view factory in a dialogCommand here since the vm is destroyed/recreated when the security criteria changes
yield return SparkCommands.window_settings_command(new DialogCommand(() => {
cmds.Add(SparkCommands.window_settings_command(new DialogCommand(() => {
if (_vm is null)
return null;
_settings_manager.instance_settings = _vm.create().grid;
@@ -162,8 +203,9 @@ namespace bts.shell.risk_management {
var dialog = new ShellSettingsDialog { DataContext = settings_vm };
settings_vm.RequestClose += (s, e) => WindowUtilities.force_close(dialog);
return dialog;
}));
yield return _menu_display_vm.spark_cmd;
})));
cmds.Add(_menu_display_vm.spark_cmd);
return (cmds, Disposable.wrap_collection(subs));
// although only the api only requires security keys,
// the actual securities are used in this method so the user can see them in the view
@@ -0,0 +1,105 @@
using bts.api;
using bts.collections;
using mbts;
using mbts.collections;
using mbts.ui;
using mbts.ui.shell;
using mbts.ui.utility;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Reactive.Linq;
using System.Windows.Data;
using System.Windows.Input;
using Component = bts.shell.risk_management.RiskLimitsImportConflictsView.RiskLimitsComponent;
namespace bts.shell.risk_management {
class RiskLimitsImportVM : DisposableViewModelBase, IRequestViewClose {
readonly RefCountMap<ParsedRiskLimits> _conflicts = new RefCountMap<ParsedRiskLimits>();
IReadOnlyDictionary<uint, SecurityMD> _security_map = DictionaryHelper.empty<uint, SecurityMD>();
public RiskLimitsImportVM(int num_limits) {
rows_view = CollectionViewSource.GetDefaultView(rows);
ok_cmd = new DelegateCommand(() => import_request?.Invoke());
cancel_cmd = new DelegateCommand(() => RequestClose?.Invoke(this, new EventArgs()));
this.num_limits = num_limits;
_dispose = ObservableAutoWrapper.connect_item_hooks(rows, r =>
r.subscribe_has_error().Subscribe(has_error => {
if (has_error) {
if (r.affected_limits.Count(_conflicts.increment_adds_key) == 0)
return;
} else if (r.affected_limits.Count(_conflicts.decrement_removes_key) == 0)
return;
RaisePropertyChanged(nameof(num_successfully_parsed_limits));
}));
}
public event Action import_request;
public event EventHandler RequestClose;
public ObservableCollection<Row> rows { get; } = new ObservableCollection<Row>();
public ICollectionView rows_view { get; }
public int num_limits { get; }
public int num_successfully_parsed_limits => num_limits - _conflicts.Count;
// misc items sources
public IEnumerable<Side> sides => new[] { Side.Buy, Side.Sell };
public ObservableCollection<AccountTuple?> accounts { get; } = new ObservableCollection<AccountTuple?>();
public IReadOnlyDictionary<uint, SecurityMD> security_map {
get => _security_map;
set {
if (!ReferenceEquals(_security_map, value)) {
_security_map = value;
_resolve_securities();
RaisePropertyChanged();
}
}
}
// commands
public ICommand ok_cmd { get; }
public ICommand cancel_cmd { get; }
void _resolve_securities() {
if (_security_map == null)
return;
var reverse_lookup = RiskLimitsParser.reverse_lookup(MappedDictionary.create(_security_map, v => v.security.ToString()));
foreach (var r in rows) {
if (r.component == Component.Security && r.has_error) {
var id = reverse_lookup(r.text);
if (id != 0 && _security_map.TryGetValue(id, out var smd))
r.value = smd.security;
}
}
}
public class Row : ViewModelBase, ITemplateSelectorKey {
readonly DelegateProperty<bool> _has_error;
object _value;
string _text;
public Row(Component component, string text, IReadOnlyCollection<ParsedRiskLimits> affected_limits, object error_value, object value) {
this.component = component;
this.text = text;
this.affected_limits = affected_limits;
_value = value;
_has_error = backing(nameof(has_error), () => Equals(this.value, error_value));
}
public Component component { get; }
public string text { get => _text; set => Set(ref _text, value); }
public IReadOnlyCollection<ParsedRiskLimits> affected_limits { get; }
public object value {
get => _value;
set {
if (Set(ref _value, value))
_has_error.refresh();
}
}
public bool has_error => _has_error.Value;
string ITemplateSelectorKey.key => component.ToString();
public IObservable<bool> subscribe_has_error() => _has_error.observe_current(true);
}
}
}
@@ -87,6 +87,7 @@ namespace bts.shell.risk_management {
public RiskLimitsModification(
SecurityImmutable? security = null,
SecurityCriteria security_criteria = null,
AccountTuple? account = null,
uint? max_long_position = null,
uint? max_short_position = null,
bool? is_position_limit_enabled = null,
@@ -98,6 +99,7 @@ namespace bts.shell.risk_management {
//
this.security = security;
this.security_criteria = security_criteria;
this.account = account;
this.max_long_position = max_long_position;
this.max_short_position = max_short_position;
this.is_position_limit_enabled = is_position_limit_enabled;
@@ -110,6 +112,7 @@ namespace bts.shell.risk_management {
public SecurityImmutable? security { get; }
public SecurityCriteria security_criteria { get; }
public AccountTuple? account { get; }
// position
public uint? max_long_position { get; }
public uint? max_short_position { get; }
@@ -126,6 +129,7 @@ namespace bts.shell.risk_management {
new RiskLimitsModification(
_common_value(limit_items, l => l.security, s => s),
null,
_common_value(limit_items, l => new AccountTuple(l.account_key, l.account_name)),
_common_value(limit_items, l => l.limits.max_long_position),
_common_value(limit_items, l => l.limits.max_short_position),
_common_value(limit_items, l => l.limits.is_position_limit_enabled),
@@ -146,8 +150,25 @@ namespace bts.shell.risk_management {
min_price: min_price ?? target.min_price,
max_price: max_price ?? target.max_price);
public RiskLimitsModification with(RiskLimitsModification other_mod) =>
with(
other_mod.security.HasValue ? other_mod.security.Value : security,
other_mod.account.HasValue ? other_mod.account.Value : account,
security_criteria: other_mod.security_criteria ?? security_criteria,
max_long_position: other_mod.max_long_position ?? max_long_position,
max_short_position: other_mod.max_short_position ?? max_short_position,
is_position_limit_enabled: other_mod.is_position_limit_enabled ?? is_position_limit_enabled,
clip_limit: other_mod.clip_limit ?? clip_limit,
is_clip_limit_enabled: other_mod.is_clip_limit_enabled ?? is_clip_limit_enabled,
min_price: other_mod.min_price ?? min_price,
max_price: other_mod.max_price ?? max_price,
is_price_limit_enabled: other_mod.is_price_limit_enabled ?? is_price_limit_enabled);
//new RiskLimitsModification(security: other_mod.security ?? security,
// security_criteria: other_mod.security ?? security);
public RiskLimitsModification with(
OptionalNullable<SecurityImmutable>? security = null,
OptionalNullable<AccountTuple>? account = null,
SecurityCriteria security_criteria = null,
OptionalNullable<uint>? max_long_position = null,
OptionalNullable<uint>? max_short_position = null,
@@ -161,6 +182,7 @@ namespace bts.shell.risk_management {
new RiskLimitsModification(
security.HasValue ? security.Value.value : this.security,
security_criteria ?? this.security_criteria,
account.HasValue ? account.Value.value : this.account,
max_long_position.HasValue ? max_long_position.Value.value : this.max_long_position,
max_short_position.HasValue ? max_short_position.Value.value : this.max_short_position,
is_position_limit_enabled.HasValue ? is_position_limit_enabled.Value.value : this.is_position_limit_enabled,
@@ -1,89 +1,114 @@
using bts.admin.risk;
using bts.api;
using bts.utils;
using mbts.spark;
using mbts.ui;
using mbts.ui.shell;
using System;
using System.Runtime.CompilerServices;
namespace bts.shell.risk_management {
class RiskLimitsVM : ViewModelBase, IValueFactory<AccountSecurityRiskLimits> {
readonly DeferrableActionWrapper _result_changed;
// The user can modify some props directly in the grid.
// However, the sorting relies on immutable data
// (binary search may break if the applicable comparisons change,
// depending on the current sorting criteria).
// As a work-around, the rows are sorted by the committed_data.
// Any modifications made through the prop setters are assumed to be 'user-changes'
// (as the props are bound to the view),
/// and the committed data is only changed through <see cref="load_from(AccountSecurityRiskLimits)"/>.
AccountSecurityRiskLimits _committed_data, _mutable_data;
class RiskLimitsVM : ViewModelBase, IEquatable<RiskLimitsVM> {
RiskLimitsVM(AccountSecurityKey id) =>
this.id = id;
public RiskLimitsVM() =>
_result_changed = new DeferrableActionWrapper(() => result_changed?.Invoke());
public event Action request_commit;
public RiskLimitsVM(AccountSecurityRiskLimits data) : this() {
_committed_data = data;
_mutable_data = data;
}
/// The user can modify some props directly in the grid,
/// which may or may not give the row a new sort-position.
/// For this reason, the owner-viewmodel (<see cref="RiskManagementVM"/>)
/// is notified both immediately before, and after the changes are reflected in <see cref="data"/>.
/// By responding to those events, the owner-viewmodel can safely process any
/// sorting-changes without breaking binary search functionality.
/// <see cref="value_changing"/>, <see cref="value_changed"/>
public event Action result_changed;
/// <summary>
/// This event is raised just before a new value is assigned to <see cref="data"/>.
/// </summary>
public event Action<(AccountSecurityRiskLimits old_value, AccountSecurityRiskLimits new_value)> value_changing;
/// <summary>
/// This event is raised immediately after a new value is assigned to <see cref="data"/>.
/// </summary>
public event Action<(AccountSecurityRiskLimits old_value, AccountSecurityRiskLimits new_value)> value_changed;
public event Action is_dirty_changed;
public SecurityImmutable? security => _committed_data.security;
public uint security_key => _committed_data.security_key;
public string account_name => _committed_data.account_name;
public uint account_key => _committed_data.account_key;
public AccountSecurityKey id { get; }
public SecurityImmutable? security => data.security;
public string security_text => is_persisted ? security.ToString() : $"*{security}";
public uint security_key => data.security_key;
public string account_name => data.account_name;
public uint account_key => data.key.account;
// position limit
public bool is_position_limit_enabled { get => _mutable_limits.is_position_limit_enabled; set => _set_limits(_mutable_limits.with(is_position_limit_enabled: value)); }
public uint max_long_position { get => _mutable_limits.max_long_position; set => _set_limits(_mutable_limits.with(max_long_position: value)); }
public uint max_short_position { get => _mutable_limits.max_short_position; set => _set_limits(_mutable_limits.with(max_short_position: value)); }
public bool is_position_limit_enabled { get => _limits.is_position_limit_enabled; set => _modify(new RiskLimitsModification(is_position_limit_enabled: value)); }
public uint max_long_position { get => _limits.max_long_position; set => _modify(new RiskLimitsModification(max_long_position: value)); }
public uint max_short_position { get => _limits.max_short_position; set => _modify(new RiskLimitsModification(max_short_position: value)); }
// clip limit
public bool is_clip_limit_enabled { get => _mutable_limits.is_clip_limit_enabled; set => _set_limits(_mutable_limits.with(is_clip_limit_enabled: value)); }
public uint clip_limit { get => _mutable_limits.clip_limit; set => _set_limits(_mutable_limits.with(clip_limit: value)); }
public bool is_clip_limit_enabled { get => _limits.is_clip_limit_enabled; set => _modify(new RiskLimitsModification(is_clip_limit_enabled: value)); }
public uint clip_limit { get => _limits.clip_limit; set => _modify(new RiskLimitsModification(clip_limit: value)); }
// price limit
public bool is_price_limit_enabled { get => _mutable_limits.is_price_limit_enabled; set => _set_limits(_mutable_limits.with(is_price_limit_enabled: value)); }
public double max_price { get => _mutable_limits.max_price; set => _set_limits(_mutable_limits.with(max_price: value)); }
public double min_price { get => _mutable_limits.min_price; set => _set_limits(_mutable_limits.with(min_price: value)); }
public AccountSecurityKey row_id => new AccountSecurityKey(account_key, security_key);
public AccountSecurityRiskLimits committed_data => _committed_data;
public bool is_price_limit_enabled { get => _limits.is_price_limit_enabled; set => _modify(new RiskLimitsModification(is_price_limit_enabled: value)); }
public double min_price { get => _limits.min_price; set => _modify(new RiskLimitsModification(min_price: value)); }
public double max_price { get => _limits.max_price; set => _modify(new RiskLimitsModification(max_price: value)); }
RiskLimits _mutable_limits {
get => _mutable_data.limits;
set => _mutable_data = _mutable_data.with(limits: value);
public bool is_persisted => committed_data.HasValue;
public bool is_dirty => !committed_data.HasValue || !committed_data.Value.Equals(data);
public AccountSecurityRiskLimits data { get; private set; }
public AccountSecurityRiskLimits? committed_data { get; private set; }
RiskLimits _limits => data.limits;
public static RiskLimitsVM create_placeholder(AccountSecurityRiskLimits state) {
var vm = new RiskLimitsVM(state.key);
vm.load(state, false);
return vm;
}
public AccountSecurityRiskLimits create() => _mutable_data;
public static RiskLimitsVM create_persisted(AccountSecurityRiskLimits state) {
var vm = new RiskLimitsVM(state.key);
vm.load(state, true);
return vm;
}
public void load_from(AccountSecurityRiskLimits value) {
using (_result_changed.defer_execution())
public void load(AccountSecurityRiskLimits new_state, bool is_committed) {
using (detect_property_changes()) {
_committed_data = value;
_mutable_data = value;
bool was_dirty = is_dirty;
if (is_committed)
committed_data = new_state;
if (!data.Equals(new_state)) {
value_changing?.Invoke((data, new_state));
var orig_state = data;
data = new_state;
value_changed?.Invoke((orig_state, new_state));
}
if (is_dirty != was_dirty)
is_dirty_changed?.Invoke();
}
}
public void apply_modifications(RiskLimitsModification m) =>
load_from(_committed_data.with(
_committed_data.limits.with(m.is_position_limit_enabled,
m.max_long_position,
m.max_short_position,
m.is_clip_limit_enabled,
m.clip_limit,
m.is_price_limit_enabled,
m.min_price,
m.max_short_position),
new AccountTuple(_committed_data.account_key, _committed_data.account_name),
m.security));
public bool Equals(RiskLimitsVM other) =>
other != null && id == other.id;
void _set_limits(RiskLimits new_limits, [CallerMemberName] string prop = "") =>
_set_limits(new_limits, new[] { prop });
public override bool Equals(object obj) =>
Equals(obj as RiskLimitsVM);
void _set_limits(RiskLimits new_limits, params string[] invalidate_props) {
if (!_mutable_limits.Equals(new_limits)) {
_mutable_limits = new_limits;
RaisePropertyChanged(invalidate_props);
_result_changed.execute();
public override int GetHashCode() =>
id.GetHashCode();
void _modify(RiskLimitsModification mod) {
var new_value = data.with(limits: mod.apply(data.limits));
if (committed_data.HasValue) {
// if the user just toggled one of the limits on/off, request an immediate update to persist the change
// (the on/off toggles are the only props that can be edited directly in the grid,
// the user might find it annoying if they have to click 'Save' just to turn the limits on/off.
var clims = committed_data.Value.limits;
load(new_value, false);
var revert_mod = new RiskLimitsModification(is_position_limit_enabled: clims.is_position_limit_enabled, is_clip_limit_enabled: clims.is_clip_limit_enabled, is_price_limit_enabled: clims.is_price_limit_enabled);
var reverted_lims = new_value = new_value.with(limits: revert_mod.apply(new_value.limits));
if (reverted_lims.limits.Equals(clims)) {
// since only the limit toggle props were reverted,
// the above equality indicates that only the limit toggle props were modified.
request_commit?.Invoke();
}
} else {
load(new_value, false);
}
}
}
@@ -36,27 +36,32 @@ namespace bts.shell.risk_management {
.wrap<AccountSecurityKey, AccountSecurityRiskLimits>(r => r.key);
static IComparer<RiskLimitsVM> _row_id_comparer =>
_data_row_id_comparer.wrap<AccountSecurityRiskLimits, RiskLimitsVM>(r => r.committed_data);
_data_row_id_comparer.wrap<AccountSecurityRiskLimits, RiskLimitsVM>(r => r.data);
readonly DeferrableActionWrapper _result_changed, _refresh_filter_changed, _selected_rows_changed;
readonly DeferrableActionWrapper _refresh_filter_changed, _selected_rows_changed, _dirty_rows_changed;
readonly ColumnSortManager _sort_manager;
readonly ObservableCollection<RiskManagementColumnModel> _columns = new ObservableCollection<RiskManagementColumnModel>();
readonly Dictionary<Columns, RiskManagementColumnModel> _column_map = new Dictionary<Columns, RiskManagementColumnModel>();
readonly SelectorVM<AccountTuple?, uint> _accounts_vm = new SelectorVM<AccountTuple?, uint>(acc => acc?.id ?? 0) { comparer = Comparer<AccountTuple>.Default.to_nullable() };
IReadOnlyDictionary<AccountSecurityKey, AccountSecurityRiskLimits> _cache = DictionaryHelper.empty<AccountSecurityKey, AccountSecurityRiskLimits>();
ImmutableSortedSet<RiskLimitsVM> _selected_rows = ImmutableSortedSet.Create(_row_id_comparer);
IList<AccountSecurityRiskLimits> _data_rows;
ImmutableSortedSet<RiskLimitsVM> _selected_rows = ImmutableSortedSet.Create(_row_id_comparer);
IComparer<AccountSecurityRiskLimits> _data_comparer = _data_row_id_comparer;
IComparer<RiskLimitsVM> _row_comparer;
IDisposable _import_limits_op;
ImmutableDictionary<AccountSecurityKey, RiskLimitsVM> _dirty_rows = ImmutableDictionary<AccountSecurityKey, RiskLimitsVM>.Empty;
Dictionary<AccountSecurityKey, RiskLimitsVM> _imported_row_map = new Dictionary<AccountSecurityKey, RiskLimitsVM>();
Dictionary<AccountSecurityKey, RiskLimitsVM> _row_cache = new Dictionary<AccountSecurityKey, RiskLimitsVM>();
public RiskManagementVM(IObservable<TableUpdate<AccountSecurityRiskLimits, AccountSecurityKey>> data_source, IObservable<IReadOnlyList<AccountTuple>> accounts_source) {
_result_changed = new DeferrableActionWrapper(() => result_changed?.Invoke());
_selected_rows_changed = new DeferrableActionWrapper(() => selected_rows_changed?.Invoke());
_refresh_filter_changed = new DeferrableActionWrapper(() => _filter_changed?.Invoke(_mk_filter()));
_dirty_rows_changed = new DeferrableActionWrapper(() => dirty_rows_changed?.Invoke(dirty_rows));
_sort_manager = new ColumnSortManager(_columns.OfType<ISortableDIYGridColumn>(), null);
_data_rows = rows.WrapSelector(r => r.committed_data, lim => new RiskLimitsVM(lim));
_sort_manager.active_sorting_changed += () =>
data_comparer = _sort_manager.BuildComparer(id => _find_column(id)?.row_comparer, _data_comparer);
_data_rows = rows.WrapSelector(r => r.data, null);
_accounts_vm.selected_item_changed += () => {
RaisePropertyChanged(nameof(selected_account));
_result_changed.execute();
_refresh_filter_changed.execute();
};
column_map = FunctionalIndex.create<string, RiskManagementColumnModel>(_find_column);
@@ -66,7 +71,6 @@ namespace bts.shell.risk_management {
throw new InvalidOperationException();
}, c => c.id.ToString(), cs => cs.id);
}, null);
_refresh_filter_changed = new DeferrableActionWrapper(() => _filter_changed?.Invoke(_mk_filter()));
/////////////////
// Columns
/////////////////
@@ -155,6 +159,7 @@ namespace bts.shell.risk_management {
}).to_comparer();
_column_map = _columns.ToDictionary(c => c.id);
columns = ObservableAutoWrapper.SelectObservable(_columns, c => c);
var filter_source =
Observable.FromEvent<Func<AccountSecurityRiskLimits, bool>>(cb => _filter_changed += cb, cb => _filter_changed -= cb)
.StartWith(_mk_filter);
@@ -166,6 +171,7 @@ namespace bts.shell.risk_management {
f.filter_changed += _refresh_filter_changed.execute;
return Disposable.Create(() => f.filter_changed -= _refresh_filter_changed.execute);
}).ToList();
_accounts_vm.selected_item_changed += on_selected_account_changed;
_dispose = Disposable.Create(
ObservableAutoWrapper.connect_item_hooks(rows, subscribe_row_changes),
accounts_source.OnDispatcher().Subscribe(on_accounts),
@@ -209,13 +215,31 @@ namespace bts.shell.risk_management {
return col;
}
IDisposable subscribe_row_changes(RiskLimitsVM r) {
r.result_changed += on_limits_changed;
return Disposable.Create(() => r.result_changed -= on_limits_changed);
void on_limits_changed() {
var lim = r.create();
if (_cache.TryGetValue(lim.key, out var curr_lim) && !lim.Equals(curr_lim))
request_update_limit?.Invoke(lim);
IDisposable subscribe_row_changes(RiskLimitsVM row) {
row.value_changing += on_value_changing;
row.value_changed += on_value_changed;
row.request_commit += on_request_commit;
check_dirty();
return Disposable.Create(() => {
row.value_changing -= on_value_changing;
row.value_changed -= on_value_changed;
row.request_commit -= on_request_commit;
});
void on_value_changing((AccountSecurityRiskLimits old_value, AccountSecurityRiskLimits new_value) change) =>
on_row_data_changed(new Change<AccountSecurityRiskLimits>(change.old_value, change.new_value), false);
void on_value_changed((AccountSecurityRiskLimits old_value, AccountSecurityRiskLimits new_value) change) =>
check_dirty();
void on_request_commit() =>
request_update_limit?.Invoke(row.data);
void check_dirty() {
int dr_count = _dirty_rows.Count;
_dirty_rows = row.is_dirty ? _dirty_rows.Add(row.id, row) : _dirty_rows.Remove(row.id);
if (dr_count != _dirty_rows.Count)
_dirty_rows_changed.execute();
}
}
@@ -223,22 +247,85 @@ namespace bts.shell.risk_management {
_accounts_vm.update_items(new_accounts.Cast<AccountTuple?>());
void on_data(TableUpdate<AccountSecurityRiskLimits, AccountSecurityKey> table) {
_cache = table.state;
var comp = data_comparer;
_data_rows.RemoveSorted(table.removed.Concat(table.changes.Old()), comp);
_data_rows.InsertSorted(table.added.Concat(table.changes.New()), comp);
using (_dirty_rows_changed.defer_execution())
using (_selected_rows_changed.defer_execution()) {
foreach (var lim in table.removed) {
if (_row_cache.TryGetValue(lim.key, out var row)) {
_data_rows.RemoveSorted(row.data, data_comparer);
if (row.committed_data.HasValue)
_row_cache.Remove(lim.key);
}
}
foreach (var ch in table.changes) {
on_row_data_changed(ch, true);
}
foreach (var lim in table.added) {
if (_row_cache.TryGetValue(lim.key, out var row)) {
// if row is already here, it must be an import
// overwrite the import with the persisted row (this probably won't happen in practice)
rows.RemoveSorted(row, row_comparer);
_imported_row_map.Remove(lim.key);
}
var new_row = RiskLimitsVM.create_persisted(lim);
_row_cache[lim.key] = new_row;
rows.InsertSorted(new_row, row_comparer);
}
}
}
void on_row_data_changed(Change<AccountSecurityRiskLimits> change, bool is_persisted) {
Log.assert(_row_cache.TryGetValue(change.Old.key, out var row));
int old_index = CollectionHelper.binary_search(rows, row, row_comparer);
Log.assert(old_index >= 0);
int new_index = CollectionHelper.binary_search(_data_rows, change.New, _data_comparer);
// if the change came from the server (i.e., a persisted change that the row-vm doesn't already know about),
// load the new data (current modifications will be overwritten).
// Otherwise, the change is presumably the result of an uncommitted user-edit, which the row must already know about.
if (is_persisted) {
row.load(change.New, true);
if (_dirty_rows.Remove(row.id, out _dirty_rows))
_dirty_rows_changed.execute();
}
if (new_index < 0)
new_index = ~new_index;
if (Math.Abs(new_index - old_index) > 1) {
if (new_index > old_index)
new_index--;
rows.Move(old_index, new_index);
}
}
void on_selected_account_changed() {
foreach (var ir in _imported_row_map.Values) {
if (ir.account_key == selected_account?.id) {
rows.InsertOrReplaceSorted(ir, row_comparer);
} else {
rows.RemoveSorted(ir, row_comparer);
}
}
}
}
public event Action result_changed, selected_rows_changed;
public event Action selected_rows_changed;
public event Action<AccountSecurityRiskLimits> request_update_limit;
public event Action<ImmutableDictionary<AccountSecurityKey, RiskLimitsVM>> dirty_rows_changed;
event Action<Func<AccountSecurityRiskLimits, bool>> _filter_changed;
public IReadOnlyIndex<string, RiskManagementColumnModel> column_map { get; }
public bool has_unpersisted_limits => false;
// this collection is needed to control the column order
public IReadOnlyObservableCollection<IDIYGridColumn> columns { get; }
public ObservableCollection<RiskLimitsVM> rows { get; } = new ObservableCollection<RiskLimitsVM>();
public IReadOnlyList<RiskLimitsVM> selected_rows => _selected_rows;
/// <summary>
/// The selected rows are provided as an <see cref="ImmutableSortedSet{T}"/> so they can be observed/accessed on different threads.
/// <see cref="RiskManagementVMExtensions.subscribe_selected_rows(RiskManagementVM)"/>.
/// </summary>
public ImmutableSortedSet<RiskLimitsVM> selected_rows => _selected_rows;
/// <summary>
/// The dirty rows are provided as an <see cref="ImmutableDictionary{TKey, TValue}"/> so they can be observed/accessed on different threads.
/// <see cref="RiskManagementVMExtensions.subscribe_has_dirty_rows(RiskManagementVM)(RiskManagementVM)"/>.
/// </summary>
public ImmutableDictionary<AccountSecurityKey, RiskLimitsVM> dirty_rows => _dirty_rows;
public IReadOnlyObservableCollection<AccountTuple?> accounts => _accounts_vm.items;
public AccountTuple? selected_account {
get => _accounts_vm.selected_item ?? default;
@@ -251,13 +338,20 @@ namespace bts.shell.risk_management {
if (value != null) {
_data_comparer = value;
_row_comparer = null;
_data_rows.sync_with(_data_rows.Ordered(value).ToList());
rows.sync_with(rows.Ordered(row_comparer));
_selected_rows = _selected_rows.WithComparer(row_comparer);
}
}
}
public IComparer<RiskLimitsVM> row_comparer =>
_row_comparer ?? (_row_comparer = data_comparer?.wrap<AccountSecurityRiskLimits, RiskLimitsVM>(r => r.committed_data));
_row_comparer ?? (_row_comparer = data_comparer?.wrap<AccountSecurityRiskLimits, RiskLimitsVM>(r => r.data));
public IReadOnlyDictionary<uint, SecurityMD> security_map { get; set; } = DictionaryHelper.empty<uint, SecurityMD>();
public IReadOnlyDictionary<uint, IEnumerable<AccountSecurityRiskLimits>> build_account_limits_map() =>
_data_rows.GroupBy(dr => dr.account_key)
.ToDictionary(g => g.Key, g => g.AsEnumerable());
public RiskManagementSettings create() {
var grid = grid_settings_manager.create();
@@ -268,9 +362,10 @@ namespace bts.shell.risk_management {
public void load_from(RiskManagementSettings settings) {
if (settings is null)
throw new ArgumentNullException(nameof(settings));
using (_result_changed.defer_execution()) {
if (settings.grid != null)
grid_settings_manager.load_from(settings.grid);
if (settings.grid != null)
grid_settings_manager.load_from(settings.grid);
_sort_manager.SortingCriteria = settings.sorting_criteria;
using (_refresh_filter_changed.defer_execution()) {
foreach (var col in _columns)
col.load_from(null, settings.filters);
_accounts_vm.try_select(settings.account_id, true);
@@ -280,8 +375,49 @@ namespace bts.shell.risk_management {
public void load_from(GridSettings grid) {
if (grid is null)
throw new ArgumentNullException(nameof(grid));
using (_result_changed.defer_execution())
grid_settings_manager.load_from(grid);
grid_settings_manager.load_from(grid);
}
public void modify_rows(IEnumerable<AccountSecurityKey> targets, RiskLimitsModification mod) {
foreach (var key in targets) {
if (_row_cache.TryGetValue(key, out var row)) {
var new_data = row.data.with(limits: mod.apply(row.data.limits));
row.load(new_data, false);
}
}
}
public void revert(IEnumerable<RiskLimitsVM> targets) {
foreach (var row in targets) {
if (row.committed_data.HasValue)
row.load(row.committed_data.Value, true);
}
}
public void import_limits(string file_name) {
Disposable.dispose(ref _import_limits_op);
_import_limits_op = RiskLimitsImporter.import_limits(file_name,
security_map,
accounts.Where(a => a.HasValue)
.ToDictionary(a => a.Value.id, a => a.Value.name),
add_imported_rows);
void add_imported_rows(IEnumerable<ParsedRiskLimits> imported_rows) {
foreach (var ir in imported_rows) {
var res = ir.result;
if (!res.security.HasValue && security_map.TryGetValue(res.security_key, out var sec_md))
res = res.with(security: sec_md.security);
if (string.IsNullOrEmpty(res.account_name) && accounts.TryGetFirst(a => a?.id == res.account_key, out var acc))
res = res.with(account: acc);
if (_row_cache.TryGetValue(res.key, out var old_row))
rows.RemoveSorted(old_row, row_comparer);
var new_row = RiskLimitsVM.create_placeholder(res);
_row_cache[res.key] = new_row;
_imported_row_map[res.key] = new_row;
if (new_row.account_key == selected_account?.id)
rows.InsertSorted(new_row, row_comparer);
}
}
}
void IHandleRowSelection.row_selection_changed(SelectionChangedEventArgs e) {
@@ -293,7 +429,7 @@ namespace bts.shell.risk_management {
void IHandleGridSorting.on_sorting(object sender, DIYGridSortingEventArgs e) {
_sort_manager.OnColumnClick(e.Column, KeyboardExtensions.IsShiftDown());
data_comparer = _sort_manager.BuildComparer(id => _find_column(id)?.row_comparer, _data_comparer);
e.Handled = true;
}
RiskManagementColumnModel _find_column(string key_str) =>
@@ -310,4 +446,33 @@ namespace bts.shell.risk_management {
return lim => lim.account_key == acc_id && (col_filter_pred is null || col_filter_pred(lim));
}
}
static class RiskManagementVMExtensions {
public static IObservable<ImmutableSortedSet<RiskLimitsVM>> subscribe_selected_rows(this RiskManagementVM vm) =>
vm is null ?
throw new ArgumentNullException(nameof(vm)) :
Observable.Create<ImmutableSortedSet<RiskLimitsVM>>(o => {
o.OnNext(vm.selected_rows);
vm.selected_rows_changed += on_selected_rows_changed;
return Disposable.Create(() => vm.selected_rows_changed -= on_selected_rows_changed);
void on_selected_rows_changed() =>
o.OnNext(vm.selected_rows);
})
.SubscribeOnDispatcher();
public static IObservable<bool> subscribe_has_dirty_rows(this RiskManagementVM vm) =>
vm is null ?
throw new ArgumentNullException(nameof(vm)) :
Observable.Create<bool>(o => {
bool last_fired = vm.dirty_rows.Count > 0;
o.OnNext(last_fired);
vm.dirty_rows_changed += on_dirty_rows_changed;
return Disposable.Create(() => vm.dirty_rows_changed -= on_dirty_rows_changed);
void on_dirty_rows_changed(ImmutableDictionary<AccountSecurityKey, RiskLimitsVM> drs) {
if (last_fired != drs.Count > 0)
o.OnNext(last_fired = !last_fired);
}
})
.SubscribeOnDispatcher();
}
}
@@ -0,0 +1,39 @@
<Window
x:Class="bts.shell.risk_management.RiskLimitsImportConflictsDialog"
x:ClassModifier="internal"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:risk="clr-namespace:bts.shell.risk_management"
xmlns:u="clr-namespace:mbts.ui"
xmlns:c="clr-namespace:mbts.ui.controls"
u:WindowStyle.AllowResize="True"
u:WindowStyle.SizeToContent="WidthAndHeight"
u:WindowStyle.TitleContent="Import Limits Conflicts"
Style="{StaticResource BTSDialogTitleTemplate}"
>
<u:WindowStyle.TitleContentTemplate>
<DataTemplate>
<StackPanel Orientation="Horizontal" HorizontalAlignment="Left">
<Image Height="12" Margin="5,2" Source="{x:Static u:Icons.Import}"/>
<TextBlock Margin="4,0,0,0" Text="{Binding}"/>
</StackPanel>
</DataTemplate>
</u:WindowStyle.TitleContentTemplate>
<Window.Content>
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="*"/>
<RowDefinition Height="Auto"/>
</Grid.RowDefinitions>
<risk:RiskLimitsImportConflictsView Margin="12,10,12,8"/>
<c:DialogSkirt Grid.Row="1">
<c:DialogSkirt.RightItems>
<x:Array Type="{x:Type Button}">
<Button Command="{Binding ok_cmd}">Continue</Button>
<Button Command="{Binding cancel_cmd}" IsCancel="True">Cancel</Button>
</x:Array>
</c:DialogSkirt.RightItems>
</c:DialogSkirt>
</Grid>
</Window.Content>
</Window>
@@ -0,0 +1,11 @@
using System.Windows;
namespace bts.shell.risk_management {
/// <summary>
/// Interaction logic for RiskLimitsImportConflictsDialog.xaml
/// </summary>
partial class RiskLimitsImportConflictsDialog : Window {
public RiskLimitsImportConflictsDialog() =>
InitializeComponent();
}
}
@@ -0,0 +1,141 @@
<UserControl
x:Class="bts.shell.risk_management.RiskLimitsImportConflictsView"
x:ClassModifier="internal"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:risk="clr-namespace:bts.shell.risk_management"
xmlns:u="clr-namespace:mbts.ui"
xmlns:c="clr-namespace:mbts.ui.controls"
xmlns:cv="clr-namespace:mbts.ui.converters"
MinWidth="400"
>
<UserControl.Resources>
<Style x:Key="VerticallyCenteredText" TargetType="TextBlock">
<Setter Property="VerticalAlignment" Value="Center"/>
</Style>
<DataTemplate x:Key="UIntTemplate">
<c:TickUpDownUInt Value="{Binding value, UpdateSourceTrigger=PropertyChanged}"/>
</DataTemplate>
<DataTemplate x:Key="DoubleTemplate">
<c:TickUpDownDouble Value="{Binding value, UpdateSourceTrigger=PropertyChanged}"/>
</DataTemplate>
<DataTemplate x:Key="BooleanTemplate">
<CheckBox IsChecked="{Binding value}"/>
</DataTemplate>
<DataTemplate x:Key="PriceReadTemplate">
<TextBlock Text="{Binding value, Converter={StaticResource DoubleTextConverter}}" VerticalAlignment="Center"/>
</DataTemplate>
<!--Value Cell Template Selector-->
<u:KeyedTemplateSelector x:Key="ValueCellTemplateSelector">
<u:KeyedTemplateSelector.Default>
<DataTemplate>
<TextBlock Text="{Binding value}" VerticalAlignment="Center"/>
</DataTemplate>
</u:KeyedTemplateSelector.Default>
<u:TemplateSelectorKeyValue Key="{x:Static MinPrice, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}" Value="{StaticResource PriceReadTemplate}"/>
<u:TemplateSelectorKeyValue Key="{x:Static MaxPrice, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}" Value="{StaticResource PriceReadTemplate}"/>
</u:KeyedTemplateSelector>
<!--Value Cell Editing Template Selector-->
<u:KeyedTemplateSelector x:Key="ValueCellEditingTemplateSelector">
<u:TemplateSelectorKeyValue Key="{x:Static Security, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}">
<DataTemplate>
<c:ContractPickerPopup
HorizontalAlignment="Stretch"
VerticalAlignment="Stretch"
CloseOnCancel="True"
CloseOnOK="True"
Header="{Binding value}"
IsEditMode="False"
IsLazy="True"
SecurityMap="{Binding DataContext.security_map, RelativeSource={RelativeSource AncestorType=DataGrid}, Mode=OneWay}"
SelectedSecurity="{Binding value, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
ShowDialogSkirt="True"
/>
</DataTemplate>
</u:TemplateSelectorKeyValue>
<u:TemplateSelectorKeyValue Key="{x:Static Account, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}">
<DataTemplate>
<ComboBox ItemsSource="{Binding DataContext.accounts, RelativeSource={RelativeSource AncestorType=DataGrid}}" SelectedItem="{Binding value, UpdateSourceTrigger=PropertyChanged}"/>
</DataTemplate>
</u:TemplateSelectorKeyValue>
<u:TemplateSelectorKeyValue Key="{x:Static MaxNetLongPosition, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}" Value="{StaticResource UIntTemplate}"/>
<u:TemplateSelectorKeyValue Key="{x:Static MaxNetShortPosition, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}" Value="{StaticResource UIntTemplate}"/>
<u:TemplateSelectorKeyValue Key="{x:Static IsPositionLimitEnabled, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}" Value="{StaticResource BooleanTemplate}"/>
<u:TemplateSelectorKeyValue Key="{x:Static ClipLimit, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}" Value="{StaticResource UIntTemplate}"/>
<u:TemplateSelectorKeyValue Key="{x:Static IsClipLimitEnabled, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}" Value="{StaticResource BooleanTemplate}"/>
<u:TemplateSelectorKeyValue Key="{x:Static MinPrice, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}" Value="{StaticResource DoubleTemplate}"/>
<u:TemplateSelectorKeyValue Key="{x:Static MaxPrice, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}" Value="{StaticResource DoubleTemplate}"/>
<u:TemplateSelectorKeyValue Key="{x:Static IsPriceLimitEnabled, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}" Value="{StaticResource BooleanTemplate}"/>
</u:KeyedTemplateSelector>
</UserControl.Resources>
<!--Content-->
<Grid x:Name="content_root">
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="*"/>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="*"/>
</Grid.ColumnDefinitions>
<Image VerticalAlignment="Center" Margin="0,0,8,0">
<Image.Source>
<Binding Source="{x:Static MessageBoxImage.Exclamation}">
<Binding.Converter>
<cv:SystemIconConverter/>
</Binding.Converter>
</Binding>
</Image.Source>
</Image>
<Canvas x:Name="text_canvas" Grid.Column="1" HorizontalAlignment="Stretch"/>
<TextBlock Grid.Column="1" TextWrapping="Wrap" Width="{Binding ActualWidth, ElementName=text_canvas}">
<Run Text="{Binding num_successfully_parsed_limits, Mode=OneWay}"/>
<Run Text="/"/>
<Run Text="{Binding num_limits, Mode=OneWay}"/>
<Run Text=" limit items have been successfully converted."/>
<Run Text="Resolve conflicts below by selecting a value to assign each affected limit item,"/>
<Run Text="or modify individual limit items in the main window."/>
<LineBreak/>
<LineBreak/>
<Run Text="Click 'Continue' to proceed to the main window."/>
</TextBlock>
<DataGrid
x:Name="data_grid"
u:DataGridBehavior.SingleClickEdit="True"
Grid.Row="1"
Grid.ColumnSpan="2"
AutoGenerateColumns="False"
CanUserAddRows="False"
CanUserDeleteRows="False"
CanUserReorderColumns="False"
CanUserSortColumns="True"
HeadersVisibility="All"
ItemsSource="{Binding rows_view}"
Margin="0,8,0,0"
MinRowHeight="17"
RowHeaderWidth="22"
>
<DataGrid.CellStyle>
<Style TargetType="DataGridCell" BasedOn="{StaticResource DataGridCellBaseStyle}">
<Setter Property="VerticalContentAlignment" Value="Stretch"/>
</Style>
</DataGrid.CellStyle>
<DataGrid.RowStyle>
<Style TargetType="DataGridRow">
<Setter Property="IsSelected" Value="{Binding is_selected, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"/>
<Style.Triggers>
<DataTrigger Binding="{Binding IsSelected, RelativeSource={RelativeSource Self}}" Value="True">
<Setter Property="Background" Value="{StaticResource SelectedRowBackground}"/>
</DataTrigger>
</Style.Triggers>
</Style>
</DataGrid.RowStyle>
<DataGrid.Columns>
<DataGridTextColumn Header="Component" Binding="{Binding component}" ElementStyle="{StaticResource VerticallyCenteredText}" IsReadOnly="True"/>
<DataGridTextColumn Header="Text" Binding="{Binding text}" ElementStyle="{StaticResource VerticallyCenteredText}" IsReadOnly="True"/>
<DataGridTextColumn Header="Affected Limit Items" Binding="{Binding affected_limits.Count}" ElementStyle="{StaticResource VerticallyCenteredText}" IsReadOnly="True"/>
<DataGridTemplateColumn Header="Value" CellTemplateSelector="{StaticResource ValueCellTemplateSelector}" CellEditingTemplateSelector="{StaticResource ValueCellEditingTemplateSelector}"/>
</DataGrid.Columns>
</DataGrid>
</Grid>
</UserControl>
@@ -0,0 +1,38 @@
using System.Windows.Controls;
namespace bts.shell.risk_management {
/// <summary>
/// Interaction logic for RiskLimitsImportConflictsView.xaml
/// </summary>
partial class RiskLimitsImportConflictsView : UserControl {
public RiskLimitsImportConflictsView() =>
InitializeComponent();
public enum RiskLimitsComponent {
Security,
Account,
MaxNetLongPosition,
MaxNetShortPosition,
IsPositionLimitEnabled,
ClipLimit,
IsClipLimitEnabled,
MinPrice,
MaxPrice,
IsPriceLimitEnabled
}
public static class RiskLimitsComponentNames {
public static readonly string
Security = RiskLimitsComponent.Security.ToString(),
Account = RiskLimitsComponent.Account.ToString(),
MaxNetLongPosition = RiskLimitsComponent.MaxNetLongPosition.ToString(),
MaxNetShortPosition = RiskLimitsComponent.MaxNetShortPosition.ToString(),
IsPositionLimitEnabled = RiskLimitsComponent.IsPositionLimitEnabled.ToString(),
ClipLimit = RiskLimitsComponent.ClipLimit.ToString(),
IsClipLimitEnabled = RiskLimitsComponent.IsClipLimitEnabled.ToString(),
MinPrice = RiskLimitsComponent.MinPrice.ToString(),
MaxPrice = RiskLimitsComponent.MaxPrice.ToString(),
IsPriceLimitEnabled = RiskLimitsComponent.IsPriceLimitEnabled.ToString();
}
}
}
@@ -15,6 +15,14 @@
Background="{StaticResource CommonBackground}"
>
<UserControl.Resources>
<cv:BooleanToObjectConverter x:Key="IsDirtyOpacityConverter">
<cv:BooleanToObjectConverter.ValueForFalse>
<sys:Double>1.0</sys:Double>
</cv:BooleanToObjectConverter.ValueForFalse>
<cv:BooleanToObjectConverter.ValueForTrue>
<sys:Double>0.6</sys:Double>
</cv:BooleanToObjectConverter.ValueForTrue>
</cv:BooleanToObjectConverter>
<Style x:Key="TextCell" TargetType="c:TextCell">
<Setter Property="VerticalAlignment" Value="Center"/>
<Setter Property="Padding" Value="2,0"/>
@@ -27,6 +35,7 @@
<Setter Property="FontFamily" Value="{Binding Path='(c:DIYGrid.Column).font_family', RelativeSource={RelativeSource Self}}"/>
<Setter Property="FontWeight" Value="{Binding Path='(c:DIYGrid.Column).font_weight', RelativeSource={RelativeSource Self}}"/>
<Setter Property="FontSize" Value="{Binding Path='(c:DIYGrid.Column).font_size', RelativeSource={RelativeSource Self}}"/>
<Setter Property="Opacity" Value="{Binding is_dirty, Converter={StaticResource IsDirtyOpacityConverter}}"/>
</Style>
<Style x:Key="CellBorder" TargetType="Border">
<Setter Property="HorizontalAlignment" Value="Stretch"/>
@@ -84,7 +93,7 @@
<c:TextCell
c:DIYGrid.ColumnKey="Security"
c:DIYGrid.Column="{Binding Path='DataContext.column_map[Security]', RelativeSource={RelativeSource AncestorType=c:DIYGrid}}"
Text="{Binding security}"
Text="{Binding security_text}"
Style="{StaticResource TextCell}"
/>
<c:TextCell
@@ -156,6 +165,13 @@
Style="{StaticResource LimitToggleSwitch}"
/>
</Border>
<!--<Border
c:DIYGrid.ColumnKey="IsDirty"
c:DIYGrid.Column="{Binding Path='DataContext.column_map[IsDirty]', RelativeSource={RelativeSource AncestorType=c:DIYGrid}}"
Style="{StaticResource CellBorder}"
>
<Image Source="{x:Static u:Icons.CheckMark}" Visibility="{Binding is_persisted, Converter={StaticResource BooleanToVisibilityConverter}}"/>
</Border>-->
</Grid>
</DataTemplate>
</c:DIYGrid.RowTemplate>
@@ -242,7 +242,8 @@ namespace mbts.ui.utility {
}
if (_map.Count != this.items.Count)
throw new InvalidOperationException("Map and items are out of sync (different item counts).");
try_select(target_key, _is_pending_selection || _items.Count == 0);
if (try_select(target_key, _is_pending_selection || _items.Count == 0) && _is_pending_selection)
_is_pending_selection = false;
}
}
@@ -112,6 +112,14 @@ namespace mbts.ui.shell {
protected bool Set<T>(ref T backing, T value, [CallerMemberName]string name = "") =>
Set(ref backing, value, EqualityComparer<T>.Default, name);
protected bool Set<T>(ref T backing, T value, [CallerMemberName] string name = "", params string[] dependent_props) {
if (Set(ref backing, value, EqualityComparer<T>.Default, name)) {
RaisePropertyChanged(dependent_props);
return true;
}
return false;
}
protected bool Set<T>(ref T backing, T value, IEqualityComparer<T> comparer, [CallerMemberName]string name = "") {
if (!comparer.Equals(backing, value)) {
backing = value;
@@ -1,28 +0,0 @@
using bts.api;
using System.ComponentModel.Composition;
namespace mbts.user.settings
{
[InheritedExport]
internal interface ISecurityBasedSettingsFactory
{
SecurityBasedSettings get(Venue exchange, SecurityType type, string symbol);
}
internal interface ISecurityBasedSettingsFactory<T> : ISecurityBasedSettingsFactory where T : class
{
}
[ProtoBuf.ProtoContract]
[ProtoBuf.ProtoInclude(100, typeof(SecurityTickSettings))]
internal abstract class SecurityBasedSettings
{
protected SecurityBasedSettings() { }
protected SecurityBasedSettings(SecurityTuple security) {
this.security = security;
}
[ProtoBuf.ProtoMember(1)]
public SecurityTuple security;
}
}
@@ -2,6 +2,7 @@
using mbts.spark.utilities;
using ProtoBuf;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Windows.Media;
@@ -119,4 +120,9 @@ namespace mbts.ui.controls.color_picker {
};
#endregion
}
static class ColorPaletteExtensions {
public static ObservableCollection<ColorPaletteVM> to_viewmodels(this IEnumerable<ColorPalette> source) =>
new ObservableCollection<ColorPaletteVM>(source.empty_if_null().Select(cp => new ColorPaletteVM(cp)));
}
}
@@ -265,6 +265,10 @@ namespace mbts.ui.controls {
get => GetValue(SortDirectionProperty) as ListSortDirection?;
set => SetValue(SortDirectionProperty, value);
}
ListSortDirection? ISortableDIYGridColumn.SortDirection {
get => SortDirection;
set => SetCurrentValue(SortDirectionProperty, value);
}
#region IsVisible
public static readonly DependencyProperty IsVisibleProperty =
@@ -323,6 +327,7 @@ namespace mbts.ui.controls {
model.width = Width;
width_changed += on_width_changed;
model.width_changed += on_model_width_changed;
model.result_changed += on_result_changed;
_model_hooks = Disposable.Create(() => {
width_changed -= on_width_changed;
model.width_changed -= on_model_width_changed;
@@ -336,6 +341,8 @@ namespace mbts.ui.controls {
model.width = value;
model.width_changed += on_model_width_changed;
}
void on_result_changed() =>
load_from(model.create());
}
/// important: don't access any dependency props in here.
@@ -370,7 +377,6 @@ namespace mbts.ui.controls {
original_width = settings.width;
SetCurrentValue(WidthProperty, original_width);
}
//
}
// 'fallback' font-params (aka 'grid-level' font-params)
@@ -6,7 +6,6 @@ using mbts.ui.shell;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Reflection;
using System.Runtime.CompilerServices;
@@ -22,19 +21,20 @@ namespace mbts.ui.controls {
}
}
interface IDIYGridColumnModel : DIYGrid.IFilterableColumn {
interface IDIYGridColumnModel : DIYGrid.IFilterableColumn, IValueFactoryVM<GridColumnSettings> {
string id { get; }
string column_template { get; }
IComparer row_comparer { get; }
double width { get; set; }
event Action<double> width_changed;
event Action result_changed;
}
interface IDIYGridColumnFactory {
DIYGrid.ColumnBase create_view();
}
class DIYGridColumnModel<TKey> : ViewModelBase, IDIYGridColumnModel, ISortableDIYGridColumn<TKey>, ISortableDIYGridColumn, IValueFactory<GridColumnSettings> where TKey : struct {
class DIYGridColumnModel<TKey> : ViewModelBase, IDIYGridColumnModel, ISortableDIYGridColumn<TKey>, ISortableDIYGridColumn, IValueFactoryVM<GridColumnSettings> where TKey : struct {
readonly DeferrableActionWrapper _result_changed;
FontWeight _fallback_font_weight;
@@ -96,15 +96,6 @@ namespace mbts.ui.controls {
width_changed?.Invoke(value);
}
}
double _actual_width;
public double actual_width {
get => _actual_width;
set {
_actual_width = value;
width = value;
RaisePropertyChanged(nameof(actual_width));
}
}
public bool is_visible { get => _is_visible; set => _set(ref _is_visible, value); }
public ListSortDirection? sort_direction { get => _sort_direction; set => Set(ref _sort_direction, value); }
public Color? background_color_override { get => _background_color_override; set => _set(ref _background_color_override, value); }
@@ -144,6 +135,31 @@ namespace mbts.ui.controls {
}
}
public void load_from(GridColumnSettings value) {
if (!value.strong_id<TKey>().Equals(id))
throw new ArgumentException("Column id in settings object does not match the column model's id.", nameof(value));
using (_result_changed.defer_execution())
using (_detect_result_changed())
using (detect_property_changes(nameof(font_color), nameof(font_weight), nameof(background_color))) {
display_name = value.display_name;
is_visible = value.is_visible;
font_color_override = value.font_color_override;
font_weight_override = value.font_weight_override;
background_color_override = value.background_color_override;
width = value.width;
horizontal_alignment = value.horizontal_alignment;
}
}
IDisposable _detect_result_changed() {
var orig_state = create();
return Disposable.Create(() => {
var curr_state = create();
if (!orig_state.Equals(curr_state))
result_changed?.Invoke();
});
}
bool _set<T>(ref T backing, T new_value, [CallerMemberName]string prop = null) =>
_set(ref backing, new_value, EqualityComparer<T>.Default, prop);
@@ -161,20 +177,6 @@ namespace mbts.ui.controls {
}
return false;
}
public void load_from(GridColumnSettings value) {
if (!value.strong_id<TKey>().Equals(id))
throw new ArgumentException("Column id in settings object does not match the column model's id.", nameof(value));
using (_result_changed.defer_execution()) {
display_name = value.display_name;
is_visible = value.is_visible;
font_color_override = value.font_color_override;
font_weight_override = value.font_weight_override;
background_color_override = value.background_color_override;
width = value.width;
horizontal_alignment = value.horizontal_alignment;
}
}
}
class DIYGridColumnModel<TKey, TRow, TGridFilter> : DIYGridColumnModel<TKey> where TKey : struct {
@@ -905,7 +905,7 @@ namespace mbts.ui.controls {
if (cb is null) {
cb = new DIYGridColumn { id = cm.id };
BindingOperations.SetBinding(cb, ColumnBase.HeaderProperty, new Binding(nameof(DIYGridColumnModel<int>.header)) { Source = cm });
BindingOperations.SetBinding(cb, ColumnBase.SortDirectionProperty, new Binding(nameof(DIYGridColumnModel<int>.sort_direction)) { Source = cm });
BindingOperations.SetBinding(cb, ColumnBase.SortDirectionProperty, new Binding(nameof(DIYGridColumnModel<int>.sort_direction)) { Source = cm, Mode = BindingMode.TwoWay });
cb.set_model(cm);
BindingOperations.SetBinding(cb, ColumnBase.IsVisibleProperty, new Binding(nameof(DIYGridColumnModel<int>.is_visible)) { Source = cm });
if (cm is IFilterableColumn fc) {
@@ -93,6 +93,25 @@ namespace mbts.ui.controls {
public uint Increment { get { return (uint)GetValue(IncrementProperty); } set { SetValue(IncrementProperty, value); } }
#region TickUpCommand
public static readonly DependencyProperty TickUpCommandProperty =
TickUpDown.TickUpCommandProperty.AddOwner(typeof(TickUpDownUInt));
public ICommand TickUpCommand {
get => GetValue(TickUpCommandProperty) as ICommand;
set => SetValue(TickUpCommandProperty, value);
}
#endregion
#region TickDownCommand
public static readonly DependencyProperty TickDownCommandProperty =
TickUpDown.TickDownCommandProperty.AddOwner(typeof(TickUpDownUInt));
public ICommand TickDownCommand {
get => GetValue(TickDownCommandProperty) as ICommand;
set => SetValue(TickDownCommandProperty, value);
}
#endregion
// explicit props
public bool EnableArrowKeyTick { get => _enable_arrow_key_tick.value; set => _enable_arrow_key_tick.value = value; }
public ModifierKeys ArrowKeyTickModifiers { get => _arrow_key_tick_modifiers.value; set => _arrow_key_tick_modifiers.value = value; }
@@ -120,13 +139,19 @@ namespace mbts.ui.controls {
}
void _tick_up() {
if (TickUpDownHelper.tick_up(Value, Increment, out uint result))
if (TickUpCommand is ICommand cmd) {
cmd.ExecuteIfCan(null);
} else if (TickUpDownHelper.tick_up(Value, Increment, out uint result)) {
SetCurrentValue(ValueProperty, result);
}
}
void _tick_down() {
if (TickUpDownHelper.tick_down(Value, Increment, out uint result))
if (TickDownCommand is ICommand cmd) {
cmd.ExecuteIfCan(null);
} else if (TickUpDownHelper.tick_down(Value, Increment, out uint result)) {
SetCurrentValue(ValueProperty, result);
}
}
}
}
@@ -1,4 +1,5 @@
using bts.api;
using mbts;
using mbts.spark;
using System;
using System.Globalization;
@@ -17,7 +18,8 @@ namespace mbts.ui.spark.converters {
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture) {
var price = get_val<double>(values, 0);
var spec = get_val<ContractSpecificationImmutable?>(values, 1) ?? SecurityDataHelper.Defaults.ContractSpecificationImmutable;
return spec.format(price);
var settings = get_val<mbts.user.settings.TickDisplaySettings>(values, 2);
return spec.format(price, settings);
}
public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture) =>
@@ -77,6 +77,16 @@ namespace mbts.ui {
var bytes = BitConverter.GetBytes(color);
return Color.FromArgb(bytes[3], bytes[2], bytes[1], bytes[0]);
}
/// <summary>
/// Creates a blended color, whose a, r, g, b channels are the average of two colors.
/// </summary>
public static Color blend_with(this Color color, Color other) =>
Color.FromArgb(
(byte)(((ushort)color.A + (ushort)other.A) / 2),
(byte)(((ushort)color.R + (ushort)other.R) / 2),
(byte)(((ushort)color.G + (ushort)other.G) / 2),
(byte)(((ushort)color.B + (ushort)other.B) / 2));
public static SolidColorBrush to_brush(this BTSColor color) =>
new SolidColorBrush(color);
@@ -1,388 +0,0 @@
using bts.api;
using bts.utils;
using mbts.co2;
using mbts.user.settings;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
namespace mbts.spark {
static class TickUtils {
internal static ContractSpecificationImmutable spec_or_default(this ContractSpecificationImmutable? spec) =>
spec.HasValue ? spec.Value : SecurityDataHelper.Defaults.ContractSpecificationImmutable;
internal static ContractSpecificationImmutable spec_or_default(this SecurityImmutable security) =>
security.HasContractSpec ? security.ContractSpec : SecurityDataHelper.Defaults.ContractSpecificationImmutable;
internal static ContractSpecificationImmutable spec_or_default(this SecurityImmutable? security) =>
security.HasValue && security.Value.HasContractSpec ? security.Value.ContractSpec : SecurityDataHelper.Defaults.ContractSpecificationImmutable;
public static ContractSpecificationImmutable spec_or_default(this SecurityMD? security_md) =>
(security_md?.security).spec_or_default();
public static double ticksize(this ContractSpecificationImmutable spec, double price) =>
Math.Abs(price) > spec.PriceBreak ? spec.HighTick : spec.LowTick;
public static string format(this ContractSpecificationImmutable spec, double price, double with_regard_to_price, bool in_tick_terms) {
double net_change = price - with_regard_to_price;
return (in_tick_terms) ?
TickStore.get(spec).format_without_decimal_part((net_change) / spec.ticksize(net_change)) :
TickStore.get(spec).format(net_change);
}
public static string format(this ContractSpecificationImmutable spec, double price) =>
TickStore.get(spec).format(price);
public static string format(this ContractSpecificationImmutable? spec, double price) =>
spec.spec_or_default().format(price);
public static string format(this ContractSpecificationImmutable spec, double price, double display_multiplier, bool show_commas, string nan_text) =>
TickStore.get(spec).format(price, display_multiplier, show_commas, nan_text);
public static string format(this ContractSpecificationImmutable? spec, double price, double display_multiplier, bool show_commas, string nan_text) =>
spec.spec_or_default().format(price, display_multiplier, show_commas, nan_text);
public static double parse(this ContractSpecificationImmutable spec, string text, double display_multiplier, string nan_text) =>
TickStore.get(spec).parse(text, display_multiplier, nan_text);
public static double parse(this ContractSpecificationImmutable? spec, string text, double display_multiplier, string nan_text) =>
spec.spec_or_default().parse(text, display_multiplier, nan_text);
public static bool is_integer_tick(ContractSpecificationImmutable spec) =>
spec.MainFraction == 0 &&
spec.PriceDisplayFormat == 0 &&
spec.LowTick > 0 &&
MathUtils.is_int(spec.LowTick) &&
spec.HighTick > 0 &&
MathUtils.is_int(spec.HighTick);
public static ContractSpecification create_integer_tick_spec(int low_tick) =>
create_integer_tick_spec(low_tick, low_tick);
public static ContractSpecification create_integer_tick_spec(int low_tick, int high_tick) {
var rv = SecurityDataHelper.Defaults.ContractSpecification;
rv.MainFraction = 0;
rv.SubFraction = 0;
rv.PriceDisplayFormat = 0;
rv.PriceBreak = 0;
rv.LowTick = low_tick;
rv.HighTick = high_tick;
return rv;
}
public static double low_tick(NativePriceSize[] bids, NativePriceSize[] asks) {
double low = bids[bids.Length - 1].price;
if (double.IsNaN(low))
low = bids.LastOrDefault(nps => nps.price, p => !double.IsNaN(p), double.NaN);
if (double.IsNaN(low))
low = asks[0].price;
return low;
}
public static double high_tick(NativePriceSize[] bids, NativePriceSize[] asks) {
double high = asks[asks.Length - 1].price;
if (double.IsNaN(high))
high = asks.LastOrDefault(nps => nps.price, p => !double.IsNaN(p), double.NaN);
if (double.IsNaN(high))
high = bids[0].price;
return high;
}
public static int? tickdiff(this ContractSpecificationImmutable spec, double x, double y) {
if (get_regional_ticks(spec).try_get_tickdiff(x, y, out int n_low, out int n_high))
return n_low + n_high;
return null;
}
public static int tickdiff_unchecked(this ContractSpecificationImmutable spec, double x, double y) {
(int n_low, int n_high) = get_regional_ticks(spec).tickdiff_unchecked(x, y);
return n_low + n_high;
}
public static double mid_tick(ContractSpecificationImmutable spec, double bid, double ask) {
double raw_mid;
if (double.IsNaN(bid)) {
if (double.IsNaN(ask)) return double.NaN;
raw_mid = ask;
} else if (double.IsNaN(ask)) {
raw_mid = bid;
} else {
raw_mid = (bid + ask) / 2.0;
}
double tick_size = spec.ticksize(raw_mid);
return raw_mid < 0 ?
raw_mid + (raw_mid % tick_size) :
raw_mid - (raw_mid % tick_size);
}
public static TickFactors deduce_ticks(IEnumerable<ContractSpecification> contract_specs) {
var ticks = new HashSet<TickFactors>(contract_specs.Select(TickStore.get).SelectMany(rtf => new[] { rtf.low_tick, rtf.high_tick }));
switch (ticks.Count) {
case 0: return TickStore.default_rtf.low_tick;
case 1: return ticks.First();
default:
double tick_base_lcm = MathUtils.LCM(ticks.Select(t => (int)t.tick_base));
double tick_unit_gcd = MathUtils.GCD(ticks.Select(t => t.tick_unit * (tick_base_lcm / t.tick_base)));
return new TickFactors(tick_base_lcm, tick_unit_gcd);
}
}
public static RegionalTickFactors get_tick_factors(ContractSpecificationImmutable spec) =>
TickStore.get(spec);
public static double tickup(this ContractSpecificationImmutable spec, double value) =>
TickStore.get(spec).tickup(value);
public static double tickup(this ContractSpecificationImmutable spec, double value, int count) {
if (count == 0) return value;
if (count < 0) return TickStore.get(spec).tickdown(value, (uint)(-count));
else return TickStore.get(spec).tickup(value, (uint)count);
}
public static double tickdown(this ContractSpecificationImmutable spec, double value) =>
TickStore.get(spec).tickdown(value);
public static double tickdown(this ContractSpecificationImmutable spec, double value, int count) {
if (count == 0) return value;
if (count < 0) return TickStore.get(spec).tickup(value, (uint)(-count));
else return TickStore.get(spec).tickdown(value, (uint)count);
}
public static bool tick_equals(this ContractSpecificationImmutable contract, double x, double y) =>
MathUtils.RoundFractionalUnits(x, contract.LowTick) == MathUtils.RoundFractionalUnits(y, contract.LowTick);
public static IEqualityComparer<double> tick_equality_comparer(this ContractSpecificationImmutable contract) =>
EqualityComparer.Create((double a, double b) => tick_equals(contract, a, b), x => MathUtils.RoundFractionalUnits(x, contract.LowTick));
public static int compare_tick_fallback_to_double(this ContractSpecificationImmutable contract, double x, double y) =>
tick_equals(contract, x, y) ? 0 : x.CompareTo(y);
public static double round_to_tick(this ContractSpecificationImmutable spec, double value) {
double intpart = (long)value;
double floatpart = value % 1;
double tick = spec.ticksize(value);
floatpart = ((int)(floatpart / tick)) * tick;
return intpart + floatpart;
}
public static decimal round_to_tick(this ContractSpecificationImmutable spec, decimal value) {
decimal intpart = (long)value;
decimal floatpart = value % 1;
decimal tick = (decimal)spec.ticksize((double)value);
floatpart = ((int)(floatpart / tick)) * tick;
return intpart + floatpart;
}
public static RegionalTickFactors get_regional_ticks(ContractSpecificationImmutable? spec) =>
spec.HasValue ? TickStore.get(spec.Value) : TickStore.default_rtf;
public static RegionalTickFactors get_regional_ticks(SecurityImmutable security) =>
get_regional_ticks(security.spec_or_default());
static TickFactors _inflate_to_base(TickFactors tick_factors, double new_base) =>
new TickFactors(new_base, tick_factors.tick_unit * new_base / tick_factors.tick_base);
public static class CompareUtils {
public static IComparer<double> base_comparer =>
Comparer<double>.Create(_compare_base);
public static IComparer<double> unit_comparer =>
Comparer<double>.Create(_compare_unit);
public static IComparer<TickFactors> base_unit_comparer =>
Comparer<TickFactors>.Create(bts.utils.CompareUtils.safe_comparison<TickFactors>(compare_base_unit));
public static int compare_base_unit(TickFactors a, TickFactors b) {
int comp = _compare_base(a.tick_base, b.tick_base);
return comp == 0 ? a.tick_unit.CompareTo(b.tick_unit) : comp;
}
static int _compare_base(double a, double b) {
double reduced_a = MathUtils.factor_out(a, 10);
double reduced_b = MathUtils.factor_out(b, 10);
int comp = reduced_a.CompareTo(reduced_b);
return comp == 0 ? a.CompareTo(b) : comp;
}
static int _compare_unit(double a, double b) =>
_compare_unit(a, b, 0, 0);
static int _compare_unit(double a, double b, int a_mult10, int b_mult10) {
// fractional-coins are a special case, as they may not be an integer to begin with
if (!MathUtils.is_int(a))
return _compare_unit(a * 10, b, ++a_mult10, b_mult10);
if (!MathUtils.is_int(b))
return _compare_unit(a, b * 10, a_mult10, ++b_mult10);
double reduced_a = a_mult10 > 0 ? a : MathUtils.factor_out(a, 10, 5);
double reduced_b = b_mult10 > 0 ? b : MathUtils.factor_out(b, 10, 5);
int comp = reduced_a.CompareTo(reduced_b);
return comp == 0 ? (a * Math.Pow(10, -a_mult10)).CompareTo(b * Math.Pow(10, -b_mult10)) : comp;
}
}
static class TickStore {
public static readonly RegionalTickFactors default_rtf = new RegionalTickFactors(new TickFactors(1000, 1), new TickFactors(1000, 1), double.MaxValue);
static readonly ConcurrentDictionary<SpecKey, RegionalTickFactors> _exchange_ticks = new ConcurrentDictionary<SpecKey, RegionalTickFactors>();
static readonly bool _som_ticks_fix_enabled = config.Configuration.get<bts.config.toggles.SOMTicksFix>().enabled;
public static RegionalTickFactors get(ContractSpecification spec) =>
_exchange_ticks.GetOrAdd(new SpecKey(spec), _create_rtf);
public static RegionalTickFactors get(ContractSpecificationImmutable spec) =>
_exchange_ticks.GetOrAdd(new SpecKey(spec), _create_rtf);
public static RegionalTickFactors get(SecurityImmutable security) =>
security.HasContractSpec ? get(security.ContractSpec) : default_rtf;
public static RegionalTickFactors get(SecurityImmutable? security) =>
security.HasValue ? get(security.Value) : default_rtf;
static RegionalTickFactors _create_rtf(SpecKey key) {
double tick_base = key.denominator;
if (tick_base == 0) {
// indicates tick is a decimal
tick_base = 100;
}
return _create_rtf(key.low_tick, key.high_tick, key.price_break, tick_base, key.display_digits);
}
static RegionalTickFactors _create_rtf(double low_tick, double high_tick, double price_break, double reduced_target_base, uint display_digits_override) {
var low_tf = _try_create_tf(low_tick, reduced_target_base, display_digits_override);
var high_tf = _try_create_tf(high_tick, reduced_target_base, display_digits_override);
if (low_tf == null) {
low_tf = high_tf ?? (high_tf = default_rtf.low_tick);
} else if (high_tf == null)
high_tf = low_tf;
else {
// if low/high tick-bases do not match, inflate the smaller base so they do
// Note: this assumes the tick-bases are related by factors of 10 (i.e. they have all the same prime factors except for a different number of pairs of 5 and 2, e.g. 64 and 640)
if (low_tf.tick_base > high_tf.tick_base) {
high_tf = _inflate_to_base(high_tf, low_tf.tick_base);
} else if (low_tf.tick_base < high_tf.tick_base) {
low_tf = _inflate_to_base(low_tf, high_tf.tick_base);
}
}
return new RegionalTickFactors(low_tf, high_tf, price_break);
}
/// <summary>
/// Creates TickFactors with a base equal to &quot;<paramref name="tick_base"/> * 10^n,&quot; where 'n' is a natural number (including 0).
/// <para>Note: If <paramref name="display_digits_override"/> is non-zero, 'n' will be &quot;<paramref name="display_digits_override"/> - Math.Ceiling(Log10(<paramref name="tick_base"/>))&quot;</para>
/// </summary>
/// <param name="tick_size">The raw tick-size.</param>
/// <param name="tick_base">The raw tick-base.</param>
/// <returns>Well-defined TickFactors</returns>
static TickFactors _try_create_tf(double tick_size, double tick_base, uint display_digits_override) {
var tf = _try_create_tf(tick_size, tick_base);
if (tf != null && display_digits_override > 0) {
int display_digit_diff = (int)display_digits_override - tf.display_digits();
if (_som_ticks_fix_enabled) {
// we can always add display_digits (i.e. dislpay_digit_diff > 0), of course the ticks can be expressed precisely with extra 0s.
// but if we are going to remove display_digits (i.e display_digit_diff < 0), we must make sure the tick_unit is large enough to be expressed precisely with that many fewer digits
// - "-display_digit_diff <= Math.Ceiling(Math.Log10(tf.tick_unit))" will tell us if the digits can be removed without compromising precision
// - unfortunately, we cannot rely on the exchange's ContractSpec for this, there is 1 known case where the data they give us is incorrect
// SOM spreads ContractSpec (from the exchange):
// LowTick: 0.0025 (aka 1/400, or 2/800)
// MainFraction: 8
// SubFraction: 0
// PriceDisplayFormat: 1
// - as you can see, this cannot possibly be formatted with 1 display digit, it ticks in increments of 1/400
// - in practice, to maintain the '8' base, we format this in increments of 2/800 (e.g. 1-000, 1-002, 1-004, and so on up to 1-778, 2-000)
if (display_digit_diff > 0 || (display_digit_diff < 0 && -display_digit_diff <= Math.Ceiling(Math.Log10(tf.tick_unit))))
tf = _inflate_to_base(tf, tf.tick_base * Math.Pow(10, display_digit_diff));
} else if (display_digit_diff != 0) {
tf = _inflate_to_base(tf, tf.tick_base * Math.Pow(10, display_digit_diff));
}
}
return tf;
}
/// <summary>
/// Creates TickFactors with a base equal to &quot;reduced_target_base * 10^n,&quot; where 'n' is a natural number (including 0).
/// </summary>
/// <param name="tick_size">The raw tick-size.</param>
/// <param name="reduced_target_base">The smallest acceptable tick-base.</param>
/// <returns>Well-defined TickFactors</returns>
static TickFactors _try_create_tf(double tick_size, double reduced_target_base) {
if (!_check_tick_size(tick_size))
return null;
double raw_base = 1 / tick_size;
double raw_base_log10 = Math.Log10(raw_base);
double reduced_target_base_log10 = Math.Log10(reduced_target_base);
double log10_diff = raw_base_log10 - reduced_target_base_log10;
if (MathUtils.is_int(log10_diff))
return raw_base > reduced_target_base ? new TickFactors(raw_base, 1) : new TickFactors(reduced_target_base, Math.Pow(10, -log10_diff));
int count = 0;
double factored_base = log10_diff > 0 ? reduced_target_base * Math.Pow(10, Math.Ceiling(log10_diff)) : reduced_target_base;
do {
// Note that the modulus operator is not used here due to rounding errors.
// Such a rounding errror was the cause of the bug https://bluetradesys.atlassian.net/browse/SP-283.
if (MathUtils.is_int(factored_base / raw_base))
return new TickFactors(factored_base, factored_base / raw_base);
factored_base *= 10;
} while (++count < 10);
return null;
}
static TickFactors _create_tf(double tick_size) {
if (!_check_tick_size(tick_size))
return default_rtf.low_tick;
double matched_unit = double.MinValue;
TickFactors matched_tf = null;
foreach (var kv in _exchange_ticks) {
if (kv.Key.high_tick == tick_size) {
return kv.Value.high_tick;
} else if (kv.Key.low_tick == tick_size) {
return kv.Value.low_tick;
} else if (is_better_match(kv.Key.high_tick)) {
matched_unit = kv.Key.high_tick;
matched_tf = kv.Value.high_tick;
} else if (is_better_match(kv.Key.low_tick)) {
matched_unit = kv.Key.low_tick;
matched_tf = kv.Value.low_tick;
}
}
return matched_tf ?? new TickFactors(1.0 / tick_size, 1);
bool is_better_match(double known_unit) =>
known_unit < tick_size && known_unit > matched_unit && tick_size % known_unit == 0;
}
static bool _check_tick_size(double tick_size) =>
tick_size > 0 && (tick_size <= 0.5 || MathUtils.is_int(tick_size));
struct SpecKey : IEquatable<SpecKey> {
public readonly uint denominator, display_digits;
public readonly double low_tick, high_tick, price_break;
public SpecKey(ContractSpecification spec)
: this(spec.MainFraction, spec.PriceDisplayFormat, spec.LowTick, spec.HighTick, spec.PriceBreak) { }
public SpecKey(ContractSpecificationImmutable spec)
: this(spec.MainFraction, spec.PriceDisplayFormat, spec.LowTick, spec.HighTick, spec.PriceBreak) { }
public SpecKey(uint denominator, uint display_digits, double low_tick, double high_tick, double price_break) {
this.denominator = denominator;
this.display_digits = display_digits;
this.low_tick = low_tick;
this.high_tick = high_tick;
this.price_break = price_break;
}
public bool Equals(SpecKey other) =>
denominator == other.denominator &&
display_digits == other.display_digits &&
low_tick == other.low_tick &&
high_tick == other.high_tick &&
price_break == other.price_break;
public override bool Equals(object obj) =>
obj is SpecKey sk && Equals(sk);
public override int GetHashCode() =>
EqualityComparer.aggregate_hash((int)denominator, (int)display_digits, low_tick.GetHashCode(), high_tick.GetHashCode(), price_break.GetHashCode());
}
}
}
}
@@ -122,6 +122,9 @@ namespace mbts.ui.utility.text {
public static string name(this System.Windows.Media.FontFamily font_family) =>
font_family.FamilyNames.Values.FirstOrDefault() ?? string.Empty;
public static string name_or_default(this System.Windows.Media.FontFamily font_family) =>
font_family?.FamilyNames?.Values?.FirstOrDefault() ?? StandardFontFamilyName;
public static string display_name(this System.Windows.Media.FontFamily family, double size) =>
$"{family}, {size} pt";
+1 -1
View File
@@ -12,7 +12,7 @@ using System.Threading.Tasks;
using security_key = System.UInt32;
namespace mbts.co2 {
unsafe class MDConsumerHandle {
public unsafe class MDConsumerHandle {
// Once is_initialized goes true it never goes false
public bool is_heart_beating { get { return Co2NativeMethods.md_consumer_is_heart_beating(_header); } }
+5 -1
View File
@@ -112,5 +112,9 @@ namespace mbts.co2 {
return !a.Equals(b);
}
}
static class NativePriceSizeExtensions {
public static NativePriceSize with(this NativePriceSize nps, uint? direct_size = null, uint? implied_size = null) =>
new NativePriceSize(nps.int_price, direct_size ?? nps.direct_size, implied_size ?? nps.implied_size);
}
}
+1 -1
View File
@@ -3,7 +3,7 @@ using mbts.co2;
using System;
namespace mbts {
readonly struct SecurityMD : IEquatable<SecurityMD> {
public readonly struct SecurityMD : IEquatable<SecurityMD> {
public static readonly Func<SecurityMD, uint> key_fn = smd => smd.security.Id;
public SecurityImmutable security { get; }
+41
View File
@@ -23,6 +23,9 @@ namespace bts.utils {
public static bool epsilon_equals(double x, double y) =>
Math.Abs(x - y) < epsilon;
public static bool marginal_equals(double x, double y, double margin = epsilon) =>
Math.Abs(x - y) < margin;
public static double GCD(IEnumerable<double> nums) {
var no_zeros = nums.Where(n => n != 0);
if (!no_zeros.Any()) return 0;
@@ -102,6 +105,44 @@ namespace bts.utils {
public static int RoundFractionalUnits(double value, double fractional_unit) =>
(int)Math.Round(value / fractional_unit);
public static double round_down_abs(double value, double margin = epsilon) {
if (value < 0) {
return round_up(value, margin);
} else if (value > 0) {
return round_down(value, margin);
}
return 0;
}
public static double round_down(double value, double margin = epsilon) {
if (double.IsNaN(value) || double.IsInfinity(value))
return value;
var result = Math.Floor(value);
if (marginal_equals(value - result, 1, margin)) {
result = Math.Ceiling(value);
}
return result;
}
public static double round_up_abs(double value, double margin = epsilon) {
if (value < 0) {
return round_down(value, margin);
} else if (value > 0) {
return round_up(value, margin);
}
return 0;
}
public static double round_up(double value, double margin = epsilon) {
if (double.IsNaN(value) || double.IsInfinity(value))
return value;
var result = Math.Ceiling(value);
if (marginal_equals(result - value, 1, margin)) {
result = Math.Floor(value);
}
return result;
}
public static bool is_int(double d) =>
epsilon_equals(d, Math.Round(d));
@@ -83,6 +83,49 @@ namespace System.Collections.Generic {
return rv;
}
public static IEnumerable<TAccumulate> AggregateConsecutiveGroups<T, TGroupKey, TAccumulate>(
this IEnumerable<T> source,
Func<TAccumulate> seed_factory,
Func<TAccumulate, T, TAccumulate> aggregate,
Func<T, TGroupKey> group_key) =>
AggregateConsecutiveGroups(source, seed_factory, aggregate, group_key, EqualityComparer<TGroupKey>.Default);
public static IEnumerable<TAccumulate> AggregateConsecutiveGroups<T, TGroupKey, TAccumulate>(
this IEnumerable<T> source,
Func<TAccumulate> seed_factory,
Func<TAccumulate, T, TAccumulate> aggregate,
Func<T, TGroupKey> group_key,
IEqualityComparer<TGroupKey> group_key_comparer) {
//
if (source is null)
throw new ArgumentNullException(nameof(source));
if (seed_factory is null)
throw new ArgumentNullException(nameof(seed_factory));
if (aggregate is null)
throw new ArgumentNullException(nameof(aggregate));
if (group_key is null)
throw new ArgumentNullException(nameof(group_key));
if (group_key_comparer is null)
throw new ArgumentNullException(nameof(group_key_comparer));
using (var en = source.GetEnumerator()) {
if (en.MoveNext()) {
var curr_group = group_key(en.Current);
var agg = aggregate(seed_factory(), en.Current);
while (en.MoveNext()) {
var group = group_key(en.Current);
if (group_key_comparer.Equals(group, curr_group))
agg = aggregate(agg, en.Current);
else {
yield return agg;
curr_group = group;
agg = aggregate(seed_factory(), en.Current);
}
}
yield return agg;
}
}
}
public static bool CountAtLeast<T>(this IEnumerable<T> source, int count) {
if (count < 0)
throw new ArgumentException(ExceptionBuilder.Format.LessThan(0), nameof(count));
@@ -0,0 +1,24 @@
using System.Collections.Immutable;
namespace bts.collections {
static class ImmutableDictionaryExtensions {
/// <summary>
/// Adds the specified key/value pair if the dictionary does not already contain the key, otherwise replaces the value for that key.
/// </summary>
/// <returns><see cref="true"/> if a new key was added; otherwise <see cref="false"/>.</returns>
public static bool AddOrSet<TKey, TValue>(this ImmutableDictionary<TKey, TValue> dictionary, TKey key, TValue value, out ImmutableDictionary<TKey, TValue> result) {
int orig_count = dictionary.Count;
result = dictionary.SetItem(key, value);
return result.Count != orig_count;
}
/// <summary>
/// Removes the entry with specified key.
/// </summary>
/// <returns><see cref="true"/> if the entry was removed; otherwise <see cref="false"/>.</returns>
public static bool Remove<TKey, TValue>(this ImmutableDictionary<TKey, TValue> dictionary, TKey key, out ImmutableDictionary<TKey, TValue> result) {
result = dictionary.Remove(key);
return result.Count != dictionary.Count;
}
}
}
@@ -25,5 +25,21 @@ namespace bts.collections {
bd.Remove(v);
return bd.ToImmutable();
}
public static bool Add<T>(this ImmutableHashSet<T> source, T value, out ImmutableHashSet<T> result) {
int orig_count = source.Count;
result = source.Add(value);
return result.Count != orig_count;
}
public static ImmutableHashSet<T> AddRange<T>(this ImmutableHashSet<T> source, IEnumerable<T> value) {
if (source is null)
throw new ArgumentNullException(nameof(source));
if (value is null)
throw new ArgumentNullException(nameof(value));
var bd = source.ToBuilder();
bd.AddRange(value);
return bd.ToImmutable();
}
}
}
}
@@ -28,6 +28,15 @@ namespace bts.collections {
list.Insert(i < 0 ? ~i : i, value);
}
public static void InsertOrReplaceSorted<T>(this IList<T> list, T item, IComparer<T> comparer) {
int i = CollectionHelper.binary_search(list, item, comparer);
if (i < 0) {
list.Insert(~i, item);
} else {
list[i] = item;
}
}
public static bool RemoveSorted<T>(this IList<T> list, T item, IComparer<T> comparer) {
int i = CollectionHelper.binary_search(list, item, comparer);
if (i < 0)
@@ -0,0 +1,16 @@
using bts.api;
namespace mbts.user.settings
{
[ProtoBuf.ProtoContract]
[ProtoBuf.ProtoInclude(100, typeof(SecurityTickSettings))]
public abstract class SecurityBasedSettings {
protected SecurityBasedSettings() { }
protected SecurityBasedSettings(SecurityTuple security) {
this.security = security;
}
[ProtoBuf.ProtoMember(1)]
public SecurityTuple security;
}
}
@@ -11,7 +11,7 @@ namespace mbts
/// Wraps up a security type, security name and exchange
[ProtoContract]
[Serializable]
class SecurityTuple : IComparable<SecurityTuple>, IEquatable<SecurityTuple>
public class SecurityTuple : IComparable<SecurityTuple>, IEquatable<SecurityTuple>
{
[ProtoMember(1)]
public readonly SecurityType security_type;
@@ -30,7 +30,7 @@ namespace mbts
security_name = the_security_name;
security_exchange = the_security_exchange;
}
public SecurityTuple(co2.UserSymbol u) : this(u.type, u.symbol, u.exchange) { }
internal SecurityTuple(co2.UserSymbol u) : this(u.type, u.symbol, u.exchange) { }
public bool is_empty() { return Equals(empty); }
@@ -1,13 +1,11 @@
using bts.utils;
using mbts.spark.utilities;
using mbts.ui;
using ProtoBuf;
using System;
using System.ComponentModel;
namespace mbts.user.settings {
[ProtoContract]
class RegionalTickFactors : IEquatable<RegionalTickFactors> {
public class RegionalTickFactors : IEquatable<RegionalTickFactors> {
[ProtoMember(1)]
readonly TickFactors _low_tick;
[ProtoMember(2)]
@@ -24,11 +22,8 @@ namespace mbts.user.settings {
_low_tick_inclusive_end = low_tick_inclusive_end;
}
[DisplayInfo("Low")]
public TickFactors low_tick => _low_tick;
[DisplayInfo("High")]
public TickFactors high_tick => _high_tick;
[DisplayInfo("Inclusive Low Range End Pt")]
public double low_tick_inclusive_end => _low_tick_inclusive_end;
public bool Equals(RegionalTickFactors other) =>
@@ -60,4 +55,4 @@ namespace mbts.user.settings {
public static bool operator !=(RegionalTickFactors x, RegionalTickFactors y) => !(x == y);
}
}
}
@@ -1,21 +1,17 @@
using mbts.ui;
using ProtoBuf;
using ProtoBuf;
namespace mbts.user.settings
{
[DisplayInfo("Tick Settings")]
[ProtoContract]
class SecurityTickSettings : SecurityBasedSettings
public class SecurityTickSettings : SecurityBasedSettings
{
public SecurityTickSettings() {
price_tick = new RegionalTickFactors();
theo_tick = new TickFactors();
}
[DisplayInfo("Price", style = DisplayInfo.DisplayStyle.GroupBox)]
[ProtoMember(1)]
public RegionalTickFactors price_tick { get; set; }
[DisplayInfo("Theo")]
[ProtoMember(2)]
public TickFactors theo_tick { get; set; }
}
@@ -0,0 +1,34 @@
using System;
namespace mbts.user.settings {
public class TickDisplaySettings {
public bool pad_with_leading_zeros { get; set; } = true;
public double display_multiplier { get; set; } = double.NaN;
public bool show_commas { get; set; } = false;
public string nan_text { get; set; } = "-";
public bool show_decimal_part { get; set; } = true;
public bool show_zero_integer { get; set; } = true;
public static TickDisplaySettings Default =>
new TickDisplaySettings();
}
public static class TickDisplaySettingsExtensions {
public static TickDisplaySettings with(
this TickDisplaySettings settings,
bool? pad_with_leading_zeros = null,
double? display_multiplier = null,
bool? show_commas = null,
string nan_text = null,
bool? show_decimal_part = null,
bool? show_zero_integer = null) =>
new TickDisplaySettings {
pad_with_leading_zeros = pad_with_leading_zeros ?? settings.pad_with_leading_zeros,
display_multiplier = display_multiplier ?? settings.display_multiplier,
show_commas = show_commas ?? settings.show_commas,
nan_text = nan_text ?? settings.nan_text,
show_decimal_part = show_decimal_part ?? settings.show_decimal_part,
show_zero_integer = show_zero_integer ?? settings.show_zero_integer
};
}
}
@@ -1,14 +1,15 @@
using mbts.user.settings;
using System;
using System.Globalization;
using bts;
using static bts.utils.MathUtils;
using bts;
using bts.api;
using bts.utils;
using mbts.spark;
using mbts.user.settings;
using System;
using System.Globalization;
using static bts.utils.MathUtils;
namespace mbts {
static class TickExtensions {
const string _nan_text = "-";
public static class TickExtensions {
public static string _nan_text => TickDisplaySettings.Default.nan_text;
#region Public Extensions (is_valid, format, parse, tick_up, tick_down)
public static bool is_valid(this TickFactors tick) =>
@@ -18,6 +19,9 @@ namespace mbts {
public static bool is_valid(this RegionalTickFactors regional_tick) =>
regional_tick.low_tick.is_valid() && regional_tick.high_tick.is_valid();
public static bool is_integer(this TickFactors tick) =>
tick.tick_unit == tick.tick_base;
public static double tick_unit_frac(this TickFactors tick) =>
tick.tick_unit / tick.tick_base;
@@ -38,18 +42,27 @@ namespace mbts {
public static string format(this TickFactors tick, double value, double display_multiplier, bool show_commas) =>
format(tick, value, display_multiplier, show_commas, _nan_text);
public static string format(this TickFactors tick, double value, double display_multiplier, bool show_commas, string nan_text, bool hide_decimal_part = false) {
if (double.IsNaN(value)) return nan_text;
public static string format(this TickFactors tick, double value, TickDisplaySettings settings) {
if (settings is null)
settings = TickDisplaySettings.Default;
if (double.IsNaN(value)) return settings.nan_text;
if (double.IsInfinity(value)) return value.ToString();
if (!tick.is_valid()) return _format_no_tick(value, display_multiplier, show_commas);
return _format_tick(tick, double.IsNaN(display_multiplier) ? value : value * display_multiplier, show_commas, hide_decimal_part);
if (!tick.is_valid()) return _format_no_tick(value, settings.display_multiplier, settings.show_commas);
return _format_tick(tick, value, settings);
}
public static string format(this TickFactors tick, double value, double display_multiplier, bool show_commas, string nan_text, bool show_decimal_part = false) =>
tick.format(value, TickDisplaySettings.Default.with(
display_multiplier: display_multiplier,
show_commas: show_commas,
nan_text: nan_text,
show_decimal_part: show_decimal_part));
public static string format_without_decimal_part(this RegionalTickFactors regional_tick, double value) =>
format_without_decimal_part(value <= regional_tick.low_tick_inclusive_end ? regional_tick.low_tick : regional_tick.high_tick, value);
public static string format(this RegionalTickFactors regional_tick, double value) =>
format(value <= regional_tick.low_tick_inclusive_end ? regional_tick.low_tick : regional_tick.high_tick, value);
public static string format(this RegionalTickFactors regional_tick, double value, TickDisplaySettings settings = null) =>
format(value <= regional_tick.low_tick_inclusive_end ? regional_tick.low_tick : regional_tick.high_tick, value, settings);
public static string format(this RegionalTickFactors regional_tick, double value, double display_multiplier) =>
format(value <= regional_tick.low_tick_inclusive_end ? regional_tick.low_tick : regional_tick.high_tick, value, display_multiplier);
@@ -88,25 +101,33 @@ namespace mbts {
return _round_tick(tuf, val);
}
public static double tickup(this RegionalTickFactors regional_tick, double input) { return regional_tick.tickup(input, 1); }
public static double tickup(this RegionalTickFactors regional_tick, double input, uint count) {
public static double tickup(this RegionalTickFactors regional_tick, double input) =>
regional_tick.tickup(input, 1);
public static double tickup(this RegionalTickFactors regional_tick, double input, uint count) =>
regional_tick.tickup(input, count, TickUtils.precision_const);
public static double tickup(this RegionalTickFactors regional_tick, double input, uint count, double precision, bool bling = true) {
if (!precision.is_real_positive())
throw new ArgumentException(nameof(precision), "Must be a real positive number.");
if (DoubleHelper.IsNaNOrInfinity(input) || count == 0) return input;
double val, tuf;
if (input < regional_tick.low_tick_inclusive_end) {
tuf = regional_tick.low_tick.tick_unit_frac();
double ieeer = Math.IEEERemainder(input, tuf);
input -= ieeer;
if (ieeer < -_precision_const) count--;
if (ieeer < -precision) count--;
val = input + tuf * count;
if (val > regional_tick.low_tick_inclusive_end) {
count -= (uint)Math.Ceiling((regional_tick.low_tick_inclusive_end - input) / tuf);
count -= (uint)MathUtils.round_up((regional_tick.low_tick_inclusive_end - input) / tuf, precision);
tuf = regional_tick.high_tick.tick_unit_frac();
val = regional_tick.low_tick_inclusive_end + tuf * count;
}
} else {
tuf = regional_tick.high_tick.tick_unit_frac();
double ieeer = Math.IEEERemainder(input, tuf);
if (Math.Abs(ieeer) <= _precision_const) input -= ieeer;
input -= ieeer;
if (ieeer < -precision) count--;
val = input + tuf * count;
}
return _round_tick(tuf, val);
@@ -176,8 +197,6 @@ namespace mbts {
static int _count_ticks(double tick_unit_frac, double value) =>
(int)Math.Round(value / tick_unit_frac);
private const double _precision_const = 0.000000001;
public static double tickdown(this TickFactors tick, double input) { return tick.tickdown(input, 1); }
public static double tickdown(this TickFactors tick, double input, uint count) {
if (DoubleHelper.IsNaNOrInfinity(input)) return input;
@@ -188,25 +207,33 @@ namespace mbts {
return _round_tick(tuf, val);
}
public static double tickdown(this RegionalTickFactors regional_tick, double input) { return regional_tick.tickdown(input, 1); }
public static double tickdown(this RegionalTickFactors regional_tick, double input, uint count) {
public static double tickdown(this RegionalTickFactors regional_tick, double input) =>
regional_tick.tickdown(input, 1);
public static double tickdown(this RegionalTickFactors regional_tick, double input, uint count) =>
tickdown(regional_tick, input, count, TickUtils.precision_const);
public static double tickdown(this RegionalTickFactors regional_tick, double input, uint count, double precision) {
if (!precision.is_real_positive())
throw new ArgumentException(nameof(precision), "Must be a real positive number.");
if (DoubleHelper.IsNaNOrInfinity(input) || count == 0) return input;
double val, tuf;
if (input > regional_tick.low_tick_inclusive_end) {
tuf = regional_tick.high_tick.tick_unit_frac();
double ieeer = Math.IEEERemainder(input, tuf);
input -= ieeer;
if (ieeer > _precision_const) count--;
if (ieeer > precision) count--;
val = input - count * tuf;
if (val < regional_tick.low_tick_inclusive_end) {
count -= (uint)Math.Ceiling((input - regional_tick.low_tick_inclusive_end) / tuf);
count -= (uint)MathUtils.round_up((input - regional_tick.low_tick_inclusive_end) / tuf, precision);
tuf = regional_tick.low_tick.tick_unit_frac();
val = regional_tick.low_tick_inclusive_end - tuf * count;
}
} else {
tuf = regional_tick.low_tick.tick_unit_frac();
double ieeer = Math.IEEERemainder(input, tuf);
if (Math.Abs(ieeer) <= _precision_const) input -= ieeer;
input -= ieeer;
if (ieeer > precision) count--;
val = input - tuf * count;
}
return _round_tick(tuf, val);
@@ -294,41 +321,64 @@ namespace mbts {
return integer_part + numerator_part / tick.tick_base;
}
private static string _format_tick(TickFactors tick, double value, bool show_commas, bool hide_decimal_part) {
if (value < 0) return "-" + _format_tick(tick, Math.Abs(value), show_commas, hide_decimal_part);
try {
checked {
int integer_part = (int)Math.Floor(value);
double numerator_dec = value - integer_part;
double unit_frac = tick.tick_unit / tick.tick_base;
int n_units = (int)Math.Round(numerator_dec / unit_frac);
if (n_units == tick.tick_base) {
if (hide_decimal_part) {
return integer_part.ToString();
private static string _format_tick(TickFactors tick, double value, TickDisplaySettings settings) {
if (!settings.display_multiplier.is_nan())
value *= settings.display_multiplier;
// Hide the sign from the 'core_impl.' If the value is negative,
// flip it before calling core_impl, then prepend a '-' to the resultant string.
bool negate = value < 0;
if (negate)
value = -value;
var text = core_impl();
if (!settings.show_zero_integer) {
// Hide the integer if its zero. This could be better optimized,
// but speed shouldn't be an issue, so it doesn't seem worth the time/effort.
var parts = text.Split(tick.separator());
if (parts.Length > 1 && parts[0] == "0")
text = parts[1];
}
if (negate)
text = "-" + text;
return text;
// Formats a 'normalized' value. This method expects 'value' to be positive,
// and [already] multiplied by the display multiplier (if non-nan).
string core_impl() {
try {
checked {
int integer_part = (int)Math.Floor(value);
double numerator_dec = value - integer_part;
double unit_frac = tick.tick_unit / tick.tick_base;
int n_units = (int)Math.Round(numerator_dec / unit_frac);
if (n_units == tick.tick_base) {
if (settings.show_decimal_part) {
return (integer_part + 1).ToString() + tick.separator() + new string('0',
settings.pad_with_leading_zeros ? display_digits(tick.tick_base) : 1);
} else {
return integer_part.ToString();
}
}
double decimal_part = n_units * tick.tick_unit;
if (decimal_part == tick.tick_base) {
++integer_part;
decimal_part = 0;
} else {
return (integer_part + 1).ToString() + tick.separator() + new string('0', display_digits(tick.tick_base));
// some ticks are not formatted with 100% precision, using less than the required display_digits
// for such cases, we need to truncate the decimal part rather than round it.
decimal_part = Math.Floor(decimal_part);
}
string integer_part_text = settings.show_commas ? integer_part.ToString("#,0") : integer_part.ToString();
if (settings.show_decimal_part) {
return integer_part_text + tick.separator() + decimal_part.ToString(
settings.pad_with_leading_zeros ? new string('0', display_digits(tick.tick_base)) : "0");
} else {
return integer_part_text;
}
}
double decimal_part = n_units * tick.tick_unit;
if (decimal_part == tick.tick_base) {
++integer_part;
decimal_part = 0;
} else {
// some ticks are not formatted with 100% precision, using less than the required display_digits
// for such cases, we need to truncate the decimal part rather than round it.
decimal_part = Math.Floor(decimal_part);
}
string integer_part_text = show_commas ? integer_part.ToString("#,0") : integer_part.ToString();
if (hide_decimal_part) {
return integer_part_text;
} else {
return integer_part_text + tick.separator() + decimal_part.ToString(new string('0', display_digits(tick.tick_base)));
}
}
}
catch (OverflowException ex) {
Log.Ui.warn($"Arithmetic overflow exception in format_tick (tick:{tick}, value:{value}):{ex}");
return "Overflow";
catch (OverflowException ex) {
Log.Ui.warn($"Arithmetic overflow exception in format_tick (tick:{tick}, value:{value}):{ex}");
return "Overflow";
}
}
}
@@ -337,4 +387,4 @@ namespace mbts {
}
#endregion
}
}
}
@@ -1,11 +1,10 @@
using mbts.ui;
using ProtoBuf;
using ProtoBuf;
using System;
using System.ComponentModel;
namespace mbts.user.settings {
[ProtoContract]
class TickFactors : IEquatable<TickFactors> {
public class TickFactors : IEquatable<TickFactors> {
[ProtoMember(1), DefaultValue(100.0)]
readonly double _tick_base;
[ProtoMember(2), DefaultValue(1.0)]
@@ -19,9 +18,7 @@ namespace mbts.user.settings {
_tick_unit = tick_unit;
}
[DisplayInfo("Base")]
public double tick_base => _tick_base;
[DisplayInfo("Unit")]
public double tick_unit => _tick_unit;
public bool Equals(TickFactors other) =>
@@ -48,4 +45,4 @@ namespace mbts.user.settings {
public static bool operator !=(TickFactors x, TickFactors y) => !(x == y);
}
}
}
@@ -0,0 +1,144 @@
using bts.api;
using bts.utils;
using mbts;
using mbts.user.settings;
using System;
using System.Collections.Generic;
namespace bts.data.ticks {
class TickFactorsFactory {
static readonly RegionalTickFactors _default_rtf = new RegionalTickFactors(new TickFactors(1000, 1), new TickFactors(1000, 1), double.MaxValue);
readonly Dictionary<SpecKey, RegionalTickFactors> _exchange_ticks = new Dictionary<SpecKey, RegionalTickFactors>();
public RegionalTickFactors default_rtf => _default_rtf;
public RegionalTickFactors get(ContractSpecification spec) =>
_exchange_ticks.GetOrAdd(new SpecKey(spec), _create_rtf);
public RegionalTickFactors get(ContractSpecificationImmutable spec) =>
_exchange_ticks.GetOrAdd(new SpecKey(spec), _create_rtf);
public RegionalTickFactors get(SecurityImmutable security) =>
security.HasContractSpec ? get(security.ContractSpec) : _default_rtf;
public RegionalTickFactors get(SecurityImmutable? security) =>
security.HasValue ? get(security.Value) : _default_rtf;
static RegionalTickFactors _create_rtf(SpecKey key) {
double tick_base = key.denominator;
if (tick_base == 0) {
// indicates tick is a decimal
tick_base = 100;
}
return _create_rtf(key.low_tick, key.high_tick, key.price_break, tick_base, key.display_digits);
}
static RegionalTickFactors _create_rtf(double low_tick, double high_tick, double price_break, double reduced_target_base, uint display_digits_override) {
var low_tf = _try_create_tf(low_tick, reduced_target_base, display_digits_override);
var high_tf = _try_create_tf(high_tick, reduced_target_base, display_digits_override);
if (low_tf == null) {
low_tf = high_tf ?? (high_tf = _default_rtf.low_tick);
} else if (high_tf == null)
high_tf = low_tf;
else {
// if low/high tick-bases do not match, inflate the smaller base so they do
// Note: this assumes the tick-bases are related by factors of 10 (i.e. they have all the same prime factors except for a different number of pairs of 5 and 2, e.g. 64 and 640)
if (low_tf.tick_base > high_tf.tick_base) {
high_tf = _inflate_to_base(high_tf, low_tf.tick_base);
} else if (low_tf.tick_base < high_tf.tick_base) {
low_tf = _inflate_to_base(low_tf, high_tf.tick_base);
}
}
// if price break is not a multiple of both low/high tick, set it to nan
// (much simpler than trying to interpret data that is incorrect)
if (!price_break.is_real() || !MathUtils.is_int(price_break / low_tick) || !MathUtils.is_int(price_break / high_tick)) {
price_break = double.NaN;
high_tf = low_tf;
}
return new RegionalTickFactors(low_tf, high_tf, price_break);
}
/// <summary>
/// Creates TickFactors with a base equal to &quot;<paramref name="tick_base"/> * 10^n,&quot; where 'n' is a natural number (including 0).
/// <para>Note: If <paramref name="display_digits_override"/> is non-zero, 'n' will be &quot;<paramref name="display_digits_override"/> - Math.Ceiling(Log10(<paramref name="tick_base"/>))&quot;</para>
/// </summary>
/// <param name="tick_size">The raw tick-size.</param>
/// <param name="tick_base">The raw tick-base.</param>
/// <returns>Well-defined TickFactors</returns>
static TickFactors _try_create_tf(double tick_size, double tick_base, uint display_digits_override) {
var tf = _try_create_tf(tick_size, tick_base);
if (tf != null && display_digits_override > 0) {
int display_digit_diff = (int)display_digits_override - tf.display_digits();
if (display_digit_diff != 0) {
tf = _inflate_to_base(tf, tf.tick_base * Math.Pow(10, display_digit_diff));
}
}
return tf;
}
/// <summary>
/// Creates TickFactors with a base equal to &quot;reduced_target_base * 10^n,&quot; where 'n' is a natural number (including 0).
/// </summary>
/// <param name="tick_size">The raw tick-size.</param>
/// <param name="reduced_target_base">The smallest acceptable tick-base.</param>
/// <returns>Well-defined TickFactors</returns>
static TickFactors _try_create_tf(double tick_size, double reduced_target_base) {
if (!_check_tick_size(tick_size))
return null;
double raw_base = 1 / tick_size;
double raw_base_log10 = Math.Log10(raw_base);
double reduced_target_base_log10 = Math.Log10(reduced_target_base);
double log10_diff = raw_base_log10 - reduced_target_base_log10;
if (MathUtils.is_int(log10_diff))
return raw_base > reduced_target_base ? new TickFactors(raw_base, 1) : new TickFactors(reduced_target_base, Math.Pow(10, -log10_diff));
int count = 0;
double factored_base = log10_diff > 0 ? reduced_target_base * Math.Pow(10, Math.Ceiling(log10_diff)) : reduced_target_base;
do {
// Note that the modulus operator is not used here due to rounding errors.
// Such a rounding errror was the cause of the bug https://bluetradesys.atlassian.net/browse/SP-283.
if (MathUtils.is_int(factored_base / raw_base))
return new TickFactors(factored_base, factored_base / raw_base);
factored_base *= 10;
} while (++count < 10);
return null;
}
static TickFactors _inflate_to_base(TickFactors tick_factors, double new_base) =>
new TickFactors(new_base, tick_factors.tick_unit * new_base / tick_factors.tick_base);
static bool _check_tick_size(double tick_size) =>
tick_size > 0 && (tick_size <= 0.5 || MathUtils.is_int(tick_size));
struct SpecKey : IEquatable<SpecKey> {
public readonly uint denominator, display_digits;
public readonly double low_tick, high_tick, price_break;
public SpecKey(ContractSpecification spec)
: this(spec.MainFraction, spec.PriceDisplayFormat, spec.LowTick, spec.HighTick, spec.PriceBreak) { }
public SpecKey(ContractSpecificationImmutable spec)
: this(spec.MainFraction, spec.PriceDisplayFormat, spec.LowTick, spec.HighTick, spec.PriceBreak) { }
public SpecKey(uint denominator, uint display_digits, double low_tick, double high_tick, double price_break) {
this.denominator = denominator;
this.display_digits = display_digits;
this.low_tick = low_tick;
this.high_tick = high_tick;
this.price_break = price_break;
}
public bool Equals(SpecKey other) =>
denominator == other.denominator &&
display_digits == other.display_digits &&
low_tick == other.low_tick &&
high_tick == other.high_tick &&
price_break == other.price_break;
public override bool Equals(object obj) =>
obj is SpecKey sk && Equals(sk);
public override int GetHashCode() =>
EqualityComparer.aggregate_hash((int)denominator, (int)display_digits, low_tick.GetHashCode(), high_tick.GetHashCode(), price_break.GetHashCode());
}
}
}
@@ -0,0 +1,325 @@
using bts.api;
using bts.data.ticks;
using bts.utils;
using mbts.co2;
using mbts.user.settings;
using System;
using System.Collections.Generic;
using System.Linq;
namespace mbts.spark {
public static class TickUtils {
//const double _precision_const = 0.000000001;
const double _precision_const = 0.00000001;
public static double precision_const => _precision_const;
[ThreadStatic]
static TickFactorsFactory _exchange_ticks_backing;
static TickFactorsFactory _exchange_ticks =>
_exchange_ticks_backing ?? (_exchange_ticks_backing = new TickFactorsFactory());
internal static ContractSpecificationImmutable spec_or_default(this ContractSpecificationImmutable? spec) =>
spec.HasValue ? spec.Value : SecurityDataHelper.Defaults.ContractSpecificationImmutable;
internal static ContractSpecificationImmutable spec_or_default(this SecurityImmutable security) =>
security.HasContractSpec ? security.ContractSpec : SecurityDataHelper.Defaults.ContractSpecificationImmutable;
internal static ContractSpecificationImmutable spec_or_default(this SecurityImmutable? security) =>
security.HasValue && security.Value.HasContractSpec ? security.Value.ContractSpec : SecurityDataHelper.Defaults.ContractSpecificationImmutable;
public static ContractSpecificationImmutable spec_or_default(this SecurityMD? security_md) =>
(security_md?.security).spec_or_default();
public static IComparer<double> price_comparer(this ContractSpecificationImmutable spec) =>
MathUtils.epsilon_comparer.wrap<double, double>(p => spec.round_to_tick(p));
public static double ticksize(this ContractSpecificationImmutable spec, double price) {
if (!spec.LowTick.is_real_positive()) {
return spec.HighTick;
} else if (!spec.HighTick.is_real_positive()) {
return spec.LowTick;
} else if (!price.is_real() || !spec.PriceBreak.is_real()) {
return spec.LowTick;
} else {
return price > spec.PriceBreak ? spec.HighTick : spec.LowTick;
}
}
public static string format(this ContractSpecificationImmutable spec, double price, bool in_tick_terms) =>
in_tick_terms ?
_get(spec).format_without_decimal_part(price / spec.ticksize(price)) :
_get(spec).format(price);
public static string format(this ContractSpecificationImmutable spec, double price, TickDisplaySettings settings = null) =>
_get(spec).format(price, settings);
public static string format(this ContractSpecificationImmutable? spec, double price, TickDisplaySettings settings = null) =>
spec.spec_or_default().format(price, settings);
public static string format(this ContractSpecificationImmutable spec, double price, double display_multiplier, bool show_commas, string nan_text) =>
_get(spec).format(price, display_multiplier, show_commas, nan_text);
public static string format(this ContractSpecificationImmutable? spec, double price, double display_multiplier, bool show_commas, string nan_text) =>
spec.spec_or_default().format(price, display_multiplier, show_commas, nan_text);
public static double parse(this ContractSpecificationImmutable spec, string text, double display_multiplier, string nan_text) =>
_get(spec).parse(text, display_multiplier, nan_text);
public static double parse(this ContractSpecificationImmutable? spec, string text, double display_multiplier, string nan_text) =>
spec.spec_or_default().parse(text, display_multiplier, nan_text);
public static bool is_integer_tick(ContractSpecificationImmutable spec) =>
spec.MainFraction == 0 &&
spec.PriceDisplayFormat == 0 &&
spec.LowTick > 0 &&
MathUtils.is_int(spec.LowTick) &&
spec.HighTick > 0 &&
MathUtils.is_int(spec.HighTick);
public static ContractSpecification create_integer_tick_spec(int low_tick) =>
create_integer_tick_spec(low_tick, low_tick);
public static ContractSpecification create_integer_tick_spec(int low_tick, int high_tick) {
var rv = SecurityDataHelper.Defaults.ContractSpecification;
rv.MainFraction = 0;
rv.SubFraction = 0;
rv.PriceDisplayFormat = 0;
rv.PriceBreak = 0;
rv.LowTick = low_tick;
rv.HighTick = high_tick;
return rv;
}
public static double low_tick(NativePriceSize[] bids, NativePriceSize[] asks) {
double low = bids[bids.Length - 1].price;
if (double.IsNaN(low))
low = bids.LastOrDefault(nps => nps.price, p => !double.IsNaN(p), double.NaN);
if (double.IsNaN(low))
low = asks[0].price;
return low;
}
public static double high_tick(NativePriceSize[] bids, NativePriceSize[] asks) {
double high = asks[asks.Length - 1].price;
if (double.IsNaN(high))
high = asks.LastOrDefault(nps => nps.price, p => !double.IsNaN(p), double.NaN);
if (double.IsNaN(high))
high = bids[0].price;
return high;
}
public static int? tickdiff(this ContractSpecificationImmutable spec, double x, double y) {
if (get_regional_ticks(spec).try_get_tickdiff(x, y, out int n_low, out int n_high))
return n_low + n_high;
return null;
}
public static int tickdiff_unchecked(this ContractSpecificationImmutable spec, double x, double y) {
(int n_low, int n_high) = get_regional_ticks(spec).tickdiff_unchecked(x, y);
return n_low + n_high;
}
public static double mid_tick(ContractSpecificationImmutable spec, double bid, double ask) {
double raw_mid;
if (double.IsNaN(bid)) {
if (double.IsNaN(ask)) return double.NaN;
raw_mid = ask;
} else if (double.IsNaN(ask)) {
raw_mid = bid;
} else {
raw_mid = (bid + ask) / 2.0;
}
double tick_size = spec.ticksize(raw_mid);
return raw_mid < 0 ?
raw_mid + (raw_mid % tick_size) :
raw_mid - (raw_mid % tick_size);
}
public static TickFactors deduce_ticks(IEnumerable<ContractSpecification> contract_specs) {
var ticks = new HashSet<TickFactors>(contract_specs.Select(_get).SelectMany(rtf => new[] { rtf.low_tick, rtf.high_tick }));
switch (ticks.Count) {
case 0: return _exchange_ticks.default_rtf.low_tick;
case 1: return ticks.First();
default:
double tick_base_lcm = MathUtils.LCM(ticks.Select(t => (int)t.tick_base));
double tick_unit_gcd = MathUtils.GCD(ticks.Select(t => t.tick_unit * (tick_base_lcm / t.tick_base)));
return new TickFactors(tick_base_lcm, tick_unit_gcd);
}
}
public static RegionalTickFactors get_tick_factors(ContractSpecificationImmutable spec) =>
_get(spec);
public static double tickup(this ContractSpecificationImmutable spec, double value) =>
_get(spec).tickup(value);
public static double tickup(this ContractSpecificationImmutable spec, double value, int count) {
if (count == 0) return value;
if (count < 0) return _get(spec).tickdown(value, (uint)(-count));
else return _get(spec).tickup(value, (uint)count);
}
public static double tickdown(this ContractSpecificationImmutable spec, double value) =>
_get(spec).tickdown(value);
public static double tickdown(this ContractSpecificationImmutable spec, double value, int count) {
if (count == 0) return value;
if (count < 0) return _get(spec).tickup(value, (uint)(-count));
else return _get(spec).tickdown(value, (uint)count);
}
public static bool tick_equals(this ContractSpecificationImmutable contract, double x, double y) =>
MathUtils.RoundFractionalUnits(x, contract.LowTick) == MathUtils.RoundFractionalUnits(y, contract.LowTick);
public static IEqualityComparer<double> tick_equality_comparer(this ContractSpecificationImmutable contract) =>
EqualityComparer.Create((double a, double b) => tick_equals(contract, a, b), x => MathUtils.RoundFractionalUnits(x, contract.LowTick));
public static int compare_tick_fallback_to_double(this ContractSpecificationImmutable contract, double x, double y) =>
tick_equals(contract, x, y) ? 0 : x.CompareTo(y);
public static double round_to_tick(this ContractSpecificationImmutable spec, double value) {
double intpart = (long)value;
double floatpart = value % 1;
double tick = spec.ticksize(value);
floatpart = ((int)Math.Round(floatpart / tick)) * tick;
return intpart + floatpart;
}
public static decimal round_to_tick(this ContractSpecificationImmutable spec, decimal value) {
decimal intpart = (long)value;
decimal floatpart = value % 1;
decimal tick = (decimal)spec.ticksize((double)value);
floatpart = ((int)(floatpart / tick)) * tick;
return intpart + floatpart;
}
public static int? full_ticks_from_zero(this ContractSpecificationImmutable spec, double value) =>
full_ticks_from(spec, 0, value);
public static int? full_ticks_from(this ContractSpecificationImmutable spec, double origin, double value) {
if (!value.is_real() || !origin.is_real())
return null;
if (value < origin) {
if (spec.LowTick.is_real_positive()) {
if (spec.HighTick.is_real_positive() && spec.PriceBreak < origin && spec.PriceBreak > value) {
var ticks_to_break = MathUtils.round_up((spec.PriceBreak - origin) / spec.HighTick, precision_const);
var low_ticks_remainder = MathUtils.round_up((value - spec.PriceBreak) / spec.LowTick, precision_const);
return (int)(ticks_to_break + low_ticks_remainder);
} else {
return (int)MathUtils.round_up((value - origin) / spec.LowTick, precision_const);
}
} else if (spec.HighTick.is_real_positive()) {
return (int)MathUtils.round_up((value - origin) / spec.HighTick, precision_const);
}
} else {
if (spec.HighTick.is_real_positive()) {
if (spec.LowTick.is_real_positive() && spec.PriceBreak > origin && spec.PriceBreak < value) {
var ticks_to_break = MathUtils.round_down((spec.PriceBreak - origin) / spec.LowTick, precision_const);
var high_ticks_remainder = MathUtils.round_down((value - spec.PriceBreak) / spec.HighTick, precision_const);
return (int)(ticks_to_break + high_ticks_remainder);
} else {
return (int)MathUtils.round_down(value / spec.HighTick, precision_const);
}
} else if (spec.LowTick.is_real_positive()) {
return (int)MathUtils.round_down(value / spec.LowTick, precision_const);
}
}
return null;
}
public static RegionalTickFactors get_regional_ticks(ContractSpecificationImmutable? spec) =>
spec.HasValue ? _get(spec.Value) : _exchange_ticks.default_rtf;
public static RegionalTickFactors get_regional_ticks(SecurityImmutable security) =>
get_regional_ticks(security.spec_or_default());
public static ContractSpecificationImmutable multiply_tick_size(ContractSpecificationImmutable spec, uint factor) {
factor = fit_ticks_per_row_to_dollars(spec, factor);
return spec.with(low_tick: spec.LowTick * factor, high_tick: spec.HighTick * factor);
}
public static double normalize_price(ContractSpecificationImmutable spec, double price) {
var ticks = spec.full_ticks_from_zero(price);
return ticks.HasValue ? spec.tickup(0, ticks.Value) : price;
}
public static uint fit_ticks_per_row_to_dollars(ContractSpecificationImmutable spec, uint ticks_per_row) =>
_fit_ticks_per_row_to_dollars(spec, ticks_per_row) ?? 1;
static uint? _fit_ticks_per_row_to_dollars(ContractSpecificationImmutable spec, uint ticks_per_row) {
if (ticks_per_row == 0)
return null;
// it is assumed that low tick will be the same as high tick;
// however, best to double check - return null if this isn't the case (let the caller decide what to do).
var tf = get_tick_factors(spec);
if (!tf.low_tick.Equals(tf.high_tick) || !tf.is_valid() || tf.low_tick.is_integer())
return null;
var ticks_per_dollar = (uint)(tf.low_tick.tick_base / tf.low_tick.tick_unit);
// if ticks_per_row is greater than ticks_per_dollar, round to a multiple of ticks_per_dollar
if (ticks_per_row > ticks_per_dollar) {
return (uint)Math.Floor((double)(ticks_per_row / ticks_per_dollar));
} else if (ticks_per_row == ticks_per_dollar) {
return ticks_per_row;
} else {
uint max_decrease_adj = ticks_per_row;
uint max_increase_adj = ticks_per_dollar - ticks_per_row - 1;
for (uint adj = 0; adj < Math.Max(max_decrease_adj, max_increase_adj); adj++) {
if (adj < max_decrease_adj) {
var result = ticks_per_row - adj;
if (ticks_per_dollar % result == 0)
return result;
}
if (adj < max_increase_adj) {
var result = ticks_per_row + adj;
if (ticks_per_dollar % result == 0)
return result;
}
}
}
return null;
}
static RegionalTickFactors _get(ContractSpecification spec) => _exchange_ticks.get(spec);
static RegionalTickFactors _get(ContractSpecificationImmutable spec) => _exchange_ticks.get(spec);
public static class CompareUtils {
public static IComparer<double> base_comparer =>
Comparer<double>.Create(_compare_base);
public static IComparer<double> unit_comparer =>
Comparer<double>.Create(_compare_unit);
public static IComparer<TickFactors> base_unit_comparer =>
Comparer<TickFactors>.Create(bts.utils.CompareUtils.safe_comparison<TickFactors>(compare_base_unit));
public static int compare_base_unit(TickFactors a, TickFactors b) {
int comp = _compare_base(a.tick_base, b.tick_base);
return comp == 0 ? a.tick_unit.CompareTo(b.tick_unit) : comp;
}
static int _compare_base(double a, double b) {
double reduced_a = MathUtils.factor_out(a, 10);
double reduced_b = MathUtils.factor_out(b, 10);
int comp = reduced_a.CompareTo(reduced_b);
return comp == 0 ? a.CompareTo(b) : comp;
}
static int _compare_unit(double a, double b) =>
_compare_unit(a, b, 0, 0);
static int _compare_unit(double a, double b, int a_mult10, int b_mult10) {
// fractional-coins are a special case, as they may not be an integer to begin with
if (!MathUtils.is_int(a))
return _compare_unit(a * 10, b, ++a_mult10, b_mult10);
if (!MathUtils.is_int(b))
return _compare_unit(a, b * 10, a_mult10, ++b_mult10);
double reduced_a = a_mult10 > 0 ? a : MathUtils.factor_out(a, 10, 5);
double reduced_b = b_mult10 > 0 ? b : MathUtils.factor_out(b, 10, 5);
int comp = reduced_a.CompareTo(reduced_b);
return comp == 0 ? (a * Math.Pow(10, -a_mult10)).CompareTo(b * Math.Pow(10, -b_mult10)) : comp;
}
}
}
}
@@ -10,6 +10,11 @@ namespace bts.utils {
public static int safe_compare<T>(this T a, T b) where T : IComparable<T> =>
a == null ? (b == null ? 0 : -1) : (b == null ? 1 : a.CompareTo(b));
public static int nullable_compare<T>(T? a, T? b) where T : struct, IComparable<T> =>
a.HasValue ?
(b.HasValue ? a.Value.CompareTo(b.Value) : 1) :
(b.HasValue ? -1 : 0);
#region Equality
public static bool NullCheckEquals<T>(T x, T y) =>
NullCheckEquals(x, y, (_x, _y) => _x.Equals(_y));
+2 -2
View File
@@ -96,7 +96,7 @@
}
public static bool update_value_type<T>(ref T field, T newval) where T : struct, IEquatable<T> {
bool rv = field.Equals(newval);
bool rv = !field.Equals(newval);
field = newval;
return rv;
}
@@ -106,4 +106,4 @@
v => v is TResult r ? r : throw new InvalidCastException($"Failed to cast element in source collection from type {typeof(T)} to {typeof(TResult)}.");
}
}
}
}
@@ -6,6 +6,9 @@ using System.Threading.Tasks;
namespace System.Reactive.Linq {
public static class ObservableExtensions {
public static IObservable<bool> And(this IObservable<bool> source1, IObservable<bool> source2) =>
source1.CombineLatest(source2).Select(tup => tup.Item1 && tup.Item2);
/// <summary>
/// <para>Creates an "Observable Heartbeat" that will publish true/false to indicate whether or not the heartbeat is detected, it will only send updates when the 'heartbeat status' has changed.</para>
/// <para>Whenever the source produces an update, the heartbeat evaluates to true and the heartbeat duration clock is reset.</para>
@@ -0,0 +1,12 @@
using System.Collections.Generic;
namespace bts.tests.security {
public static class ContractSpecificationFiles {
public const string
Sim = "SimContractSpecifications.contract_spec_proto";
public static IEnumerable<string> all() {
yield return Sim;
}
}
}
@@ -0,0 +1,14 @@
using System.Collections.Generic;
namespace bts.tests.security {
public static class SecurityFiles {
public const string
KrandallOrderBookCrash = "KrandallOrderBookCrash.security_proto",
NonDeterministicICEFutures = "NonDeterministicICEFutures.security_proto";
public static IEnumerable<string> all() {
yield return KrandallOrderBookCrash;
yield return NonDeterministicICEFutures;
}
}
}
@@ -0,0 +1,13 @@
using bts.api;
using bts.resources;
using bts.utils.proto;
using System.Collections.Generic;
using System.Linq;
namespace bts.tests.security {
static class SecurityTestHelper {
public static IEnumerable<SecurityImmutable> read_securities(string file_path) =>
StreamHelper.ReadProtos<Security>(ResourceHelper.LoadResource(file_path))
.Select(s => new SecurityImmutable(s));
}
}
@@ -1,12 +1,16 @@
using bts.api;
using bts.collections;
using bts.mcore;
using bts.resources;
using bts.test;
using bts.utils;
using bts.utils.proto;
using mbts.spark;
using System;
using System.Collections.Generic;
using System.Linq;
namespace bts.mcore {
namespace bts.tests.security {
[TestGroup]
class SecurityTests {
[Test]
@@ -30,7 +34,7 @@ namespace bts.mcore {
[Test]
public void test_security_compare() {
foreach (var file_path in SecurityFiles.all())
_test_security_compare(_read_securities(file_path));
_test_security_compare(SecurityTestHelper.read_securities(file_path));
}
void _test_security_compare(IEnumerable<SecurityImmutable> securities) {
@@ -41,19 +45,5 @@ namespace bts.mcore {
ComparisonTests.transitive_comparison(sec_list, SecurityHelper.Comparer.InstanceImmutable);
ComparisonTests.identity_comparison(sec_list, SecurityHelper.Comparer.InstanceImmutable);
}
IEnumerable<SecurityImmutable> _read_securities(string file_path) =>
StreamHelper.ReadProtos<Security>(ResourceHelper.LoadResource(file_path)).Select(s => new SecurityImmutable(s));
static class SecurityFiles {
public const string
KrandallOrderBookCrash = "KrandallOrderBookCrash.security_proto",
NonDeterministicICEFutures = "NonDeterministicICEFutures.security_proto";
public static IEnumerable<string> all() {
yield return KrandallOrderBookCrash;
yield return NonDeterministicICEFutures;
}
}
}
}
@@ -0,0 +1,121 @@
using bts.api;
using bts.resources;
using bts.test;
using bts.utils;
using bts.utils.proto;
using mbts.spark;
using System;
using System.Collections.Generic;
using System.Linq;
namespace bts.tests.security {
static class TickTestHelper {
public static IEnumerable<double> generate_test_prices(double tick_size, int radius = 200, double origin_price = 0) {
Assert.That(radius > 0);
var price_base_set = Enumerable.Range(-radius, radius * 2).Select(
n => origin_price + tick_size * n);
return generate_test_prices(price_base_set, new[] {
0,
MathUtils.epsilon,
-MathUtils.epsilon,
MathUtils.epsilon * 100,
-MathUtils.epsilon * 100,
tick_size * 0.02,
-tick_size * 0.02,
tick_size * 0.49,
-tick_size * 0.49,
tick_size * 0.99,
-tick_size * 0.99,
});
}
public static IEnumerable<double> generate_test_prices(IEnumerable<double> price_base_set, IEnumerable<double> adjustments) =>
price_base_set.Concat(
adjustments.SelectMany(a => price_base_set.Select(p => p + a)));
public static IEnumerable<ContractSpecificationImmutable> read_contract_specs(string file_path) =>
StreamHelper.ReadProtos<ContractSpecification>(ResourceHelper.LoadResource(file_path)).Select(s => new ContractSpecificationImmutable(s));
public static int? full_ticks_from_zero(ContractSpecificationImmutable tick, double value) {
if (!value.is_real())
return null;
if (MathUtils.marginal_equals(value, 0, TickUtils.precision_const))
return 0;
bool low_tick_valid = tick.LowTick.is_real_positive();
bool high_tick_valid = tick.HighTick.is_real_positive();
if (low_tick_valid) {
if (high_tick_valid) {
if (value < 0) {
if (tick.PriceBreak > value) {
if (tick.PriceBreak >= 0) {
return (int)MathUtils.round_up(value / tick.LowTick, TickUtils.precision_const);
} else {
var high_ticks = (int)MathUtils.round_up(tick.PriceBreak / tick.HighTick, TickUtils.precision_const);
var low_ticks = (int)MathUtils.round_up((value - tick.PriceBreak) / tick.LowTick, TickUtils.precision_const);
return high_ticks + low_ticks;
}
} else {
return (int)MathUtils.round_up(value / (tick.PriceBreak.is_real() ? tick.HighTick : tick.LowTick), TickUtils.precision_const);
}
} else {
if (tick.PriceBreak < value) {
if (tick.PriceBreak <= 0) {
return (int)MathUtils.round_down(value / tick.HighTick, TickUtils.precision_const);
} else {
var low_ticks = (int)MathUtils.round_down(tick.PriceBreak / tick.LowTick, TickUtils.precision_const);
var high_ticks = (int)MathUtils.round_down((value - tick.PriceBreak) / tick.HighTick, TickUtils.precision_const);
return low_ticks + high_ticks;
}
} else {
return (int)MathUtils.round_down(value / (tick.PriceBreak.is_real() ? tick.LowTick : tick.HighTick), TickUtils.precision_const);
}
}
} else {
return (int)MathUtils.round_down_abs(value / tick.LowTick, TickUtils.precision_const);
}
} else if (high_tick_valid) {
return (int)MathUtils.round_down_abs(value / tick.HighTick, TickUtils.precision_const);
} else {
return null;
}
}
public static bool round_ticks(double tick_size, double value, out double rounded_value, out int rounded_ticks) {
if (!value.is_real() || !tick_size.is_real_positive()) {
rounded_value = double.NaN;
rounded_ticks = 0;
return false;
}
var ticks_to_val = value / tick_size;
ticks_to_val = ticks_to_val > 0 ? Math.Floor(ticks_to_val) : Math.Ceiling(ticks_to_val);
var rounded_down = ticks_to_val * tick_size;
var one_tick_up_abs = value > 0 ? rounded_down + tick_size : rounded_down - tick_size;
if (MathUtils.marginal_equals(one_tick_up_abs, value, TickUtils.precision_const)) {
rounded_value = one_tick_up_abs;
rounded_ticks = (int)(value > 0 ? ticks_to_val + 1 : ticks_to_val - 1);
} else {
rounded_value = rounded_down;
rounded_ticks = (int)ticks_to_val;
}
return true;
}
/// <summary>
/// Determines if the first tick in the specified direction should be a partial tick (to correct a rounding discrepency).
/// If this is so, it asserts that ticking up/down once in that direction corrects the rounding discrepency as expected.
/// </summary>
public static int check_partial_tick(ContractSpecificationImmutable spec, double value, double rounded_value, bool ticking_up) {
var partial_tick = count_partial_tick(value, rounded_value, ticking_up);
if (partial_tick != 0)
Assert.That(MathUtils.marginal_equals(spec.tickup(value, ticking_up ? partial_tick : -partial_tick), rounded_value, TickUtils.precision_const));
return partial_tick;
}
/// <summary>
/// Determines if the first tick in the specified direction should be a partial tick (to correct a rounding discrepency).
/// </summary>
public static int count_partial_tick(double value, double rounded_value, bool ticking_up) =>
(ticking_up ? (rounded_value - value) : (value - rounded_value)) > TickUtils.precision_const ?
1 : 0;
}
}
+226
View File
@@ -0,0 +1,226 @@
using bts.api;
using bts.test;
using bts.utils;
using mbts;
using mbts.spark;
using mbts.user.settings;
using System;
using System.Collections.Generic;
using System.Linq;
namespace bts.tests.security {
[TestGroup]
class TickTests {
[Test]
public void test_pad_with_leading_zeros() {
var settings = TickDisplaySettings.Default;
// Test with a decimal tick type: quarters
var tf = new TickFactors(100, 25);
// 25/100
// Show leading zeros
var res = tf.format(1, settings.with(pad_with_leading_zeros: true));
Assert.IsTrue(res == "1.00");
// Show leading zeros (with positive tick)
res = tf.format(1.25, settings.with(pad_with_leading_zeros: true));
Assert.IsTrue(res == "1.25");
// Hide leading zeros
res = tf.format(1, settings.with(pad_with_leading_zeros: false));
Assert.IsTrue(res == "1.0");
// Hide leading zeros (with positive tick)
res = tf.format(1.25, settings.with(pad_with_leading_zeros: false));
Assert.IsTrue(res == "1.25");
// Test with a non-decimal tick type: quarters of quarters of eigths
tf = new TickFactors(3200, 25);
// Show leading zeros
res = tf.format(1, settings.with(pad_with_leading_zeros: true));
Assert.IsTrue(res == "1-0000");
// Show leading zeros (with positive tick)
res = tf.format(1 + 100.0 / 3200.0, settings.with(pad_with_leading_zeros: true));
Assert.IsTrue(res == "1-0100");
// Hide leading zeros
res = tf.format(1, settings.with(pad_with_leading_zeros: false));
Assert.IsTrue(res == "1-0");
// Hide leading zeros (with positive tick)
res = tf.format(1 + 100.0 / 3200.0, settings.with(pad_with_leading_zeros: false));
Assert.IsTrue(res == "1-100");
}
[Test]
public void test_show_zero_integer() {
var settings = TickDisplaySettings.Default;
// Test with a decimal tick type: quarters
var tf = new TickFactors(100, 25);
// Show zero integer
var res = tf.format(0, settings.with(show_zero_integer: true));
Assert.IsTrue(res == "0.00");
// Show zero integer (with positive decimal)
res = tf.format(0.25, settings.with(show_zero_integer: true));
Assert.IsTrue(res == "0.25");
// Hide zero integer
res = tf.format(0, settings.with(show_zero_integer: false));
Assert.IsTrue(res == "00");
// Hide zero integer (with positive decimal)
res = tf.format(0.25, settings.with(show_zero_integer: false));
Assert.IsTrue(res == "25");
// Hide zero integer (with positive integer, non-zero decimal).
// The 'show_zero_integer' setting should bear no effect.
res = tf.format(1.25, settings.with(show_zero_integer: false));
Assert.IsTrue(res == "1.25");
// Hide zero integer (with negative decimal)
res = tf.format(-0.25, settings.with(show_zero_integer: false));
Assert.IsTrue(res == "-25");
// Hide zero integer (with negative integer, non-zero decimal).
// The 'show_zero_integer' setting should bear no effect.
res = tf.format(-1.25, settings.with(show_zero_integer: false));
Assert.IsTrue(res == "-1.25");
// Test with a non-decimal tick type: quarters of quarters of eigths
tf = new TickFactors(3200, 25);
// Hide zero integer (with positive tick)
res = tf.format(25.0/3200.0, settings.with(show_zero_integer: false));
Assert.IsTrue(res == "0025");
// Hide zero integer (with positive integer, non-zero tick).
// The 'show_zero_integer' setting should bear no effect.
res = tf.format(1 + 25.0/3200.0, settings.with(show_zero_integer: false));
Assert.IsTrue(res == "1-0025");
// Hide zero integer (with negative tick)
res = tf.format(-25.0/3200.0, settings.with(show_zero_integer: false));
Assert.IsTrue(res == "-0025");
// Hide zero integer (with negative tick, non-zero integer).
// The 'show_zero_integer' setting should bear no effect.
res = tf.format(-1 - 25.0/3200.0, settings.with(show_zero_integer: false));
Assert.IsTrue(res == "-1-0025");
// Hide zero integer (with negative tick), and hide leading zeros
res = tf.format(-25.0/3200.0, settings.with(show_zero_integer: false, pad_with_leading_zeros: false));
Assert.IsTrue(res == "-25");
// Hide zero integer (with negative integer, non-zero tick), and hide leading zeros.
// The 'show_zero_integer' setting should bear no effect.
res = tf.format(-1 - 25.0/3200.0, settings.with(show_zero_integer: false, pad_with_leading_zeros: false));
Assert.IsTrue(res == "-1-25");
// Hide zero integer (with negative tick)
res = tf.format(-25.0/3200.0, settings.with(show_zero_integer: false));
// This isn't pretty, but it's logical: a negative number,
// greater than -1, in tick form.
Assert.IsTrue(res == "-0025");
// Hide zero integer (with negative tick), and hide leading zeros
res = tf.format(-25.0/3200.0, settings.with(show_zero_integer: false, pad_with_leading_zeros: false));
// Should be the same as above, except without the leading zeros in the tick part.
Assert.IsTrue(res == "-25");
}
[Test]
public void test_tick_increment() {
var from_sec_files = SecurityFiles.all().SelectMany(SecurityTestHelper.read_securities).Select(s => s.ContractSpec);
var from_spec_files = ContractSpecificationFiles.all().SelectMany(TickTestHelper.read_contract_specs);
var distinct_specs = new HashSet<ContractSpecificationImmutable>(from_sec_files.Concat(from_spec_files));
foreach (var spec in distinct_specs)
_test_tick_increment(spec);
}
void _test_tick_increment(ContractSpecificationImmutable tick) {
// the prices straddle a particular number (the radius determines how far above/below the straddle the price range spans)
const int min_tick_radius = 200;
// some ticks can have more than 200 prices between integers (n and n+1)
const int min_int_radius = 2;
// test price range about zero
var prices_about_zero = TickTestHelper.generate_test_prices(tick.LowTick, radius: get_radius(tick.LowTick), origin_price: 0);
_test_tick_increment(tick, prices_about_zero);
// test price range about the price break
if (tick.PriceBreak.is_real()) {
var prices_about_break = TickTestHelper.generate_test_prices(tick.HighTick, radius: get_radius(tick.HighTick), origin_price: tick.PriceBreak);
_test_tick_increment(tick, prices_about_break);
}
int get_radius(double tick_size) {
Assert.That(tick_size.is_real_positive());
return Math.Max(min_tick_radius, (int)(min_int_radius / tick_size));
}
}
void _test_tick_increment(ContractSpecificationImmutable tick, IEnumerable<double> prices) {
Assert.That(!(tick.LowTick < 0));
Assert.That(!(tick.HighTick < 0));
foreach (var p in prices) {
var expected_ticks_from_zero = TickTestHelper.full_ticks_from_zero(tick, p);
var actual_ticks_from_zero = TickUtils.full_ticks_from_zero(tick, p);
if (expected_ticks_from_zero != actual_ticks_from_zero) {
expected_ticks_from_zero = TickTestHelper.full_ticks_from_zero(tick, p);
actual_ticks_from_zero = TickUtils.full_ticks_from_zero(tick, p);
}
Assert.That(expected_ticks_from_zero == actual_ticks_from_zero,
$"Expected ticks from zero to be '{expected_ticks_from_zero}', actually '{actual_ticks_from_zero}' " +
$"(low/high/pricebreak: {tick.LowTick}/{tick.HighTick}/{tick.PriceBreak}, price: {p}).");
if (expected_ticks_from_zero.HasValue) {
Assert.That(p.is_real());
_test_tick_increment(tick, p - 1, p);
if (tick.PriceBreak.is_real() && tick.PriceBreak != double.MaxValue && tick.PriceBreak != double.MinValue) {
// test both sides of the break with a few adjustments
foreach (var adjustment in new[] { 1, tick.LowTick, tick.HighTick }) {
_test_tick_increment(tick, p, tick.PriceBreak + adjustment);
_test_tick_increment(tick, p, tick.PriceBreak - adjustment);
}
}
}
}
}
void _test_tick_increment(ContractSpecificationImmutable spec, double from, double to) {
if (!from.is_real() || !to.is_real())
return;
var (min, max) = MathUtils.get_outliers(from, to);
if (spec.PriceBreak.is_real()) {
if (min >= spec.PriceBreak) {
//_test_single_tick(spec.HighTick, min, max);
} else if (max <= spec.PriceBreak) {
_test_tick_increment(spec, spec.LowTick, min, max);
} else {
//if (round_ticks(spec.LowTick, min, out var ))
_test_tick_increment_across_break(spec, min, max);
}
} else {
_test_tick_increment(spec, spec.LowTick, min, max);
}
}
void _test_tick_increment_across_break(ContractSpecificationImmutable spec, double min, double max) {
Assert.That(min < spec.PriceBreak);
Assert.That(max > spec.PriceBreak);
// 2 tick counts are used to determine the number of ticks between min and max,
// 1) number of ticks from min to the price break
// 2) number of ticks from the price break to max
// if either min/max is beyond epsilon away from a real tick,
// a partial tick is used to correct the rounding error.
Assert.That(TickTestHelper.round_ticks(spec.LowTick, spec.PriceBreak - min, out var rounded_min, out var min_ticks_to_break));
Assert.That(TickTestHelper.round_ticks(spec.HighTick, max - spec.PriceBreak, out var rounded_max, out var max_ticks_to_break));
rounded_min = spec.PriceBreak - rounded_min;
rounded_max = spec.PriceBreak + rounded_max;
int min_partial_tick = TickTestHelper.check_partial_tick(spec, min, rounded_min, true);
int max_partial_tick = TickTestHelper.check_partial_tick(spec, max, rounded_max, false);
// assert that ticking up/down between min/max behaves expectedly.
var batch_tick_up_result = spec.tickup(min, min_ticks_to_break + max_ticks_to_break + min_partial_tick);
Assert.That(MathUtils.marginal_equals(batch_tick_up_result, rounded_max, TickUtils.precision_const));
var batch_tick_down_result = spec.tickdown(max, min_ticks_to_break + max_ticks_to_break + max_partial_tick);
Assert.That(MathUtils.marginal_equals(batch_tick_down_result, rounded_min, TickUtils.precision_const));
}
void _test_tick_increment(ContractSpecificationImmutable spec, double tick_size, double min, double max) {
// min round/partial tick
Assert.That(TickTestHelper.round_ticks(tick_size, min, out var rounded_min, out var rounded_min_ticks));
var min_partial_tick = TickTestHelper.check_partial_tick(spec, min, rounded_min, true);
// max round/partial tick
Assert.That(TickTestHelper.round_ticks(tick_size, max, out var rounded_max, out var rounded_max_ticks));
var max_partial_tick = TickTestHelper.check_partial_tick(spec, max, rounded_max, false);
var full_ticks = rounded_max_ticks - rounded_min_ticks;
Assert.That(MathUtils.marginal_equals(rounded_max, spec.tickup(min, full_ticks + min_partial_tick), TickUtils.precision_const));
Assert.That(MathUtils.marginal_equals(rounded_min, spec.tickup(max, -(full_ticks + max_partial_tick)), TickUtils.precision_const));
}
}
}
+2 -1
View File
@@ -1,4 +1,4 @@
<Project Sdk="Microsoft.NET.Sdk">
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>netstandard2.0</TargetFramework>
@@ -17,5 +17,6 @@
<ItemGroup>
<EmbeddedResource Include="Resources\KrandallOrderBookCrash.security_proto" />
<EmbeddedResource Include="Resources\NonDeterministicICEFutures.security_proto" />
<EmbeddedResource Include="Resources\SimContractSpecifications.contract_spec_proto" />
</ItemGroup>
</Project>
+1 -1
View File
@@ -1 +1 @@
set(sources files/cert_secure_logon.txt;files/futures.coconut.xz;files/onixs_ice/ConnectivityConfiguration.APITest.xml;files/onixs_ice/ConnectivityConfiguration.PerfTest.xml;files/onixs_ice/ConnectivityConfiguration.Production.xml;files/perf_trace/compiled.css;files/perf_trace/index.html;files/perf_trace/jquery-3.3.1.min.js;files/perf_trace/main.js;files/perf_trace/perf_log.sql;files/perf_trace/perf_trace_analysis.sql;files/perf_trace/plotly-latest.min.js)
set(sources files/cert_secure_logon.txt;files/futures.coconut.xz;files/onixs_ice/ConnectivityConfiguration.APITest.xml;files/onixs_ice/ConnectivityConfiguration.APITest.xml.orig;files/onixs_ice/ConnectivityConfiguration.PerfTest.xml;files/onixs_ice/ConnectivityConfiguration.Production.xml;files/perf_trace/compiled.css;files/perf_trace/index.html;files/perf_trace/jquery-3.3.1.min.js;files/perf_trace/main.js;files/perf_trace/perf_log.sql;files/perf_trace/perf_trace_analysis.sql;files/perf_trace/plotly-latest.min.js)
+1 -1
View File
@@ -1 +1 @@
set(sources api/apicore.proto;api/apigateway.proto;api/apioptions.proto;api/core/ApiClientInterop.cpp;api/core/ApiServerInterop.cpp;api/public/ApiServer.cpp;api/public/ClientChannel.cpp;api/public/QuickbusClientChannel.cpp;api/public/ServerChannel.cpp;api/public/ServiceContext.cpp;api/service_helpers/AdminServiceUtils.cpp;api/service_helpers/AlgoServiceUtils.cpp;api/service_helpers/PositionUtilities.cpp;api/services/AdminService.proto;api/services/AlgoDefinitionService.proto;api/services/AlgoService.proto;api/services/ApiUnitTestService.proto;api/services/AuthService.proto;api/services/BasePositionService.proto;api/services/ErrorReportService.proto;api/services/HelloService.proto;api/services/MBOService.proto;api/services/MarginService.proto;api/services/MarketDataAuxiliaryService.proto;api/services/MarketDataRelay.proto;api/services/MarketDataService.proto;api/services/MoneyFileService.proto;api/services/OrderService.proto;api/services/OutOfProcessURLListener.proto;api/services/PersistenceService.proto;api/services/PositionService.proto;api/services/ShellDiagnosticService.proto;api/services/ShellLatencyService.proto;api/services/SyntheticSecurityService.proto;api/test/ApiTests.cpp;api/test/HelloServiceServer.cpp;config/ConfigCheck.cpp;config/ConfigDownloader.cpp;config/ConfigErrorCollector.cpp;config/ConfigLog.cpp;config/ConfigPropertyEvaluator.cpp;config/ConfigValueQueue.cpp;config/ConfigurationException.cpp;config/ConfigurationState.cpp;config/PreprocessInputStream.cpp;config/config.cpp;config/defaults/MarketData.conf;config/defaults/Ports.conf;config/defaults/Symbols.conf;config/defaults/cme_reference_data.conf;config/defaults/edge.conf;config/defaults/jetfix.conf;config/defaults/keycode.conf;config/defaults/logging.conf;config/defaults/orderman_cfg.conf;config/defaults/orders_fills_cleanup.conf;config/defaults/position_cfg.conf;config/defaults/span.conf;config/defaults/spreader.conf;config/defaults/testkeys.conf;config/defaults/threads.conf;config/defaults/toggles.conf;config/extensions/extensions.proto;config/invalid/invalid.proto;config/protos/AlgoTypes.proto;config/protos/ExchangeSimCfg.proto;config/protos/MarketData.proto;config/protos/Ports.proto;config/protos/Symbols.proto;config/protos/UI.proto;config/protos/cme_reference_data.proto;config/protos/jetfix.proto;config/protos/keycode.proto;config/protos/logging.proto;config/protos/mercury_cfg.proto;config/protos/orderman_cfg.proto;config/protos/orders_fills_cleanup.proto;config/protos/perflog_cfg.proto;config/protos/position_cfg.proto;config/protos/quickbus_cfg.proto;config/protos/span.proto;config/protos/spreader.proto;config/protos/subprocess.proto;config/protos/system.proto;config/protos/testkeys.proto;config/protos/threads.proto;config/protos/toggles.proto;config/tests/HTTPServer.cpp;config/tests/config_ref_tests.cpp;config/tests/config_tests.cpp;config/text_format/text_format.cpp;domain_model/Security.cpp;domain_model/Security.proto;domain_model/SecurityTests.cpp;domain_model/sod.cpp;domain_model/tests/domain_tests.cpp;expression/BooleanGrammar.cpp;expression/ExpressionEvaluator.cpp;expression/ParserExceptions.cpp;expression/Value.cpp;expression/tests/expression_parser_tests.cpp;jetfix/codec/FIXArray.cpp;jetfix/common/OutFIX.cpp;jetfix/connection/AsyncReader.cpp;jetfix/connection/IConnection.cpp;jetfix/connection/SocketConnection.cpp;jetfix/gateway/CoreGateway.cpp;jetfix/gateway/JetFIXGateway.cpp;jetfix/gateway/Session.cpp;jetfix/store/FIXFileStore.cpp;jetfix/store/session_name.cpp;jetfix/tests/async_reader_tests.cpp;jetfix/tests/decoding_tests.cpp;jetfix/tests/fix_encoding_stream_tests.cpp;jetfix/tests/fix_fragment_tests.cpp;jetfix/tests/jetfix_performance_tests.cpp;jetfix/tests/sample_fix.cpp;jetfix/tests/store_tests.cpp;logging/LoggerHub.cpp;logging/Sink.cpp;logging/logging.cpp;logging/tests/logging_tests.cpp;md/Diag/MDPeriodicDumper.cpp;md/Diag/ShmDumper.cpp;md/MBOProcessor.cpp;md/MBOServiceServer.cpp;md/MDClient.cpp;md/MDConsumer.cpp;md/MDConsumerHandle.cpp;md/MDConsumerInterop.cpp;md/MDProducer.cpp;md/MDProducerHandle.cpp;md/MemorySegmentUtils.cpp;md/PlatformLoader.cpp;md/PriceSize.cpp;md/Product.cpp;md/SecurityCache.cpp;md/SecurityDB.cpp;md/SecurityIDRecorder.cpp;md/SecurityMapper.cpp;md/SecurityOracle.cpp;md/SettlementRecorder.cpp;md/Shm/FixedSecurity.cpp;md/SyntheticSecurityService.cpp;md/cme/MDP3Utils.cpp;md/common.cpp;md/ice/ICEUtils.cpp;md/protos/co2.proto;md/relay/QueryServer.cpp;md/relay/RelayClient.cpp;md/relay/RelayRecorder.cpp;md/service/MarketDataServiceServer.cpp;md/test/Co2ManagedTestHelper.cpp;md/test/Co2TestInstrument.cpp;md/test/mbo_tests.cpp;md/test/md2_tests.cpp;md/test/md_test_utils.cpp;md/test/synthetic_book_merge_tests.cpp;md/vendor/OnixsUtils.cpp;mercury/actors/IPollableActor.cpp;mercury/broker/Broker.cpp;mercury/broker/BrokerProxy.cpp;mercury/broker/ILocalBroker.cpp;mercury/broker/IRemoteBroker.cpp;mercury/common/mercury_common.cpp;mercury/events/TimerEvent.cpp;mercury/executor/Executor.cpp;mercury/topics/Topic.cLine truncated
set(sources api/apicore.proto;api/apigateway.proto;api/apioptions.proto;api/core/ApiClientInterop.cpp;api/core/ApiServerInterop.cpp;api/public/ApiServer.cpp;api/public/ClientChannel.cpp;api/public/QuickbusClientChannel.cpp;api/public/ServerChannel.cpp;api/public/ServiceContext.cpp;api/service_helpers/AdminServiceUtils.cpp;api/service_helpers/AlgoServiceUtils.cpp;api/service_helpers/PositionUtilities.cpp;api/services/AdminService.proto;api/services/AlgoDefinitionService.proto;api/services/AlgoService.proto;api/services/ApiUnitTestService.proto;api/services/AuthService.proto;api/services/BasePositionService.proto;api/services/ErrorReportService.proto;api/services/HelloService.proto;api/services/MBOService.proto;api/services/MarginService.proto;api/services/MarketDataAuxiliaryService.proto;api/services/MarketDataRelay.proto;api/services/MarketDataService.proto;api/services/MoneyFileService.proto;api/services/OrderService.proto;api/services/OutOfProcessURLListener.proto;api/services/PersistenceService.proto;api/services/PositionService.proto;api/services/ShellDiagnosticService.proto;api/services/ShellLatencyService.proto;api/services/SyntheticSecurityService.proto;api/test/ApiTests.cpp;api/test/HelloServiceServer.cpp;config/ConfigCheck.cpp;config/ConfigDownloader.cpp;config/ConfigErrorCollector.cpp;config/ConfigLog.cpp;config/ConfigPropertyEvaluator.cpp;config/ConfigValueQueue.cpp;config/ConfigurationException.cpp;config/ConfigurationState.cpp;config/PreprocessInputStream.cpp;config/config.cpp;config/defaults/MarketData.conf;config/defaults/Ports.conf;config/defaults/Symbols.conf;config/defaults/cme_reference_data.conf;config/defaults/edge.conf;config/defaults/jetfix.conf;config/defaults/keycode.conf;config/defaults/logging.conf;config/defaults/orderman_cfg.conf;config/defaults/orders_fills_cleanup.conf;config/defaults/position_cfg.conf;config/defaults/span.conf;config/defaults/spreader.conf;config/defaults/testkeys.conf;config/defaults/threads.conf;config/defaults/toggles.conf;config/extensions/extensions.proto;config/invalid/invalid.proto;config/protos/AlgoTypes.proto;config/protos/ExchangeSimCfg.proto;config/protos/MarketData.proto;config/protos/Ports.proto;config/protos/Symbols.proto;config/protos/UI.proto;config/protos/cme_reference_data.proto;config/protos/jetfix.proto;config/protos/keycode.proto;config/protos/logging.proto;config/protos/mercury_cfg.proto;config/protos/orderman_cfg.proto;config/protos/orders_fills_cleanup.proto;config/protos/perflog_cfg.proto;config/protos/position_cfg.proto;config/protos/quickbus_cfg.proto;config/protos/span.proto;config/protos/spreader.proto;config/protos/subprocess.proto;config/protos/system.proto;config/protos/testkeys.proto;config/protos/threads.proto;config/protos/toggles.proto;config/tests/HTTPServer.cpp;config/tests/config_ref_tests.cpp;config/tests/config_tests.cpp;config/text_format/text_format.cpp;domain_model/Security.cpp;domain_model/Security.proto;domain_model/SecurityTests.cpp;domain_model/sod.cpp;domain_model/tests/domain_tests.cpp;expression/BooleanGrammar.cpp;expression/ExpressionEvaluator.cpp;expression/ParserExceptions.cpp;expression/Value.cpp;expression/tests/expression_parser_tests.cpp;jetfix/codec/FIXArray.cpp;jetfix/common/OutFIX.cpp;jetfix/connection/AsyncReader.cpp;jetfix/connection/IConnection.cpp;jetfix/connection/SocketConnection.cpp;jetfix/gateway/CoreGateway.cpp;jetfix/gateway/JetFIXGateway.cpp;jetfix/gateway/Session.cpp;jetfix/store/FIXFileStore.cpp;jetfix/store/session_name.cpp;jetfix/tests/async_reader_tests.cpp;jetfix/tests/decoding_tests.cpp;jetfix/tests/fix_encoding_stream_tests.cpp;jetfix/tests/fix_fragment_tests.cpp;jetfix/tests/jetfix_performance_tests.cpp;jetfix/tests/sample_fix.cpp;jetfix/tests/store_tests.cpp;logging/LoggerHub.cpp;logging/Sink.cpp;logging/logging.cpp;logging/tests/logging_tests.cpp;md/Diag/MDPeriodicDumper.cpp;md/Diag/ShmDumper.cpp;md/MBOProcessor.cpp;md/MBOServiceServer.cpp;md/MDClient.cpp;md/MDConsumer.cpp;md/MDConsumerHandle.cpp;md/MDConsumerInterop.cpp;md/MDProducer.cpp;md/MDProducerHandle.cpp;md/MemorySegmentUtils.cpp;md/PlatformLoader.cpp;md/PriceSize.cpp;md/Product.cpp;md/SecurityCache.cpp;md/SecurityDB.cpp;md/SecurityIDRecorder.cpp;md/SecurityMapper.cpp;md/SecurityOracle.cpp;md/SettlementRecorder.cpp;md/Shm/FixedSecurity.cpp;md/SyntheticSecurityService.cpp;md/cme/MDP3Utils.cpp;md/common.cpp;md/ice/ICEUtils.cpp;md/protos/co2.proto;md/relay/QueryServer.cpp;md/relay/RelayClient.cpp;md/relay/RelayRecorder.cpp;md/service/MarketDataServiceServer.cpp;md/test/Co2ManagedTestHelper.cpp;md/test/Co2TestInstrument.cpp;md/test/mbo_tests.cpp;md/test/md2_tests.cpp;md/test/md_test_utils.cpp;md/test/synthetic_book_merge_tests.cpp;md/vendor/OnixsUtils.cpp;mercury/actors/IPollableActor.cpp;mercury/broker/Broker.cpp;mercury/broker/BrokerProxy.cpp;mercury/broker/ILocalBroker.cpp;mercury/broker/IRemoteBroker.cpp;mercury/common/mercury_common.cpp;mercury/events/TimerEvent.cpp;mercury/executor/Executor.cpp;mercury/topics/Topic.cLine truncated
+1
View File
@@ -6,6 +6,7 @@ MarketDataConfig {
rule: "DeploymentType.type == 'PROD'"
value {
use_sim: false
use_onixs: false
}
}
+8 -5
View File
@@ -1,10 +1,13 @@
#nusers: 1
#allow concurrent : true
#expires: 2021-Jan-01 00:00:00 637450560000000000
#generation_time: 2020-Apr-03 18:39:31.010863 5248901378137496534
#nusers: 100000
#allow concurrent : false
#expires: 3020-May-18 00:00:00 952822656000000000
#generation_time: 2020-Aug-11 14:19:03.379579 5249013541861183694
EncryptedKeyCode {
value {
keycode: "BJBQWsbdTXWa/iLmOf3ekE8vP/NYkf0Q/nUsp/rJ78Ze3W9pNXICCMabmmsr1xOM7aqRIclPgZd955uSSfvFkdNWFTxwPQ5IfnDGopj3QdhUVxhzgVLaXHN+vC0H/MWrDQ5K4WY5J/6VXgUn1LSN/2HNb5iR2sKXeh3Alamg87YtCWEi+scelffE7HK5ERT/3A3Y/e0pqUFhP6xouIjHRhC2FRBb6OoJQVvFwVDADSuKZNo9B6GhC3H0YdHqjFhGDoky5ecgzeKIX8uWJEQNnQXQJ0iTgQ95+YR5IMU+XWdlVfSrc0fuTmj3YWcBQ8Kl2ItEcobyZzJYega3tu6Ftw=="
keycode: "hrelQBN4n0kURYKYLwp2nzYTaxeyJZoGs//hN9rkyyVTgp1EQpyOnZHo7klNF8r9Ci8QV8aD0Yp66FvhtWqLFkNWCZ4pp48HzC34pdRzVbXjTmyEMK6iz/nBLE/VuYtBoXihlxIqOjTwnv4sNeAgboSOadVvGY3mRb3b9tMEIRTSbuq+KdPuTM2y/swL8fg53PNLclkqzU9f6mI/250RmnCvWzZf7Liu6TBWfQAI2RfGKP1+blewONFHqkeSA/fVkGfdiZy7cJOqak9VrxzLsJwqAK5DGMNv/kk4jceT3mF3xaSzoEzbge3ekk/SxXkuAKFrT6fxrr/v381SeHoHSw=="
}
}
+4
View File
@@ -72,6 +72,10 @@ message LadderKnobs {
optional bool open_algo_popup_on_select = 6 [default = false];
optional bool use_algo_param_grid = 7 [default = true];
optional uint32 max_mbo_orders = 8 [default = 200];
optional bool show_scrollbar = 9 [default = false];
// DJ wants bid/ask cells with markets (i.e., size > 0) to have a
// lighter background than those without markets.
optional bool lighten_market_cells = 10 [default = true];
}
message OrderBookOptions {
+7 -8
View File
@@ -248,14 +248,13 @@ inline bool is_strip(const bts::api::Security& sec){
}
inline bool is_spread_of_strips(const bts::api::Security& sec){
if(sec.has_spread())
if (sec.has_ice()){
const auto& spr = sec.spread();
for (const auto& l : spr.legs())
// assumption : either all legs are strips or none
return is_strip(l.security());
}
return false;
bool all_legs_strip = false;
if(is_spread(sec)){
all_legs_strip = true;
for (const auto& l : sec.spread().legs())
all_legs_strip = all_legs_strip && is_strip(l.security());
}
return all_legs_strip;
}
inline bool is_strip_with_no_leg_fills(const bts::api::Security& sec){
@@ -60,13 +60,28 @@ struct ICEExecutionGateway::PImpl
md::SecurityOracle sec_oracle;
};
void from_exchange_qty (const api::Security& sec, bts::orderman::ExecutionReport* exec_rep){
void from_exchange_qty (const api::Security& sec, bts::orderman::ExecutionReport* exec_rep){
LOG(OrderMan, Info, "ICEExecutionGateway::from_exchange_qty "
"sec:{} mult:{} "
"leg_sec:{} leg_sec_mult:{}"
"qty:{} filled_qty:{} last_shares:{} max_show:{} "
"price:{} last_price:{} avg_price:{}",
sec.id(), sec.ice().exchange_qty_mult(),
exec_rep->leg_security == nullptr ? 0 : exec_rep->leg_security->id(),
exec_rep->leg_security == nullptr ? os::nan() : exec_rep->leg_security->ice().exchange_qty_mult(),
exec_rep->quantity, exec_rep->filled_quantity,
exec_rep->last_shares, exec_rep->max_show,
exec_rep->price, exec_rep->last_price, exec_rep->avg_price);
exec_rep->quantity = bts::securities::from_exchange_qty(
exec_rep->quantity,sec);
exec_rep->filled_quantity = bts::securities::from_exchange_qty(
exec_rep->filled_quantity,sec);
// this is specific to the leg
const api::Security& last_shr_sec = exec_rep->leg_security == nullptr ? sec :
*exec_rep->leg_security;
exec_rep->last_shares = bts::securities::from_exchange_qty(
exec_rep->last_shares,sec);
exec_rep->last_shares,
last_shr_sec);
exec_rep->max_show = bts::securities::from_exchange_qty(
exec_rep->max_show,sec);
}
@@ -431,8 +446,7 @@ void ICEExecutionGateway::on_exe_report(const jetfix::fix::ICEExecutionReportMsg
data->last_shares = msg.has<fix::LastShares>()
? Quantity(msg.get<fix::LastShares>())
: Quantity(0);
from_exchange_qty(*sec,data);
: Quantity(0);
auto last_px_sec = data->leg_security ? data->leg_security : sec;
data->last_price = msg.has<fix::LastPx>()
? securities::decode_exchange_price(*last_px_sec, Price(msg.get<fix::LastPx>()))
@@ -457,6 +471,7 @@ void ICEExecutionGateway::on_exe_report(const jetfix::fix::ICEExecutionReportMsg
data->cfg = &me->cfg;
data->msg = text_msg;
data->exchange = api::Venue::VENUE_ICE;
from_exchange_qty(*sec,data);
me->on_exe_report(*data, msg.trace());
}
}
+8 -4
View File
@@ -1121,9 +1121,11 @@ void ICENativeOrder::init_fix()
cust = "Y";
create_encoding.add<fix::CustOrderHandlingInst>(cust);
create_encoding.add<fix::SenderSubID>(rr.operator_id());
create_encoding.add<fix::OnBehalfOfSubID>(rr.operator_id() + "|" + rr.authorized_trader());
create_encoding.add<fix::OnBehalfOfLocationID>("DAU|" + rr.authorized_group());
create_encoding.add<fix::OriginatorUserID>(rr.authorized_trader());
create_encoding.add<fix::OriginatorUserID>(rr.authorized_trader()); // 9139
create_encoding.add<fix::OnBehalfOfSubID>(rr.operator_id() + "|" + rr.account()); // 116
create_encoding.add<fix::HandlInst>('1');
create_encoding.add<fix::Int_Symbol>(sec.ice().exchange_id());
create_encoding.add<fix::Side>(def.side());
@@ -1148,9 +1150,11 @@ void ICENativeOrder::init_fix()
update_encoding.add<fix::CompanyID>(std::atoi(rr.company_id().c_str()));
update_encoding.add<fix::OnBehalfOfCompID>(on_behalf);
update_encoding.add<fix::SenderSubID>(rr.operator_id());
update_encoding.add<fix::OnBehalfOfSubID>(rr.operator_id() + "|" + rr.authorized_trader());
update_encoding.add<fix::OnBehalfOfLocationID>("DAU|" + rr.authorized_group());
update_encoding.add<fix::OriginatorUserID>(rr.authorized_trader());
update_encoding.add<fix::OriginatorUserID>(rr.authorized_trader()); // 9139
update_encoding.add<fix::OnBehalfOfSubID>(rr.operator_id() + "|" + rr.account()); // 116
update_encoding.add<fix::HandlInst>('1');
update_encoding.add<fix::Int_Symbol>(sec.ice().exchange_id());
update_encoding.add<fix::Side>(def.side());
@@ -1,376 +0,0 @@
#include "DormanAlgo.h"
#include "lib/api/services/OrderService.pb.h"
#include "lib/domain_model/Security.h"
#include "lib/logging/logging.h"
#include "lib/orderman/order_factory/IOrderFactory.h"
#include "lib/orderman/orderman_utils/Book.h"
#include "lib/orderman/orders/algo/IAlgoServices.h"
#include "lib/utils/PBUtils.h"
#include "lib/orderman/orderman_utils/orderman_utils.h"
#include "lib/orderman/orders/algo/utils/Accumulator.h"
namespace bts {
namespace orderman {
namespace dorman {
using namespace api::orderman;
struct FutureQty {
Quantity size;
TimeStamp when;
};
struct DormanAlgo::Impl {
IAlgoServices *algo = nullptr;
AlgoParams params;
api::Side side;
Quantity exposed_qty = {};
std::optional<FutureQty> next_size;
OrderDefinition splitter_definition;
OrderKey child_id;
ChildState child_state;
uint32_t fills ={};
std::vector<OrderKey> profit_orders;
std::optional<Accumulator> trade_accumulator;
std::optional<TimeStamp> pause_until;
};
DormanAlgo::DormanAlgo() :
me(new Impl())
{ }
DormanAlgo::~DormanAlgo() { }
OrderOpResult DormanAlgo::do_before_launch(IBeforeLaunchAlgoServices& ibl) {
const auto& def = ibl.definition();
// Validation
bts_assert(def.has_custom_def());
bts_assert(def.custom_def().has_dynamic());
auto params = to_dorman_params(def.custom_def().dynamic());
if (auto error = std::get_if<OrderOpResult>(&params)) {
return *error;
}
me->params = std::get<AlgoParams>(params);
me->side = def.side();
if (me->side != api::Side::SIDE_BUY && me->side != api::Side::SIDE_SELL) {
return OrderOpResult { ORDER_ERROR_INVALID_ORDER_DEFINITON, "Invalid side" };
}
if (me->params.trade_accumulation) {
auto& t = me->params.trade_accumulation.value();
me->trade_accumulator = {Accumulator {t.contracts, t.seconds, ibl.get_time()}};
}
CustomOrderDefinition default_order;
default_order.mutable_limit();
auto child_def =
get_if<CustomOrderDefinition>(def.custom_def().dynamic().order_params(), "Child")
.value_or(default_order);
update_child_template(ibl, child_def);
if (ibl.is_attaching()) {
return OrderOpResult{ORDER_ERROR_OP_NOT_SUPPORTED,
"This algo does not support attach."};
}
return {/*ok*/};
}
void DormanAlgo::do_launch(IAlgoServices& algo) {
me->algo = &algo;
auto skey = SecurityKey(algo.security().id());
algo.subscribe_book(skey);
algo.subscribe_timer();
if (me->trade_accumulator) {
algo.subscribe_ticker(skey);
}
}
void DormanAlgo::do_launch_attached(IAlgoServices&, OrderKey, ChildState) {
bts_assert(false);
}
void DormanAlgo::do_update(const api::orderman::Update& update) {
LOG(OrderMan, Diag, "Dorman order {} receiving update: {}",
algo().order_key().value(), utils::pb::to_string(update));
if (update.has_custom()) {
if (!update.custom().has_dynamic()) {
algo().cancel("Update cannot change order type");
return;
}
auto params = to_dorman_params(update.custom().dynamic());
if (auto error = std::get_if<OrderOpResult>(&params)) {
algo().cancel(error->error_msg);
}
me->params = std::get<AlgoParams>(params);
auto skey = SecurityKey(algo().security().id());
if (me->params.trade_accumulation && !me->trade_accumulator) {
algo().subscribe_ticker(skey);
auto& t = me->params.trade_accumulation.value();
me->trade_accumulator = {Accumulator {t.contracts, t.seconds, algo().get_time()}};
}
else if (!me->params.trade_accumulation && me->trade_accumulator) {
algo().unsubscribe_ticker(skey);
me->trade_accumulator = std::nullopt;
}
else if (me->params.trade_accumulation &&
me->trade_accumulator &&
(me->trade_accumulator.value().threshold != me->params.trade_accumulation.value().contracts ||
me->trade_accumulator.value().bucket_interval != std::chrono::seconds(me->params.trade_accumulation.value().seconds))
) {
// accumulator params have changed
auto& t = me->params.trade_accumulation.value();
me->trade_accumulator = {Accumulator {t.contracts, t.seconds, algo().get_time()}};
}
// Check for child
auto child = get_if<CustomOrderDefinition>(update.custom().dynamic().order_params(), "Child");
if (child) {
update_child_template(algo(), child.value());
}
}
if (me->fills >= update.quantity()) {
complete();
}
else {
// In case of price/qty change always update the child
// NOTE: it might be useful to cache the available market data size
// and update based on that if the update contains a size table change
update_child(me->exposed_qty);
}
}
void DormanAlgo::on_child_change(OrderKey key, const ChildState& state) {
if (key != me->child_id) return;
if (state.status == ChildStatus::CANCELED && !is_paused()) {
algo().cancel("Unexpected child cancel");
return;
}
auto delta = state.total_fills.value() - me->child_state.total_fills.value();
if (delta != 0) {
me->fills += delta;
algo().update_fill_state(Quantity {me->fills}, state.last_price);
send_profit_order(state.last_price, Quantity {delta});
}
me->child_state = state;
if (me->params.scratch &&
me->fills >= me->params.scratch.value().max_overfill) {
do_scratch();
}
if (me->fills >= algo().quantity().value() || state.status == ChildStatus::COMPLETED) {
complete();
}
}
void DormanAlgo::on_book(SecurityKey key, const Book& book) {
if (key.value() != me->algo->security().id()) { return; }
auto price = me->algo->price();
auto tick = me->algo->security().contract_spec().low_tick();
// Determine available size on the market
auto& side = book.side(me->side);
uint32_t available = 0;
for (const auto& level : side) {
if (securities::test_price_equality(level.price(), price.value(), tick)) {
available += level.size();
break;
}
}
// Check the step_table
auto target = Quantity {0};
if (available > 0) {
for (const auto& entry : me->params.steps.step_table) {
if (std::get<0>(entry) > available) {
break;
}
else {
target = Quantity { std::get<1>(entry) };
}
}
}
target = Quantity { std::min(target.value(), me->params.steps.maximum) };
// First on_book
if (!child_active()) {
update_child(target);
}
// See if we need to adjust
else {
if (target == me->exposed_qty) {
me->next_size = std::nullopt;
}
// If target < size reduce immediately
else if (target < me->exposed_qty) {
update_child(target);
me->next_size = std::nullopt;
}
// if target > size schedule increase
else if (target > me->exposed_qty) {
if (me->next_size) {
// already planning to increase, update the target
me->next_size.value().size = target;
}
else {
// no existing scheduled increase, create one now
me->next_size = { FutureQty { target, me->algo->get_time() + std::chrono::seconds(me->params.steps.trail_seconds) } };
}
}
}
}
void DormanAlgo::on_timer() {
// Check for pending size changes
auto now = algo().get_time();
if (me->pause_until &&
now >= me->pause_until.value()) {
resume();
}
if (me->next_size &&
now >= me->next_size.value().when) {
auto size = me->next_size.value().size;
update_child(size);
me->next_size = std::nullopt;
}
}
void DormanAlgo::on_ticker(SecurityKey, const TradeVector& vec) {
if (me->trade_accumulator) {
size_t contracts = 0;
for (const auto& t : vec) {
contracts += t.quantity.value();
}
auto& acc = me->trade_accumulator.value();
acc.push_back(algo().get_time(), contracts);
if (acc.exceeded()) {
auto delay = std::chrono::seconds(me->params.trade_accumulation.value().sleep_seconds);
pause_for(delay);
}
}
}
IAlgoOrder::OnCancelResponse DormanAlgo::on_cancel() {
// detach any remaining profit orders so they keep running
for(const auto& key : me->profit_orders) {
algo().detach_child(key);
}
return OnCancelResponse::HONOR;
}
IAlgoServices& DormanAlgo::algo() const { return *me->algo; }
//
// private
void DormanAlgo::update_child(Quantity exposed) {
auto& splitter = *me->splitter_definition.mutable_custom_def()->mutable_splitter();
splitter.set_max_order_qty(me->params.clip_limit);
me->exposed_qty = exposed;
splitter.set_exposed_qty(is_paused() ? 0 : exposed.value());
if (!child_active()) {
// launch child
me->child_id = algo().launch_child(me->splitter_definition, algo().price(), algo().quantity());
}
else {
Update update;
update.set_price(algo().price().value());
update.set_quantity(algo().quantity().value());
*update.mutable_custom()->mutable_splitter() = splitter;
algo().update_child(me->child_id, update);
}
}
void DormanAlgo::update_child_template(IBeforeLaunchAlgoServices& ibl, const CustomOrderDefinition& child) {
auto child_def = ibl.definition();
// Insert a spliter between this and the configured child definition.
api::orderman::SplitterOrderDefinition& splitter_def = *child_def.mutable_custom_def()->mutable_splitter();
*splitter_def.mutable_child() = child;
me->splitter_definition = child_def;
}
Quantity DormanAlgo::exposed_qty() const { return me->exposed_qty; }
bool DormanAlgo::child_active() const { return me->child_id.value() != 0; }
void DormanAlgo::do_scratch() {
// When the # of fills exceeds the max overfill quantity
// We enter fills opposite fills at the fill price and terminate
// Use a splitter to bypass clip limit if necessary
OrderDefinition def = me->splitter_definition;
def.set_side(securities::other_side(me->side));
def.mutable_custom_def()->mutable_splitter()->set_exposed_qty(me->fills);
auto price = me->child_state.last_price;
auto scratch_id = algo().launch_child(def, price, Quantity { me->fills }, false);
algo().detach_child(scratch_id);
complete();
}
void DormanAlgo::send_profit_order(Price p, Quantity q) {
if (me->params.profit_orders) {
auto side = securities::other_side(me->side);
Price offset =
Price { algo().security().contract_spec().low_tick() * me->params.profit_orders.value().ticks_away };
auto price =
securities::worsen_price(side, p, offset);
OrderDefinition def = me->splitter_definition;
// BTS Simulator does not currently support GTC
// Note: This could be made a configurable order type in the algo parameters
def.set_time_in_force(TimeInForce::TIME_IN_FORCE_DAY);
def.set_side(side);
def.mutable_custom_def()->mutable_limit();
me->profit_orders.push_back(
algo().launch_child(def, price, q, false));
}
}
void DormanAlgo::complete() {
// Allow profit orders to keep running
if (me->params.profit_orders) {
for(const auto& key : me->profit_orders) {
algo().detach_child(key);
}
}
algo().complete();
}
void DormanAlgo::pause_for(Duration d) {
if (me->params.trade_accumulation) {
if (is_paused()) {
me->pause_until = std::max(me->pause_until.value(), { algo().get_time() + d });
}
else {
me->pause_until = { algo().get_time() + d };
// When paused child update will always expose 0
update_child(me->exposed_qty);
}
}
}
bool DormanAlgo::is_paused() const {
return (bool)(me->pause_until);
}
void DormanAlgo::resume() {
if (is_paused()) {
me->pause_until = std::nullopt;
update_child(me->exposed_qty);
}
}
}}} //namespace
@@ -1,96 +0,0 @@
#pragma once
#include "lib/orderman/orders/algo/IAlgoOrder.h"
#include <memory>
#include <optional>
#include <variant>
#include <map>
namespace bts {
namespace orderman {
namespace dorman {
//
// Algo parameters
//
// This defines the market quantity vs the order quantity
struct StepParams {
std::vector<std::tuple<uint32_t, uint32_t>> step_table;
// This is the cap on the maximum quantity,
// even though the step table can allow for higher quantities (depending on the
// clip size this could be divided across multiple exchange orders)
uint32_t maximum;
// If the market increases don't follow until it has stayed high for trail_seconds;
uint32_t trail_seconds;
};
// If the number of accumulated fills (net of profit orders) touches or goes beyond
// this, the fills will be scratched by entering opposite orders at the fill price
struct ScratchParams {
uint32_t max_overfill;
};
// If this is enabled, then as fills accumulate, profit GTC orders are
// immediately sent N ticks away on the opposite side.
struct ProfitOrderParams {
uint32_t ticks_away;
};
// If N contracts trade in T seconds, then the algo is paused (ie child exchange order
// is/are cancelled) for X seconds. Once the condition clears order is reentered.
struct TradeAccumulationParams {
uint32_t contracts;
uint32_t seconds;
uint32_t sleep_seconds;
};
struct AlgoParams {
StepParams steps;
uint32_t clip_limit;
std::optional<ScratchParams> scratch;
std::optional<ProfitOrderParams> profit_orders;
std::optional<TradeAccumulationParams> trade_accumulation;
};
class DormanAlgo : public IAlgoOrder {
struct Impl;
std::unique_ptr<Impl> me;
IAlgoServices& algo() const;
public:
DormanAlgo();
~DormanAlgo();
OrderOpResult do_before_launch(IBeforeLaunchAlgoServices &) override;
void do_launch(IAlgoServices &) override;
void do_launch_attached(IAlgoServices &, OrderKey, ChildState) override;
void do_update(api::orderman::Update const &) override;
void on_child_change(OrderKey, ChildState const &) override;
void on_book(SecurityKey, const Book&) override;
void on_timer() override;
void on_ticker(SecurityKey, const TradeVector&) override;
IAlgoOrder::OnCancelResponse on_cancel() override;
Quantity exposed_qty() const;
private:
//
// Child management
void update_child_template(IBeforeLaunchAlgoServices&, const api::orderman::CustomOrderDefinition&);
void update_child(Quantity exposed);
bool child_active() const;
void do_scratch();
void send_profit_order(Price, Quantity);
void complete();
void pause_for(Duration);
bool is_paused() const;
void resume();
};
template <class OK,class ERR>
using Result = std::variant<OK,ERR>;
Result<AlgoParams,OrderOpResult> to_dorman_params(const api::orderman::DynamicOrderDefinition&);
}}} //namespace
@@ -1,401 +0,0 @@
#include "lib/orderman/orders/algo/algo_orders/LimitCoverAlgo.h"
#include "lib/sparkproto/SparkProtos.pb.h"
#include "lib/api/services/OrderService.pb.h"
#include "lib/orderman/order_factory/IOrderFactory.h"
#include "lib/orderman/orderman_utils/orderman_utils.h"
#include "lib/orderman/orders/algo/IAlgoServices.h"
#include "lib/orderman/orders/spreader_orders/spreader/SpreaderUtils.h"
#include "lib/os/os.h"
#include "lib/utils/PBUtils.h"
#include "lib/orderman/orders/algo/utils/DynamicOrderAdapter.h"
#include "lib/orderman/orders/algo/algo_orders/limit_cover/LimitCoverDefinition.h"
#include "lib/orderman/orders/algo/algo_orders/limit_cover/LimitCoverAdapter.h"
#include <map>
#include <limits>
#include <iostream>
#include <sstream>
#define DEFAULT_LOG_LEVEL Info
#define SUMMARIZE_TRANSACTION_BEGIN(id, type, ...) Summary __LOG_TRANS(this, id, Formatter::fmt(__VA_ARGS__), type, DEFAULT_LOG_LEVEL)
#define SUMMARIZE_TRANSACTION(id, type) Summary __LOG_TRANS(this, id, "", type, DEFAULT_LOG_LEVEL)
#define SUMMARIZE SUMMARIZE_TRANSACTION(__FUNCTION__, SummaryType::StatusChange)
// define 'PRINT_SUMMARIES' to print all logs to the console
// (assuming logs are made with the MSG/MSG_LEVEL macros)
#ifdef PRINT_SUMMARIES
#define _PRINT_MSG(x) std::cout << x << std::endl;
#else
#define _PRINT_MSG(x)
#endif
#define _MSG(level, msg) \
_PRINT_MSG(msg); \
LOG(OrderMan, level, "{}", msg)
#define MSG_LEVEL(level, ...) _MSG(level, (Formatter::fmt(__VA_ARGS__)))
// these automatically prepend log_header() to the args
#define MSG(...) MSG_LEVEL(DEFAULT_LOG_LEVEL, log_header(), " ", __VA_ARGS__)
#define DIAG(...) MSG_LEVEL(Diag, log_header(), " ", __VA_ARGS__)
#define INFO(...) MSG_LEVEL(Info, log_header(), " ", __VA_ARGS__)
#define WARN(...) MSG_LEVEL(Warn, log_header(), " ", __VA_ARGS__)
#define ERROR(...) MSG_LEVEL(Error, log_header(), " ", __VA_ARGS__)
namespace bts {
namespace orderman {
using namespace api::orderman;
using namespace bts::orderman::limit_cover::utils;
using Adapter = bts::orderman::LimitCoverAdapter;
namespace limit_cover {
namespace utils {
void init_delete_and_cover(OrderDefinition& target, const DeleteAndCoverDefinition& def) {
if (!target.has_custom_def())
*target.mutable_custom_def() = CustomOrderDefinition();
init_delete_and_cover(*target.mutable_custom_def(), def);
}
void init_delete_and_cover(CustomOrderDefinition& target, const DeleteAndCoverDefinition& def) {
if (!target.has_delete_and_cover()) {
*target.mutable_delete_and_cover() = DeleteAndCoverDefinition(def);
} else {
target.mutable_delete_and_cover()->CopyFrom(def);
}
}
void init_child_update(Update& target, uint32_t qty, double price, const DeleteAndCoverDefinition& def) {
target.set_quantity(qty);
target.set_price(price);
init_delete_and_cover(*target.mutable_custom(), def);
}
#define INVALID_DEF(x) OrderOpResult(api::orderman::ORDER_ERROR_INVALID_ORDER_DEFINITON, x)
OrderOpResult validate_custom_def(const CustomOrderDefinition& custom_def) {
if (!custom_def.has_dynamic())
return INVALID_DEF("DynamicOrderDefinition is undefined");
return Adapter::validate_proto(custom_def.dynamic());
}
OrderOpResult validate_def(const OrderDefinition& def) {
if (def.attach_target_order_key() != 0) {
return INVALID_DEF("Attach not supported.");
} else if (def.has_custom_def()) {
return validate_custom_def(def.custom_def());
} else {
return INVALID_DEF("CustomOrderDefinition is undefined.");
}
}
OrderOpResult validate_update(const Update& upd) {
return upd.has_custom() ?
validate_custom_def(upd.custom()) : OrderOpResult();
}
} // namespace utils
} // namespace limit_cover
struct LimitCoverAlgo::PImpl {
IAlgoServices *algo = nullptr;
Status status = Status::WAITING_TO_DEPLOY;
OrderKey child_key = null_order_key();
double child_price = os::nan();
uint32_t child_qty = 0;
Book book;
uint32_t limit_volume = 0;
std::map<uint32_t, LimitCoverGate> gates;
double settlement = os::nan();
double price_offset_from_settle = 0;
double limit_price = os::nan();
};
struct LimitCoverAlgo::Summary {
Summary(LimitCoverAlgo* owner, std::string transaction_id, std::string begin_tag = {}, SummaryType type = SummaryType::StatusChange, log::Level level = DEFAULT_LOG_LEVEL)
: _owner(owner), _transaction_id(transaction_id), _original_status(owner->me->status), _type(type), _level(level) {
if (_owner != nullptr && !_transaction_id.empty()) {
std::stringstream str;
str << owner->log_header() << " begin " << transaction_id << ".";
if (!begin_tag.empty()) {
str << " " << begin_tag << ".";
}
if (type == SummaryType::FullState) {
str << " Algo State: " << _owner->fmt_state() << ".";
}
MSG_LEVEL(level, str.str());
}
}
~Summary() {
std::stringstream msg_str;
if (!_transaction_id.empty()) {
msg_str << " end " << _transaction_id << ".";
}
switch (_type) {
case SummaryType::StatusChange:
if (_owner->me->status != _original_status)
msg_str << " Status changed from " << _original_status << " to " << _owner->me->status << ".";
break;
case SummaryType::FullState:
msg_str << " Algo State: " << _owner->fmt_state() << ".";
break;
}
auto msg = msg_str.str();
if (!msg.empty()) {
MSG_LEVEL(_level, _owner->log_header(), msg);
}
}
private:
LimitCoverAlgo *_owner;
std::string _transaction_id;
Status _original_status;
SummaryType _type;
log::Level _level;
};
LimitCoverAlgo::LimitCoverAlgo() : me(new PImpl()) {}
LimitCoverAlgo::~LimitCoverAlgo() {}
OrderOpResult
LimitCoverAlgo::do_before_launch(IBeforeLaunchAlgoServices &balgo) {
SUMMARIZE;
bts_assert(me->status == Status::WAITING_TO_DEPLOY);
bts_assert(me->gates.empty());
auto vd = validate_def(balgo.definition());
if (vd.ok()) {
auto lcdef = Adapter::from_proto(balgo.definition());
me->price_offset_from_settle = lcdef.price_offset();
me->gates = lcdef.normal_gates();
}
return vd;
}
void LimitCoverAlgo::do_launch(IAlgoServices& algo) {
SUMMARIZE;
bts_assert(me->status == Status::WAITING_TO_DEPLOY);
me->algo = &algo;
me->child_qty = algo.quantity().value();
algo.subscribe_book(SecurityKey(algo.security().id()));
algo.subscribe_settlement(SecurityKey(algo.security().id()));
}
void LimitCoverAlgo::do_update(Update const &upd) {
SUMMARIZE_TRANSACTION_BEGIN(__FUNCTION__, SummaryType::StatusChange, utils::pb::to_string(upd));
auto vup = validate_update(upd);
if (!vup.ok()) {
me->status = Status::DONE;
algo().terminate_error(Formatter::fmt("Invalid update: ", vup.error_msg, "."));
return;
}
if (upd.has_custom()) {
auto lcdef = Adapter::from_proto(upd.custom());
if (me->status == Status::WAITING_TO_DEPLOY) {
me->price_offset_from_settle = lcdef.price_offset();
recompute_limit_price();
recompute_limit_volume();
}
me->gates = lcdef.normal_gates();
if (me->status == Status::WORKING)
recompute_gate();
}
switch (me->status) {
case Status::WAITING_TO_DEPLOY:
try_deploy();
break;
case Status::WORKING: {
// don't change the child price; the price param is irrelevant to this algo.
if (upd.has_custom() || me->child_qty != upd.quantity())
update_child(upd.quantity());
break;
}
default:
break;
}
}
void LimitCoverAlgo::on_book(SecurityKey, Book const &b) {
SUMMARIZE_TRANSACTION_BEGIN(__FUNCTION__, SummaryType::StatusChange, "BBO: ", Formatter::to_string(b));
me->book = b;
recompute_limit_volume();
switch (me->status) {
case Status::WAITING_TO_DEPLOY:
try_deploy();
break;
case Status::WORKING: {
if (recompute_gate())
update_child(me->child_qty);
break;
}
default:
break;
}
}
void LimitCoverAlgo::update_child(uint32_t qty) {
bts_assert(me->algo != nullptr);
bts_assert(me->status == Status::WORKING);
me->child_qty = qty;
Update upd;
init_child_update(upd, qty, me->child_price, curr_gate().definition());
MSG("updating algo child: ", utils::pb::to_string(upd));
me->algo->update_child(me->child_key, upd);
}
void LimitCoverAlgo::on_child_change(OrderKey key, ChildState const& state) {
bts_assert(key == me->child_key);
SUMMARIZE_TRANSACTION_BEGIN(__FUNCTION__, SummaryType::FullState, "Child State: ", Formatter::to_string(state));
algo().update_fill_state(state.total_fills, state.last_price);
me->child_price = state.price.value();
switch (me->status) {
case Status::WORKING:
switch (state.status) {
case ChildStatus::WORKING:
break;
case ChildStatus::CANCELED: {
auto msg = Formatter::fmt("main child (", key, ") canceled unexpectedly.");
MSG(msg, ". ", fmt_state());
me->status = Status::DONE;
algo().terminate_error(msg);
break;
}
case ChildStatus::COMPLETED:
me->status = Status::DONE;
algo().complete();
break;
}
break;
case Status::DONE:
break;
default:
bts_assert_msg(false, Formatter::fmt(log_header(), " unexpected status: ", me->status));
break;
}
}
void LimitCoverAlgo::on_settlement(SecurityKey, Price settlement) {
if (me->status == Status::WAITING_TO_DEPLOY) {
MSG("updating settlement from ", me->settlement, " to ", settlement);
me->settlement = settlement.value();
DIAG("recomputing limit price...");
recompute_limit_price();
DIAG("limit price is ", me->limit_price);
DIAG("recomputing limit volume...");
recompute_limit_volume();
DIAG("limit volume is ", me->limit_volume);
try_deploy();
} else {
MSG("ignored settlement update to ", settlement,
": settlement updates are only processed while the algo is ", Status::WAITING_TO_DEPLOY,
". Settlement at time of deploy was ", me->settlement);
}
}
void LimitCoverAlgo::try_deploy() {
MSG("trying to deploy. ", fmt_state());
bts_assert(me->status == Status::WAITING_TO_DEPLOY);
bts_assert(me->algo != nullptr);
// this is probably redundant (better safe than sorry tho).
bts_assert(me->child_key == null_order_key());
if (os::is_nan(me->settlement)) {
MSG("still waiting for settle.");
} else if (me->limit_volume < activation_threshold()) {
MSG("still waiting for limit volume (", me->limit_volume, ") to breech activation threshold (", activation_threshold(), ").");
} else {
bts_assert(!os::is_nan(me->limit_price));
recompute_gate();
OrderDefinition child_def;
bts_assert(!me->gates.empty());
child_def.CopyFrom(algo().definition());
init_delete_and_cover(child_def, curr_gate().definition());
bts_assert(child_def.custom_def().has_delete_and_cover());
MSG("deploying child order: ", utils::pb::to_string(child_def));
me->child_key = algo().launch_child(child_def, Price(me->limit_price), algo().quantity());
me->status = Status::WORKING;
algo().set_ladder_visibility(false);
}
}
template<class T>
bool did_change(T& backing, T new_value) {
if (backing == new_value)
return false;
backing = new_value;
return true;
}
bool LimitCoverAlgo::recompute_gate() {
if (me->gates.empty())
return false;
auto orig_sz = me->gates.size();
auto it = me->gates.lower_bound(me->limit_volume);
if (it == me->gates.end() || (it != me->gates.begin() && it->first > me->limit_volume))
it--;
me->gates.erase(me->gates.begin(), it);
return me->gates.size() < orig_sz;
}
// limit price
double LimitCoverAlgo::compute_limit_price() const {
return os::is_nan(me->settlement) ? os::nan() :
securities::improve_price(side(), Price(me->settlement), Price(me->price_offset_from_settle))
.value();
}
bool LimitCoverAlgo::recompute_limit_price() {
return did_change(me->limit_price, compute_limit_price());
}
// limit volume
uint32_t LimitCoverAlgo::compute_limit_volume() const {
return me->algo == nullptr ? 0 :
BookUtils::volume_at_or_better(me->book, side(), me->limit_price);
}
bool LimitCoverAlgo::recompute_limit_volume() {
return did_change(me->limit_volume, compute_limit_volume());
}
// pseudo properties (const state accessors)
IAlgoServices &LimitCoverAlgo::algo() const { return *me->algo; }
api::Side LimitCoverAlgo::side() const {
return me->algo == nullptr ? api::SIDE_UNDEFINED : me->algo->definition().side();
}
const LimitCoverGate& LimitCoverAlgo::curr_gate() const {
bts_assert(!me->gates.empty());
return me->gates.begin()->second;
}
uint32_t LimitCoverAlgo::activation_threshold() const {
return me->gates.empty() ? std::numeric_limits<uint32_t>::max() : me->gates.begin()->first;
}
std::string LimitCoverAlgo::log_header() const {
std::stringstream ostr;
ostr << "LimitCoverAlgo";
if (me->algo != nullptr) {
ostr << "(" << me->algo->order_key().value() << ")";
}
ostr << "[" << fmt_status(me->status) << "]";
return ostr.str();
}
std::string LimitCoverAlgo::fmt_state() const {
std::stringstream ostr;
if (me->algo != nullptr) {
ostr << " [" << fmt_status(me->status) << "]"
<< Formatter::to_string(side()) << " " << me->algo->quantity().value()
<< " @ " << me->algo->price().value()
<< " (" << me->price_offset_from_settle
<< " away from settle).";
if (me->child_key != null_order_key()) {
ostr << " Main child key: " << me->child_key << ", ";
}
ostr << " Settle: " << me->settlement
<< ", Limit Price: " << me->limit_price
<< ", BBO: " << Formatter::to_string(me->book);
} else {
ostr << "(initializing)";
}
return ostr.str();
}
} // namespace orderman
} // namespace bts
@@ -1,94 +0,0 @@
#pragma once
#include "lib/orderman/orderman_utils/BookUtils.h"
#include "lib/orderman/orderman_utils/Formatter.h"
#include "lib/orderman/orders/algo/IAlgoOrder.h"
#include "lib/orderman/orders/algo/algo_orders/limit_cover/LimitCoverDefinition.h"
#include "lib/orderman/orders/algo/algo_orders/limit_cover/LimitCoverGate.h"
#include <map>
namespace bts {
namespace orderman {
class LimitCoverAlgo : public IAlgoOrder {
public:
LimitCoverAlgo();
~LimitCoverAlgo();
OrderOpResult do_before_launch(IBeforeLaunchAlgoServices &) override;
void do_launch(IAlgoServices &) override;
void do_update(api::orderman::Update const &) override;
void on_book(SecurityKey, Book const &) override;
void on_settlement(SecurityKey, Price settlement) override;
void on_child_change(OrderKey, ChildState const &) override;
enum class Status {
WAITING_TO_DEPLOY,
WORKING,
DONE
};
using Status = bts::orderman::LimitCoverAlgo::Status;
enum SummaryType {
StatusChange,
FullState
};
private:
struct PImpl;
struct Summary;
std::unique_ptr<PImpl> me;
IAlgoServices &algo() const;
api::Side side() const;
std::string log_header() const;
std::string fmt_state() const;
// returns the first gate in gates (asserts that gates isn't empty).
// Note: after the child is deployed, gates with lower thresholds are
// removed when the limit volume passes the next gates' thresh.
const LimitCoverGate& curr_gate() const;
/// On the compute/recompute methods:
/// compute_blah just returns the result (doesn't mutate any state),
/// while recompute_blah assigns the result to the appropriate field,
/// and returns a bool indicating whether or not the value changed.
// limit price
double compute_limit_price() const;
bool recompute_limit_price();
// limit volume
uint32_t compute_limit_volume() const;
bool recompute_limit_volume();
// recomputes the current gate (i.e., the one with the
// highest activation thresh that is still less than
// the limit volume) then removes all gates with lower threshs.
bool recompute_gate();
uint32_t activation_threshold() const;
//
void try_deploy();
void update_child(uint32_t qty);
};
namespace limit_cover {
namespace utils {
inline std::string fmt_status(LimitCoverAlgo::Status status) {
switch (status) {
case LimitCoverAlgo::Status::WAITING_TO_DEPLOY: return "WAITING_TO_DEPLOY";
case LimitCoverAlgo::Status::WORKING: return "WORKING";
case LimitCoverAlgo::Status::DONE: return "DONE";
default: return Formatter::fmt("STATUS_", static_cast<int>(status));
}
}
void init_delete_and_cover(api::orderman::OrderDefinition& target, const api::orderman::DeleteAndCoverDefinition& def);
void init_delete_and_cover(api::orderman::CustomOrderDefinition& target, const api::orderman::DeleteAndCoverDefinition& def);
void init_child_update(api::orderman::Update& target, uint32_t qty, double price, const api::orderman::DeleteAndCoverDefinition& def);
OrderOpResult validate_def(const api::orderman::OrderDefinition&);
OrderOpResult validate_custom_def(const api::orderman::CustomOrderDefinition&);
OrderOpResult validate_update(const api::orderman::Update&);
} // namespace utils
} // namespace limit_cover
inline std::ostream& operator<<(std::ostream& ostr, const LimitCoverAlgo::Status& status) {
ostr << limit_cover::utils::fmt_status(status);
return ostr;
}
} // namespace orderman
} // namespace bts
@@ -14,6 +14,7 @@
#include <google/protobuf/util/time_util.h>
#include <boost/tokenizer.hpp>
#include <stdint.h>
#include "lib/plugin/SparkServices.h"
namespace bts {
namespace orderman {
@@ -242,6 +243,8 @@ void OnSignalAlgo::_switch_state (State new_state){
static_cast<int>(new_state));
me->state = new_state;
}
extern "C" void init_spark_plugin(bts::SparkServices &) {
}
} // namespace orderman
} // namespace bts
} // namespace bts
@@ -1,584 +0,0 @@
#include "lib/orderman/orders/algo/algo_orders/PyramidAlgo.h"
#include "lib/domain_model/Security.h"
#include "lib/orderman/order_factory/IOrderFactory.h"
#include "lib/orderman/orderman_utils/Book.h"
#include "lib/orderman/orderman_utils/orderman_utils.h"
#include "lib/orderman/orders/algo/IAlgoServices.h"
#include "lib/orderman/orders/spreader_orders/spreader/SpreaderUtils.h"
#include "lib/os/os.h"
#include "lib/domain_model/Security.h"
#include "lib/utils/PBUtils.h"
#include <stdint.h>
namespace bts {
namespace orderman {
using namespace api::orderman;
enum class PyramidAlgo::Status { WAITING_FOR_MD, WAITING_FOR_MD_ATTACH, WORKING, DONE };
enum class PyramidAlgo::ExitPath { CANCEL, ERR, COMPLETE };
struct LegData{
const size_t index;
const SecurityKey sec_key;
const double tick_size;
const api::Side side; //trading side
ChildTemplate* order_template = nullptr;
OrderKey order_key;
ChildState order_state;
bool recv_book;
Book book;
Quantity top_delete; // this will be DONTCARE for covers
Quantity cover_payup;// this will be DONTCARE for top
LegData (size_t index_a,
SecurityKey sec_key_a,
double tick_size_a,
api::Side side_a,
ChildTemplate* order_template_a,
Quantity qty)
:
index (index_a),
sec_key (sec_key_a),
tick_size(tick_size_a),
side (side_a),
order_template (order_template_a),
order_key(null_order_key()),
order_state(),
recv_book(false),
book(),
top_delete(index == 0 ? qty.value() : 0),
cover_payup(index == 0 ? 0 : qty.value())
{
}
const BookSide& opp_md() const{
return book.side(SpreaderUtils::invert_side(side));
}
bool is_top_spread() const{
return index == 0;
}
void set_book (const Book& book_a){
recv_book = true;
book = book_a;
}
};
struct PyramidAlgo::PImpl {
Status state = Status::WAITING_FOR_MD;
IAlgoServices* algo_services = nullptr;
IBeforeLaunchAlgoServices* bl_algo_services;
PyramidAlgo::PyramidAlgoParams params;
std::vector<LegData> legs;
api::Side side;
Price out_price;
Quantity out_qty;
PImpl(){
}
LegData* find_leg_from_sec (SecurityKey sec_key){
for (auto& l : legs)
if(l.sec_key == sec_key)
return &l;
return nullptr;
}
LegData* find_leg_from_ord_key (OrderKey ord_key){
for (auto& l : legs)
if(l.order_key == ord_key)
return &l;
return nullptr;
}
};
PyramidAlgo::PyramidAlgo() : me(new PImpl()) {}
PyramidAlgo::~PyramidAlgo() {}
IAlgoServices& PyramidAlgo::_algo() const { return *me->algo_services; }
// initialization /////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
OrderOpResult PyramidAlgo::do_before_launch(IBeforeLaunchAlgoServices& serv) {
me->bl_algo_services = &serv;
auto& def = serv.definition();
if (def.has_custom_def() && def.custom_def().has_dynamic()){
auto conv_res = _get_creation_params(def.custom_def(), serv);
if (std::get<1>(conv_res)){
// params are good
me->params = std::get<0>(conv_res);
me->side = def.side();
// top spread
auto* t = _create_top_order_template(serv);
double tick_size = serv.lookup_security(me->params.top_spread)->contract_spec().low_tick();
me->legs.emplace_back(0, me->params.top_spread, tick_size, def.side(), t,
me->params.top_delete);
// covers
size_t i = 0;
for (SecurityKey key : me->params.cover_spreads){
auto side = SpreaderUtils::invert_side(def.side());
auto* t = _create_hedge_order_template(serv,i);
double tick_size = serv.lookup_security(key)->contract_spec().low_tick();
me->legs.emplace_back(i+1, key, tick_size, side, t, me->params.cover_payups[i]);
i++;
}
}
else
return {OrderError::ORDER_ERROR_INVALID_PARAMETER,
std::get<2>(conv_res)};
}
else
return {OrderError::ORDER_ERROR_INVALID_PARAMETER,
std::string("Missing parameters")};
return {};
}
void PyramidAlgo::do_launch(IAlgoServices& algo_services) {
me->algo_services = &algo_services;
me->out_price = algo_services.price();
me->out_qty = algo_services.quantity();
for (const LegData& l : me->legs)
algo_services.subscribe_book(l.sec_key);
}
void PyramidAlgo::do_launch_attached(IAlgoServices& algo_services,
OrderKey key,
ChildState c) {
me->algo_services = &algo_services;
if(c.quantity != algo_services.quantity() ||
!bts::securities::is_same(c.price, algo_services.price())){
_cxl_and_end(ExitPath::ERR,
"Pyramid price or quantity did not match the working order",
true);
}
else{
me->legs[0].order_key = key;
me->out_price = c.price;
me->out_qty = c.quantity;
for (const LegData& l : me->legs)
algo_services.subscribe_book(l.sec_key);
_switch_state(PyramidAlgo::Status::WAITING_FOR_MD_ATTACH);
on_child_change(key,c);
}
}
// updates ////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
void PyramidAlgo::do_update(const api::orderman::Update& update) {
LOG(OrderMan, Diag, "PyramidAlgo::do_update order:{} state:{} "
"receiving update: {}",
_algo().order_key().value(),
static_cast<int>(me->state),
utils::pb::to_string(update));
auto conv_res = _get_update_params(update, me->params);
if (!std::get<1>(conv_res)){
LOG(OrderMan, Warn, "PyramidAlgo::do_update order:{} bad update, ignoring",
_algo().order_key().value());
return;
}
const PyramidAlgoParams& algo_params = std::get<0>(conv_res);
Price price = Price(update.price());
Quantity qty = Quantity(update.quantity());
switch(me->state){
case PyramidAlgo::Status::WAITING_FOR_MD:
case PyramidAlgo::Status::WAITING_FOR_MD_ATTACH:
LOG(OrderMan, Info, "PyramidAlgo::do_update order:{} state:{} ignored",
_algo().order_key().value(),static_cast<int>(me->state));
break;
case PyramidAlgo::Status::WORKING:{
bool pq_changed = _copy_update(algo_params, price, qty);
if(_target_reached()){
_cxl_and_end (PyramidAlgo::ExitPath::CANCEL, "Target reached");
return;
}
if (_working_state_met()){
if(pq_changed)
_modify_top_spread_order();
}
else
_cxl_and_end(PyramidAlgo::ExitPath::CANCEL,
"Order cancelled (Cover prices not met)");
break;
}
case PyramidAlgo::Status::DONE:
break;
}
}
// callbacks //////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
void PyramidAlgo::on_book(SecurityKey key, const Book& book) {
LegData* leg_data = me->find_leg_from_sec(key);
if(leg_data != nullptr){
leg_data->set_book(book);
_analyze_md_and_act();
}
}
// this only gets called on am explicit algo cancel
// from the outside
IAlgoOrder::OnCancelResponse PyramidAlgo::on_cancel(){
// cancel top spread, let hedges work, cancel algo
switch(me->state){
case PyramidAlgo::Status::WAITING_FOR_MD:
case PyramidAlgo::Status::WAITING_FOR_MD_ATTACH:
case PyramidAlgo::Status::WORKING:
_cxl_and_end(PyramidAlgo::ExitPath::CANCEL,"Algo cancelled");
break;
case PyramidAlgo::Status::DONE:
break;
}
return IAlgoOrder::OnCancelResponse::IGNORE;
}
void PyramidAlgo::on_child_change(OrderKey key, const ChildState &st) {
LOG(OrderMan, Info,
"PyramidAlgo::on_child_change key:{} child_key:{} state:{} status:{} "
"total_fills:{} last_price:{}",
_algo().order_key(),
key,
static_cast<int>(me->state),
static_cast<int>(st.status),
st.total_fills,
st.last_price);
LegData* leg = me->find_leg_from_ord_key (key);
if (me->legs[0].order_key == key){
switch(me->state){
case PyramidAlgo::Status::WAITING_FOR_MD:
bts_assert_msg (false, "No child orders");
break;
case PyramidAlgo::Status::WAITING_FOR_MD_ATTACH:
leg->order_state = st;
_algo().update_fill_state(st.total_fills, st.avg_price);
_check_for_completion();
break;
case PyramidAlgo::Status::WORKING:
leg->order_state = st;
_algo().update_fill_state(st.total_fills, st.avg_price);
_send_hedges(st.last_fills);
_check_for_completion();
break;
case PyramidAlgo::Status::DONE:
break;
}
}
}
///////////////////////////////////////////////////////////////////////////////
// stateless conversion ///////////////////////////////////////////////////////
PyramidAlgo::PyramidAlgoParams PyramidAlgo::_convert_params (
const CustomOrderDefinition& cod){
const DynamicOrderDefinition& def = cod.dynamic();
const auto& params = def.order_params();
PyramidAlgoParams rv;
// top contract
auto r = get_if<uint32_t>(params, "Top Spread");
rv.top_spread = r.has_value() ? SecurityKey(r.value()) : SecurityKey(0);
// top delete
r = get_if<uint32_t>(params, "Delete");
rv.top_delete = Quantity(r.has_value() ? r.value() : UINT32_MAX);
for (size_t i = 0; i < 5; i++){
auto idx = std::to_string(i+1);
auto b = get_if<uint32_t>(params, "Spread " + idx);
if (b.has_value() && b.value() != 0){
rv.cover_spreads.emplace_back(b.value());
auto pu = get_if<uint32_t>(params, "Spread " + idx + " Payup");
rv.cover_payups.emplace_back(pu.has_value() ? pu.value() : UINT32_MAX);
}
}
return rv;
}
std::tuple<PyramidAlgo::PyramidAlgoParams,bool,std::string>
PyramidAlgo::_get_creation_params(const CustomOrderDefinition& cod,
IBeforeLaunchAlgoServices& serv){
PyramidAlgo::PyramidAlgoParams rv = _convert_params(cod);
// error checking
if(rv.top_spread.value() != serv.security().id())
return std::make_tuple(rv,false,
"Algo can only be launched from the Top Spread");
if(rv.cover_spreads.size() < 2)
return std::make_tuple(rv,false,
"Not enough cover spreads");
if (rv.cover_spreads[0].value() == 0 ||
rv.cover_spreads[1].value() == 0)
return std::make_tuple(rv,false,
"Not enough cover spreads");
return std::make_tuple(rv,true,std::string(""));
}
std::tuple<PyramidAlgo::PyramidAlgoParams,bool,std::string>
PyramidAlgo::_get_update_params(const Update& update,
const PyramidAlgoParams& curr_params){
if(update.has_custom() && update.custom().has_dynamic()){
// means there is a params change
PyramidAlgoParams new_params = _convert_params(update.custom());
if(new_params.top_spread != curr_params.top_spread ||
new_params.cover_spreads.size() != curr_params.cover_spreads.size())
return std::make_tuple(new_params,false,"Contracts can not be updated");
for (size_t i=0; i < curr_params.cover_spreads.size(); i++)
if(new_params.cover_spreads[i] != curr_params.cover_spreads[i])
return std::make_tuple(new_params,false,"Contracts can not be updated");
return std::make_tuple(new_params,true,std::string(""));
}
else
return std::make_tuple(curr_params,true,std::string(""));
}
///////////////////////////////////////////////////////////////////////////////
// order template creation/////////////////////////////////////////////////////
ChildTemplate* PyramidAlgo::_create_top_order_template (
IBeforeLaunchAlgoServices& serv) const{
OrderDefinition order_def = serv.definition();
order_def.set_security_key (me->params.top_spread.value());
order_def.set_side(me->side);
order_def.mutable_custom_def()->mutable_limit()->MergeFrom (
LimitOrderDefinition());
return &(serv.make_child_template(order_def));
}
ChildTemplate* PyramidAlgo::_create_hedge_order_template (
IBeforeLaunchAlgoServices& serv,
size_t hedge_idx) const{
OrderDefinition order_def = serv.definition();
order_def.set_attach_target_order_key(null_order_key().value());
order_def.set_security_key (me->params.cover_spreads[hedge_idx].value());
order_def.set_side(SpreaderUtils::invert_side(me->side));
order_def.set_sub_type(ORDER_SUB_TYPE_HEDGING_LEG);
LeanOrderDefinition lean;
lean.mutable_cross_threshold()->set_absolute(me->params.cover_payups[hedge_idx].value());
lean.set_max_chase_ticks(1);
lean.set_trade_toward_behavior(LeanOrderDefinition::NO_CHANGE);
lean.mutable_child()->mutable_limit()->MergeFrom (
LimitOrderDefinition());
order_def.mutable_custom_def()->mutable_lean()->MergeFrom (lean);
return &(serv.make_child_template(order_def));
}
void PyramidAlgo::_analyze_md_and_act(){
switch(me->state){
case PyramidAlgo::Status::WAITING_FOR_MD:
if(!_md_recvd())
return;
// received data for the first time
if (_working_state_met()){
// enter order, and switch state
LegData& top_leg = me->legs[0];
// this is the only place top spread order is sent (once)
top_leg.order_key = _algo().launch_child(
*top_leg.order_template,
me->out_price,
me->out_qty);
LOG(OrderMan, Info,"PyramidAlgo::_analyze_md_and_act launching order key:{} "
"child_key:{} price:{} qty:{}",
_algo().order_key(),
top_leg.order_key,
me->out_price,
me->out_qty);
_switch_state(PyramidAlgo::Status::WORKING);
}
else
_cxl_and_end(PyramidAlgo::ExitPath::CANCEL,
"Order cancelled (Cover prices not met)");
break;
case PyramidAlgo::Status::WAITING_FOR_MD_ATTACH:
if(!_md_recvd())
return;
// received data for the first time
if (_working_state_met())
_switch_state(PyramidAlgo::Status::WORKING);
else
_cxl_and_end(PyramidAlgo::ExitPath::CANCEL,
"Order detached (Cover prices not met)",
true);
break;
case PyramidAlgo::Status::WORKING:
if (!_working_state_met())
_cxl_and_end(PyramidAlgo::ExitPath::CANCEL,
"Order cancelled (Cover prices not met)");
break;
case PyramidAlgo::Status::DONE:
break;
}
}
void PyramidAlgo::_switch_state(Status new_state){
switch(new_state){
case (PyramidAlgo::Status::WAITING_FOR_MD):
bts_assert(false);
break;
case (PyramidAlgo::Status::WAITING_FOR_MD_ATTACH):
bts_assert(me->state == PyramidAlgo::Status::WAITING_FOR_MD);
break;
case (PyramidAlgo::Status::WORKING):
bts_assert(me->state == PyramidAlgo::Status::WAITING_FOR_MD ||
me->state == PyramidAlgo::Status::WAITING_FOR_MD_ATTACH);
break;
case (PyramidAlgo::Status::DONE):
bts_assert(
// when an order is entered and the criteria is not met
me->state == PyramidAlgo::Status::WAITING_FOR_MD ||
// when an order is attached and the market conditions are not met
me->state == PyramidAlgo::Status::WAITING_FOR_MD_ATTACH ||
// when the child order gets into an unexpected state
me->state == PyramidAlgo::Status::WORKING);
break;
}
LOG(OrderMan, Info,"PyramidAlgo::_switch_state key:{} {}->{} ",
_algo().order_key(),
static_cast<int>(me->state),
static_cast<int>(new_state));
me->state = new_state;
}
void PyramidAlgo::_send_hedges (Quantity filled_qty){
if (filled_qty.value() > 0)
for (auto& l : me->legs)
if(!l.is_top_spread()){
const auto& inside_md = l.opp_md()[0];
Price hedge_price = Price(inside_md.price());
uint32_t inside_md_qty = inside_md.size();
if (l.cover_payup.value() != 0 &&
inside_md_qty > l.cover_payup.value())
hedge_price = securities::worsen_price(l.side, hedge_price, Price(l.tick_size));
// check payup
l.order_key = _algo().launch_child(
*l.order_template,
hedge_price,
filled_qty);
_algo().detach_child(l.order_key);
}
}
void PyramidAlgo::_modify_top_spread_order(){
Update child_update;
child_update.set_price(me->out_price.value());
child_update.set_quantity(me->out_qty.value());
LOG(OrderMan, Info,"PyramidAlgo::_modify_top_spread_order modifying order key:{} "
"child_key:{} price:{} qty:{}",
_algo().order_key(),
me->legs[0].order_key,
me->out_price,
me->out_qty);
_algo().update_child(me->legs[0].order_key, child_update);
}
// copies the params, price and qty to the state
// retuns true is the price or qty has changed
bool PyramidAlgo::_copy_update(const PyramidAlgoParams& algo_params,
Price price, Quantity qty){
// copy input params (which are stored seperately)
me->params.top_delete = algo_params.top_delete;
size_t cov_idx = 0;
for (Quantity payup : algo_params.cover_payups)
me->params.cover_payups[cov_idx++] = payup;
// copy leg data
cov_idx = 0;
me->legs[0].top_delete = algo_params.top_delete;
for (Quantity pu : algo_params.cover_payups){
LegData& cover_leg = me->legs[cov_idx+1];
if(cover_leg.cover_payup != pu){
cover_leg.cover_payup = pu;
cover_leg.order_template = _create_hedge_order_template(
*me->bl_algo_services,
cov_idx);
}
cov_idx++;
}
// copy price and qty (returns true is they have changed)
bool pq_changed = me->out_qty.value() != qty.value() ||
!bts::securities::is_same(me->out_price, price);
me->out_price = price;
me->out_qty = qty;
return pq_changed;
}
// if the top spread order is in a final state, the algo
// algo goes to the final state
void PyramidAlgo::_check_for_completion(){
const ChildState& top_ord = me->legs[0].order_state;
switch (top_ord.status){
case (ChildStatus::WORKING):
break;
case (ChildStatus::COMPLETED):
_cxl_and_end(PyramidAlgo::ExitPath::ERR,"");
break;
case (ChildStatus::CANCELED):
_cxl_and_end(PyramidAlgo::ExitPath::ERR,
"Top spread unexpectedly cancelled");
break;
}
}
void PyramidAlgo::_cxl_and_end(PyramidAlgo::ExitPath exit_path,
const std::string& msg,
bool detach_top){
if(me->legs[0].order_key != null_order_key()){
const ChildState& top_ord_state = me->legs[0].order_state;
if(top_ord_state.status == ChildStatus::WORKING){
if(detach_top)
_algo().detach_child(me->legs[0].order_key);
else
_algo().cancel_child(me->legs[0].order_key);
}
}
switch(exit_path){
case PyramidAlgo::ExitPath::ERR:
_algo().terminate_error(msg);
break;
case PyramidAlgo::ExitPath::CANCEL:
_algo().cancel(msg);
break;
case PyramidAlgo::ExitPath::COMPLETE:
_algo().complete();
break;
}
_switch_state(PyramidAlgo::Status::DONE);
}
// true the out qty is changed it be below
// the filled qty
bool PyramidAlgo::_target_reached() const{
return me->legs[0].order_state.total_fills.value() >=
me->out_qty.value();
}
bool PyramidAlgo::_md_recvd() const{
for (const LegData& l : me->legs)
if(!l.recv_book)
return false;
return true;
}
bool gr_than_eq(double p1, double p2){
return securities::test_price_equality(p1,p2) || p1 > p2;
}
bool less_than_eq(double p1, double p2){
return securities::test_price_equality(p1,p2) || p1 < p2;
}
bool PyramidAlgo::_working_state_met() const{
double cover_sum = 0.0;
size_t i = 0;
for (const auto& l : me->legs)
if (i++ > 0)
cover_sum += l.opp_md()[0].price();
bool rv = !os::is_nan(cover_sum) &&
(
(
me->side == api::Side::SIDE_BUY &&
less_than_eq(me->out_price.value(),cover_sum)
)
||
(
me->side == api::Side::SIDE_SELL &&
gr_than_eq(me->out_price.value(),cover_sum)
)
);
if (!rv && !os::is_nan(cover_sum)){
// price condition is not met, but if the
// cum qty at the top leg price is > threashold
// then the condition is met ()
const auto& top_leg = me->legs[0];
Quantity cumm_level_qty;
SpreaderUtils::find_qty_upto_price_level(top_leg.book,
top_leg.side,
Price(me->out_price),
0.0,
cumm_level_qty);
rv = cumm_level_qty.value() > top_leg.top_delete.value();
}
return rv;
}
} // namespace orderman
} // namespace bts
@@ -1,74 +0,0 @@
#pragma once
#include "lib/orderman/orders/algo/IAlgoOrder.h"
namespace bts {
namespace orderman {
class ChildTemplate;
struct LegData;
class PyramidAlgo : public IAlgoOrder {
public:
PyramidAlgo();
~PyramidAlgo();
struct PyramidAlgoParams{
// first one is the top
SecurityKey top_spread;
Quantity top_delete;
std::vector<SecurityKey> cover_spreads;
std::vector<Quantity> cover_payups;
};
public:
OrderOpResult do_before_launch(IBeforeLaunchAlgoServices &) override;
void do_launch(IAlgoServices &) override;
void do_launch_attached(IAlgoServices &, OrderKey, ChildState) override;
void do_update(api::orderman::Update const &) override;
void on_book(SecurityKey, Book const &) override;
void on_child_change(OrderKey, ChildState const &) override;
IAlgoOrder::OnCancelResponse on_cancel() override;
private:
enum class Status;
enum class ExitPath;
struct PImpl;
std::unique_ptr<PImpl> me;
private:
IAlgoServices& _algo() const ;
// converts parameters from the CustomOrderDefinition::dynamic
// to PyramidAlgoParams
static PyramidAlgoParams _convert_params (
const bts::api::orderman::CustomOrderDefinition&);
static std::tuple<PyramidAlgoParams,bool,std::string> _get_creation_params(
const bts::api::orderman::CustomOrderDefinition&,
IBeforeLaunchAlgoServices&);
static std::tuple<PyramidAlgoParams,bool,std::string> _get_update_params(
const api::orderman::Update&,
const PyramidAlgoParams& curr_params);
ChildTemplate* _create_top_order_template (IBeforeLaunchAlgoServices&) const;
ChildTemplate* _create_hedge_order_template (IBeforeLaunchAlgoServices&,
size_t) const;
// acts on md, cognizant of the state
void _analyze_md_and_act();
void _switch_state (Status new_status);
void _send_hedges (Quantity filled_qty);
void _modify_top_spread_order();
// returns true is the price, qty changes
bool _copy_update(const PyramidAlgoParams& algo_params,
Price price, Quantity qty);
void _check_for_completion();
// cxl's the working top leg order (if any), detaches
// all hedges. if is_error then terminates algo, is
// is_cxl then cxl's algo, otherwise completes it
void _cxl_and_end(ExitPath exit_path,
const std::string& err_txt,
bool detach_top = false);
bool _target_reached() const;
// true is all legs have recvd md
bool _md_recvd() const;
bool _working_state_met() const;
};
} // namespace orderman
} // namespace bts
@@ -1,253 +0,0 @@
#include "lib/plugin/SparkServices.h"
#include "lib/api/services/OrderService.pb.h"
#include "lib/logging/logging.h"
#include "lib/orderman/orderman_utils/orderman_utils.h"
#include "lib/orderman/orders/algo/algo_orders/limit_cover/LimitCoverAdapter.h"
#include "lib/orderman/orders/algo/algo_orders/LimitCoverAlgo.h"
#include "lib/config/protos/toggles.pb.h"
#include "lib/config/config.h"
#include "DormanAlgo.h"
#include "PyramidAlgo.h"
#include "TASAlgo.h"
#include "TASCounterAlgo.h"
#include "OnSignalAlgo.h"
using namespace bts;
using namespace api::orderman;
using namespace orderman::dorman;
using namespace orderman;
namespace bts {
namespace orderman {
namespace dorman {
template <class OK,class ERR>
using Result = std::variant<OK,ERR>;
Result<AlgoParams,OrderOpResult> bad_definition(const char* msg) { return {OrderOpResult{ORDER_ERROR_INVALID_ORDER_DEFINITON, msg}}; }
// Validate DynamicOrderDefinition and construct parameter object
Result<AlgoParams,OrderOpResult> to_dorman_params(const api::orderman::DynamicOrderDefinition& def) {
const auto& params = def.order_params();
AlgoParams res;
//
// Step Table
for (size_t x = 0; x < 5; ++x) {
auto xs = std::to_string(x+1);
auto mq = get_if<uint32_t>(params, "Market Quantity " + xs).value_or(0);
auto oq = get_if<uint32_t>(params, "Order Quantity " + xs).value_or(0);
if (mq && oq) {
res.steps.step_table.push_back({ mq, oq });
}
}
std::sort(res.steps.step_table.begin(), res.steps.step_table.end());
res.steps.maximum = get_if<uint32_t>(params, "Max Size").value_or(-1);
res.steps.trail_seconds = get_if<uint32_t>(params, "Trail Seconds").value_or(0);
//
// Clip limit
res.clip_limit = get_if<uint32_t>(params, "Clip Size").value_or(0);
//
// scratch
auto enable_scratch = get_if<bool>(params, "Enable Scratch");
if (enable_scratch && enable_scratch.value()) {
auto overfill = get_if<uint32_t>(params, "Max Overfill");
if (!overfill) return bad_definition("Missing 'Max Overfill'");
res.scratch = { overfill.value() };
}
//
// profit orders
auto enable_profit_orders = get_if<bool>(params, "Profit Orders");
if (enable_profit_orders && enable_profit_orders.value()) {
auto ticks = get_if<uint32_t>(params, "Ticks Away");
if (!ticks) return bad_definition("Missing 'Ticks Away'");
res.profit_orders = { ticks.value() };
}
//
// trade accumulation
auto trade_acc = get_if<bool>(params, "Trade Accumulation").value_or(false);
if (trade_acc) {
TradeAccumulationParams tap;
auto contracts = get_if<uint32_t>(params, "Trade Contracts");
if (!contracts) return bad_definition("Missing 'Trade Accumulation # Contracts'");
tap.contracts = contracts.value();
auto interval = get_if<uint32_t>(params, "Trade Interval (seconds)");
if (!interval) return bad_definition("Missing 'Trade Accumulation Interval'");
tap.seconds = interval.value();
auto sleep = get_if<uint32_t>(params, "Trade Sleep (seconds)");
if (!sleep) return bad_definition("Missing 'Trade Accumulation Sleep'");
tap.sleep_seconds = sleep.value();
res.trade_accumulation = {tap};
}
return {res};
}
extern "C" void init_dorman_plugin(bts::SparkServices &srv) {
DynamicOrderDescriptor join_desc;
join_desc.set_dynamic_order_type("Dorman");
*join_desc.add_param_desc() = param_array("what", param_double("").param_type());
*join_desc.add_param_desc() = param_uint32("Market Quantity 1");
*join_desc.add_param_desc() = param_uint32("Order Quantity 1");
*join_desc.add_param_desc() = param_uint32("Market Quantity 2");
*join_desc.add_param_desc() = param_uint32("Order Quantity 2");
*join_desc.add_param_desc() = param_uint32("Market Quantity 3");
*join_desc.add_param_desc() = param_uint32("Order Quantity 3");
*join_desc.add_param_desc() = param_uint32("Market Quantity 4");
*join_desc.add_param_desc() = param_uint32("Order Quantity 4");
*join_desc.add_param_desc() = param_uint32("Market Quantity 5");
*join_desc.add_param_desc() = param_uint32("Order Quantity 5");
*join_desc.add_param_desc() = param_uint32("Max Size");
*join_desc.add_param_desc() = param_uint32("Trail Seconds");
*join_desc.add_param_desc() = param_uint32("Clip Size");
*join_desc.add_param_desc() = param_bool("Enable Scratch");
*join_desc.add_param_desc() = param_uint32("Max Overfill");
*join_desc.add_param_desc() = param_bool("Profit Orders");
*join_desc.add_param_desc() = param_uint32("Ticks Away");
*join_desc.add_param_desc() = param_bool("Trade Accumulation");
*join_desc.add_param_desc() = param_uint32("Trade Contracts");
*join_desc.add_param_desc() = param_uint32("Trade Interval (seconds)");
*join_desc.add_param_desc() = param_uint32("Trade Sleep (seconds)");
srv.register_dynamic_algo_order(join_desc, []() { return std::make_unique<DormanAlgo>(); });
}
extern "C" void init_pyramid_plugin(bts::SparkServices& srv) {
DynamicOrderDescriptor join_desc;
join_desc.set_dynamic_order_type("Pyramid");
*join_desc.add_param_desc() = param_security_key("Top Spread");
*join_desc.add_param_desc() = param_uint32("Delete");
*join_desc.add_param_desc() = param_security_key("Spread 1");
*join_desc.add_param_desc() = param_uint32("Spread 1 Payup");
*join_desc.add_param_desc() = param_order("Spread 1 Order");
*join_desc.add_param_desc() = param_security_key("Spread 2");
*join_desc.add_param_desc() = param_uint32("Spread 2 Payup");
*join_desc.add_param_desc() = param_order("Spread 2 Order");
*join_desc.add_param_desc() = param_security_key("Spread 3");
*join_desc.add_param_desc() = param_uint32("Spread 3 Payup");
*join_desc.add_param_desc() = param_order("Spread 3 Order");
*join_desc.add_param_desc() = param_security_key("Spread 4");
*join_desc.add_param_desc() = param_uint32("Spread 4 Payup");
*join_desc.add_param_desc() = param_order("Spread 4 Order");
*join_desc.add_param_desc() = param_security_key("Spread 5");
*join_desc.add_param_desc() = param_uint32("Spread 5 Payup");
*join_desc.add_param_desc() = param_order("Spread 5 Order");
srv.register_dynamic_algo_order(join_desc, []() { return std::make_unique<orderman::PyramidAlgo>(); });
}
extern "C" void init_tascounter_plugin(bts::SparkServices& srv) {
DynamicOrderDescriptor join_desc;
join_desc.set_dynamic_order_type("TASCounter");
// all 6 contracts. They can theoretically be inferred from the front month
// since T1 are calendars 1 month apart starting from the front month
// ex Mar-May, May-Jul, Jul-Sep being T1 front, second and third respectively
// (assuming Mar is the front month)
*join_desc.add_param_desc() = param_security_key("T1 Front");
*join_desc.add_param_desc() = param_security_key("T1 Second");
*join_desc.add_param_desc() = param_security_key("T1 Third");
*join_desc.add_param_desc() = param_security_key("T2 Front");
*join_desc.add_param_desc() = param_security_key("T2 Second");
*join_desc.add_param_desc() = param_security_key("T3 Front");
// tas contracts (could have been derived)
*join_desc.add_param_desc() = param_security_key("T1 Front TAS");
*join_desc.add_param_desc() = param_security_key("T1 Second TAS");
*join_desc.add_param_desc() = param_security_key("T1 Third TAS");
// automatic orders
*join_desc.add_param_desc() = param_uint32("T1 Front Time");
*join_desc.add_param_desc() = param_uint32("T1 Front Qty");
*join_desc.add_param_desc() = param_bool("T1 Front Order Enabled");
*join_desc.add_param_desc() = param_uint32("T1 Second Time");
*join_desc.add_param_desc() = param_uint32("T1 Second Qty");
*join_desc.add_param_desc() = param_bool("T1 Second Order Enabled");
*join_desc.add_param_desc() = param_uint32("T1 Third Time");
*join_desc.add_param_desc() = param_uint32("T1 Third Qty");
*join_desc.add_param_desc() = param_bool("T1 Third Order Enabled");
// settlement time
*join_desc.add_param_desc() = param_uint32("Settlement Start Hour");
*join_desc.add_param_desc() = param_uint32("Settlement Start Minutes");
*join_desc.add_param_desc() = param_uint32("Settlement Start Seconds");
*join_desc.add_param_desc() = param_uint32("Settlement Period (seconds)");
srv.register_dynamic_algo_order(join_desc, []() { return std::make_unique<orderman::TASCounterAlgo>(); });
}
extern "C" void init_tas_plugin(bts::SparkServices& srv) {
DynamicOrderDescriptor tas_desc;
tas_desc.set_dynamic_order_type("TAS");
size_t n_child_ords = 8;
for (size_t i=0; i< n_child_ords; i++){
auto idx = std::to_string(i+1);
*tas_desc.add_param_desc() = param_double("Order " + idx + " Price");
*tas_desc.add_param_desc() = param_uint32("Order " + idx + " Quantity");
*tas_desc.add_param_desc() = param_bool("Order " + idx + " Buy?");
}
srv.register_dynamic_algo_order(tas_desc, []() { return std::make_unique<orderman::TASAlgo>(); });
}
extern "C" void init_limit_cover(bts::SparkServices & srv) {
DynamicOrderDescriptor lc_desc;
lc_desc.set_dynamic_order_type("LimitCover");
LimitCoverAdapter::define_proto(lc_desc);
srv.register_dynamic_algo_order(lc_desc, []() { return std::make_unique<orderman::LimitCoverAlgo>(); });
}
extern "C" void init_on_signal_plugin(bts::SparkServices& srv) {
DynamicOrderDescriptor on_signal;
on_signal.set_dynamic_order_type("OnSignal");
*on_signal.add_param_desc() = param_uint32("Time Hours");
*on_signal.add_param_desc() = param_uint32("Time Minutes");
*on_signal.add_param_desc() = param_uint32("Time Seconds");
*on_signal.add_param_desc() = param_bool("Preopen");
*on_signal.add_param_desc() = param_bool("Open");
// contracts who's signals have to be received to send the algo
*on_signal.add_param_desc() = param_security_key("Signal Contract 1");
size_t n_child_ords = 10;
for (size_t i=0; i< n_child_ords; i++){
auto idx = std::to_string(i+1);
*on_signal.add_param_desc() = param_security_key("Order " + idx + " Contract");
*on_signal.add_param_desc() = param_order("Order " + idx);
*on_signal.add_param_desc() = param_double("Order " + idx + " Price");
*on_signal.add_param_desc() = param_int32("Order " + idx + " Quantity");
}
srv.register_dynamic_algo_order(on_signal, []() { return std::make_unique<orderman::OnSignalAlgo>(); });
}
extern "C" void init_spark_plugin(bts::SparkServices &srv) {
auto& dyn_algo_config = config::get<config::toggles::DynamicAlgos>();
if(dyn_algo_config.enable_dorman())
init_dorman_plugin(srv);
if(dyn_algo_config.enable_pyramid())
init_pyramid_plugin(srv);
if(dyn_algo_config.enable_tas())
init_tas_plugin(srv);
if(dyn_algo_config.enable_tascounter())
init_tascounter_plugin(srv);
if (dyn_algo_config.enable_limit_cover())
init_limit_cover(srv);
if (dyn_algo_config.enable_onsignal())
init_on_signal_plugin(srv);
}
}}}
@@ -1,222 +0,0 @@
#include "lib/orderman/orders/algo/algo_orders/TASAlgo.h"
#include "lib/domain_model/Security.h"
#include "lib/orderman/order_factory/IOrderFactory.h"
#include "lib/orderman/orderman_utils/Book.h"
#include "lib/orderman/orderman_utils/orderman_utils.h"
#include "lib/orderman/orders/algo/IAlgoServices.h"
#include "lib/orderman/orders/spreader_orders/spreader/SpreaderUtils.h"
#include "lib/os/os.h"
#include "lib/domain_model/Security.h"
#include "lib/utils/PBUtils.h"
#include "lib/utils/datetime.h"
#include <stdint.h>
namespace bts {
namespace orderman {
using namespace api::orderman;
enum class TASAlgo::Status { WAITING_FOR_SIGNAL, WORKING, DONE };
struct TASLegData{
api::Side side; //trading side
Price price;
Quantity quantity;
ChildTemplate* order_template = nullptr;
OrderKey order_key;
ChildState order_state;
TASLegData (api::Side side,
Price price,
Quantity quantity,
ChildTemplate* order_template)
:
side (side),
price(price),
quantity(quantity),
order_template (order_template),
order_key(null_order_key()),
order_state(){
order_state.status = ChildStatus::WORKING;
}
};
struct TASAlgo::PImpl {
Status state = Status::WAITING_FOR_SIGNAL;
IAlgoServices* algo_services = nullptr;
SecurityKey sec_key = SecurityKey(0);
TASAlgo::TASAlgoParams algo_params;
std::vector<TASLegData> legs;
bts::datetime::PTime start_time = bts::datetime::local_now();
PImpl(){
}
TASLegData* find_leg_from_ord_key (OrderKey ord_key){
for (auto& l : legs)
if(l.order_key == ord_key)
return &l;
return nullptr;
}
};
TASAlgo::TASAlgo() : me(new PImpl()) {}
TASAlgo::~TASAlgo() {}
// initialization /////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
OrderOpResult TASAlgo::do_before_launch(IBeforeLaunchAlgoServices& serv) {
auto& def = serv.definition();
if (def.has_custom_def() && def.custom_def().has_dynamic()){
const auto& sec = serv.security();
me->sec_key = SecurityKey(sec.id());
me->algo_params = _convert_params(def.custom_def());
if (me->algo_params.child_orders.size() > 0){
for (const auto& t : me->algo_params.child_orders){
Price price = std::get<0>(t);
Quantity quantity = std::get<1>(t);
api::Side side = std::get<2>(t);
auto* ordt = _create_order_template(
serv,
SecurityKey(sec.id()),
side);
me->legs.emplace_back(side,
price,
quantity,
ordt);
}
return {};
}
}
return {OrderError::ORDER_ERROR_INVALID_PARAMETER,
std::string("Parameters are not well formed")};
}
void TASAlgo::do_launch(IAlgoServices& algo_services) {
me->algo_services = &algo_services;
_algo().subscribe_status(me->sec_key);
//_algo().subscribe_timer();
}
void TASAlgo::do_launch_attached(IAlgoServices& algo_services,
OrderKey,
ChildState) {
me->algo_services = &algo_services;
_cxl_and_end(true, "TAS Algo can not be attached to working orders");
}
// updates ////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
void TASAlgo::do_update(const api::orderman::Update&) {
LOG(OrderMan, Warn, "TASAlgo::do_update order:{} state:{} update not allowed ",
_algo().order_key().value(),
static_cast<int>(me->state));
}
// callbacks //////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
void TASAlgo::on_book(SecurityKey, const Book&) {
}
void TASAlgo::on_child_change(OrderKey key,
ChildState const &st){
LOG(OrderMan, Info,
"TASAlgo::on_child_change key:{} child_key:{} state:{} status:{} "
"total_fills:{} last_price:{}",
_algo().order_key(),
key,
static_cast<int>(me->state),
static_cast<int>(st.status),
st.total_fills,
st.last_price);
TASLegData* ld_ptr = me->find_leg_from_ord_key(key);
if (ld_ptr != nullptr)
ld_ptr->order_state = st;
for (const auto& l : me->legs)
if(l.order_state.status == ChildStatus::WORKING)
return;
_cxl_and_end(false,"");
}
void TASAlgo::on_status(SecurityKey key, co2::TradingStatus status){
if(key == me->sec_key &&
status == co2::TradingStatus::TRADINGSTATUS_PRE_OPEN){
switch (me->state){
case TASAlgo::Status::WAITING_FOR_SIGNAL:
for (auto& l : me->legs){
l.order_key = _algo().launch_child(
*l.order_template,
l.price,
l.quantity);
LOG(OrderMan, Info,"TASAlgo::on_status launching order key:{} "
"child_key:{} price:{} qty:{}",
_algo().order_key(),
l.order_key,
l.price,
l.quantity);
}
_switch_state(TASAlgo::Status::WORKING);
break;
case TASAlgo::Status::WORKING:
case TASAlgo::Status::DONE:
break;
}
}
}
void TASAlgo::on_timer(){
if (bts::datetime::msecs_since(me->start_time) > 10000)
on_status(me->sec_key,co2::TradingStatus::TRADINGSTATUS_PRE_OPEN);
}
IAlgoServices& TASAlgo::_algo() const { return *me->algo_services; }
///////////////////////////////////////////////////////////////////////////////
// stateless conversion ///////////////////////////////////////////////////////
TASAlgo::TASAlgoParams TASAlgo::_convert_params (
const bts::api::orderman::CustomOrderDefinition& cod){
const DynamicOrderDefinition& def = cod.dynamic();
const auto& params = def.order_params();
TASAlgo::TASAlgoParams rv;
for (size_t i = 0; i < 1024; i++){
auto idx = std::to_string(i+1);
auto price = get_if<double>(params, "Order " + idx + " Price");
auto qty = get_if<uint32_t>(params, "Order " + idx + " Quantity");
auto is_buy = get_if<bool>(params, "Order " + idx + " Buy?");
if(price.has_value() && qty.has_value() && qty.value() != 0){
api::Side side = is_buy.has_value() ?
(is_buy.value() ? api::Side::SIDE_BUY : api::Side::SIDE_SELL) :
api::Side::SIDE_SELL;
rv.child_orders.emplace_back(Price(price.value()), Quantity(qty.value()), side);
}
}
return rv;
}
ChildTemplate* TASAlgo::_create_order_template (
IBeforeLaunchAlgoServices& serv,
SecurityKey key,
api::Side side){
OrderDefinition order_def = serv.definition();
order_def.set_security_key (key.value());
order_def.set_side(side);
order_def.mutable_custom_def()->mutable_limit()->MergeFrom (
api::orderman::LimitOrderDefinition());
return &(serv.make_child_template(order_def));
}
void TASAlgo::_switch_state(TASAlgo::Status new_state){
switch (new_state){
case (TASAlgo::Status::WAITING_FOR_SIGNAL):
bts_assert(false);
break;
case (TASAlgo::Status::WORKING):
bts_assert(me->state == TASAlgo::Status::WAITING_FOR_SIGNAL);
break;
case (TASAlgo::Status::DONE):
bts_assert(me->state != TASAlgo::Status::DONE);
break;
}
LOG(OrderMan, Info,"TASAlgo::_switch_state key:{} {}->{} ",
_algo().order_key(),
static_cast<int>(me->state),
static_cast<int>(new_state));
me->state = new_state;
}
void TASAlgo::_cxl_and_end (bool is_error, const std::string& err_msg){
if(is_error)
_algo().terminate_error(err_msg);
else
_algo().complete();
_switch_state(TASAlgo::Status::DONE);
}
} // namespace orderman
} // namespace bts
@@ -1,45 +0,0 @@
#pragma once
#include "lib/orderman/orders/algo/IAlgoOrder.h"
namespace bts {
namespace orderman {
class ChildTemplate;
struct LegData;
class TASAlgo : public IAlgoOrder {
public:
TASAlgo();
~TASAlgo();
struct TASAlgoParams{
std::vector<std::tuple<Price, Quantity, api::Side>> child_orders;
};
public:
OrderOpResult do_before_launch(IBeforeLaunchAlgoServices &) override;
void do_launch(IAlgoServices &) override;
void do_launch_attached(IAlgoServices &, OrderKey, ChildState) override;
void do_update(api::orderman::Update const &) override;
void on_book(SecurityKey, Book const &) override;
void on_child_change(OrderKey, ChildState const &) override;
void on_status(SecurityKey, co2::TradingStatus) override;
void on_timer() override;
private:
enum class Status;
struct PImpl;
std::unique_ptr<PImpl> me;
private:
IAlgoServices& _algo() const ;
static TASAlgoParams _convert_params (
const bts::api::orderman::CustomOrderDefinition&);
static ChildTemplate* _create_order_template (IBeforeLaunchAlgoServices&,
SecurityKey,
api::Side);
// acts on md, cognizant of the state
void _switch_state (Status new_status);
void _cxl_and_end (bool is_error, const std::string& err_msg);
};
} // namespace orderman
} // namespace bts
@@ -1,490 +0,0 @@
#include "lib/orderman/orders/algo/algo_orders/TASCounterAlgo.h"
#include "lib/domain_model/Security.h"
#include "lib/orderman/order_factory/IOrderFactory.h"
#include "lib/orderman/orderman_utils/Book.h"
#include "lib/orderman/orderman_utils/orderman_utils.h"
#include "lib/orderman/orders/algo/IAlgoServices.h"
#include "lib/orderman/orders/spreader_orders/spreader/SpreaderUtils.h"
#include "lib/os/os.h"
#include "lib/domain_model/Security.h"
#include "lib/utils/PBUtils.h"
#include "lib/utils/datetime.h"
#include <google/protobuf/timestamp.pb.h>
#include "lib/orderman/actors/SODPosition.h"
#include <google/protobuf/util/time_util.h>
#include <stdint.h>
namespace bts {
namespace orderman {
using namespace api::orderman;
using namespace google::protobuf;
enum class TASCounterAlgo::Status { WORKING, DONE };
// book and trade data for each of the 6 contracts as well as the TAS contracts
// (the vwap of the TAS contracts is not used, but for uniformity is kept in the
// the same structure)
struct ContractMarketData{
uint32_t tot_vol = 0;
double running_sum = 0;
Book book;
double estimated_settle = 0.0;
void on_trade (const TickerUpdateEvent::Trade& t){
tot_vol += t.quantity.value();
running_sum += t.price.value()*t.quantity.value();
}
const double vwap(){
return tot_vol == 0 ? os::nan() : running_sum/tot_vol;
}
};
// the input for the t1 front, second and third orders, as well as the template
// and working order key are kept here
struct ContractAutoOrder{
// inputs
uint32_t n_secs = 0;
uint32_t qty = 0;
bool enabled = false;
// dont know yet which side will be sent
ChildTemplate* buy_ord = nullptr;
ChildTemplate* sell_ord = nullptr;
// computed input
// the is AlgoData::settle_stop - n_secs
Timestamp algo_start;
// output
std::optional<OrderKey> tas_order = std::nullopt;
};
struct AlgoData{
double tick_size;
Timestamp settle_start;
Timestamp settle_stop;
ContractMarketData t1_front,
t1_second,
t1_third,
t2_front,
t2_second,
t3_front;
ContractMarketData t1_front_tas,
t1_second_tas,
t1_third_tas;
ContractAutoOrder t1_front_order,
t1_second_order,
t1_third_order;
DynamicOrderState out_state;
};
struct TASCounterAlgo::PImpl {
// reporting
uint16_t reporting_period_msecs = 500;
bts::datetime::PTime last_report_time = bts::datetime::now();
// immutable state
IAlgoServices* algo_services = nullptr;
// mutable state
AlgoData data;
// to avoid lookups on md and ticker callbacks
std::map<SecurityKey,ContractMarketData*> md_map;
Status state = Status::WORKING;
};
//fwd decls
void _copy_output(AlgoData&);
bool _copy_settle_times (AlgoData&,const Map<std::string,DynamicOrderParam>&);
void _copy_order_data (AlgoData&,const Map<std::string,DynamicOrderParam>&);
bool _setup_data(IBeforeLaunchAlgoServices&, AlgoData&,
std::map<SecurityKey,ContractMarketData*>&);
double round_to_nearest(double price, double tick_size);
long long t1_minus_t2_usecs (const Timestamp&, const Timestamp&);
long long t_minus_now_usecs (const google::protobuf::Timestamp&);
bool trade_within_time_win (const Timestamp&, const Timestamp&,
const TickerUpdateEvent::Trade& t);
bool now_within_time_win (const Timestamp&, const Timestamp&);
TASCounterAlgo::TASCounterAlgo() : me(new PImpl()) {}
TASCounterAlgo::~TASCounterAlgo() {}
// initialization /////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
OrderOpResult TASCounterAlgo::do_before_launch(IBeforeLaunchAlgoServices& serv) {
if(_setup_data(serv,me->data,me->md_map))
return {};
return {OrderError::ORDER_ERROR_INVALID_PARAMETER,
std::string("Parameters are not well formed")};
}
void TASCounterAlgo::do_launch(IAlgoServices& algo_services) {
me->algo_services = &algo_services;
algo_services.subscribe_timer();
for (const auto& kp : me->md_map){
algo_services.subscribe_book(kp.first);
algo_services.subscribe_ticker(kp.first);
}
}
void TASCounterAlgo::do_launch_attached(
IAlgoServices& algo_services,
OrderKey,
ChildState) {
// not allowed
me->algo_services = &algo_services;
}
// updates ////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
void TASCounterAlgo::do_update(const api::orderman::Update& u) {
if(me->state == Status::DONE)
return;
const auto& p = u.custom().dynamic().order_params();
// only order data change is allowed
_copy_order_data(me->data,p);
_check_and_send_order();
}
// callbacks //////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
void TASCounterAlgo::on_book(SecurityKey k, const Book& b) {
if(me->state == Status::DONE)
return;
const auto& it = me->md_map.find(k);
if(it != me->md_map.end()){
it->second->book = b;
_check_and_send_order();
}
}
void TASCounterAlgo::on_ticker(SecurityKey k, const TradeVector& v){
if(me->state == Status::DONE)
return;
const auto& it = me->md_map.find(k);
if(it != me->md_map.end()){
auto contract_md = it->second;
for (const auto& t : v)
if (_within_settle()){
contract_md->on_trade(t);
}
_check_and_send_order();
}
}
// this only gets called on an explicit algo cancel
// from the outside
TASCounterAlgo::OnCancelResponse TASCounterAlgo::on_cancel(){
return IAlgoOrder::OnCancelResponse::HONOR;
}
void TASCounterAlgo::on_timer(){
if(me->state == Status::DONE)
return;
_check_and_send_order();
if(bts::datetime::msecs_since(me->last_report_time) >=
me->reporting_period_msecs){
me->last_report_time = bts::datetime::now();
_report_state();
}
// check for end and exit
if (t1_minus_t2_usecs(util::TimeUtil::GetCurrentTime(),
me->data.settle_stop) > 0){
std::string msg = "session over";
_cxl_and_end(false,msg);
}
}
IAlgoServices& TASCounterAlgo::_algo() const { return *me->algo_services; }
void TASCounterAlgo::_switch_state(TASCounterAlgo::Status new_state){
switch (new_state){
case (TASCounterAlgo::Status::WORKING):
bts_assert(false);
break;
case (TASCounterAlgo::Status::DONE):
bts_assert(me->state == TASCounterAlgo::Status::WORKING);
break;
}
LOG(OrderMan, Info,"TASCounterAlgo::_switch_state key:{} {}->{} ",
_algo().order_key(),
static_cast<int>(me->state),
static_cast<int>(new_state));
me->state = new_state;
}
void TASCounterAlgo::_cxl_and_end (bool is_error, const std::string& err_msg){
if(me->state == Status::DONE)
return;
if(is_error)
_algo().terminate_error(err_msg);
else
_algo().complete();
_switch_state(TASCounterAlgo::Status::DONE);
}
void TASCounterAlgo::_compute_settles(){
AlgoData& d = me->data;
d.t1_front.estimated_settle = d.t1_front.vwap();
d.t1_second.estimated_settle = d.t2_front.vwap() - d.t1_front.vwap();
d.t1_third.estimated_settle = d.t3_front.vwap() - d.t1_front.vwap() -
d.t1_second.vwap();
// round to closest value
d.t1_front.estimated_settle = round_to_nearest(
d.t1_front.estimated_settle,me->data.tick_size);
d.t1_second.estimated_settle = round_to_nearest(
d.t1_second.estimated_settle,me->data.tick_size);
d.t1_third.estimated_settle = round_to_nearest(
d.t1_third.estimated_settle,me->data.tick_size);
}
// the decision to send an order can be caused by
// 1. change in settings (=> time window, enabling orders etc)
// 2. book update (=> TAS book can result in order)
// 3. ticker (=> new estimated settlement)
// 4. time passing (=> in the window now)
void TASCounterAlgo::_check_and_send_order(){
_compute_settles();
auto should_send_tas_order =
[](const ContractMarketData& c,
const ContractAutoOrder& o,
const ContractMarketData& tas_c,
bool is_buy,
double& out_price,
uint32_t& out_qty) -> bool {
// buying the tas at the offer or selling it at the bid
const auto& tas_opp_top = is_buy ? tas_c.book.ask()[0] : tas_c.book.bid()[0];
const auto& c_same_top = is_buy ? c.book.bid()[0] : c.book.ask()[0];
if(tas_opp_top.size() > 0 && c_same_top.size() > 0){
// delivery price as defined by where the TAS order is traded
double tas_delv_price = c.estimated_settle + tas_opp_top.price();
// if the delv price for the buy order is <= contract bid or
// or the delv price for the sell order is >= contract offer
// then we are buying at the bid or selling at the offer
double c_price = c_same_top.price();
if((is_buy && tas_delv_price <= c_price) ||
(!is_buy && tas_delv_price >= c_price)){
out_qty = std::min(o.qty,tas_opp_top.size());
out_price = tas_opp_top.price();
return true;
}
}
return false;
};
auto _send_order_tn = [&](
const ContractMarketData& c,
ContractAutoOrder& o,
const ContractMarketData& tas_c) -> void {
if(o.enabled && o.n_secs > 0 && o.qty > 0 &&
!o.tas_order.has_value() &&
now_within_time_win(o.algo_start,me->data.settle_stop)){
double price;
uint32_t qty;
if(should_send_tas_order(c,o,tas_c,true,price,qty)){
o.tas_order = _algo().launch_child(*o.buy_ord,
Price(price),
Quantity(qty));
}
else if(should_send_tas_order(c,o,tas_c,false,price,qty)){
o.tas_order = _algo().launch_child(*o.sell_ord,
Price(price),
Quantity(qty));
}
}
};
_send_order_tn(me->data.t1_front,me->data.t1_front_order,me->data.t1_front_tas);
_send_order_tn(me->data.t1_second,me->data.t1_second_order,me->data.t1_second_tas);
_send_order_tn(me->data.t1_third,me->data.t1_third_order,me->data.t1_third_tas);
}
void TASCounterAlgo::_report_state(){
_compute_settles();
_copy_output(me->data);
_algo().update_custom_state(me->data.out_state);
}
bool TASCounterAlgo::_within_settle() const{
return now_within_time_win(me->data.settle_start,me->data.settle_stop);
}
///////////////////////////////////////////////////////////////////////////////
// stateless conversion ///////////////////////////////////////////////////////
// stateless helpers
ChildTemplate* _create_order_template (IBeforeLaunchAlgoServices& serv,
SecurityKey key,
api::Side side){
OrderDefinition order_def = serv.definition();
order_def.set_security_key (key.value());
order_def.set_side(side);
order_def.mutable_custom_def()->mutable_limit()->MergeFrom (
api::orderman::LimitOrderDefinition());
return &(serv.make_child_template(order_def));
}
// copies output into the dynamic state for publishing
void _copy_output(AlgoData& d){
auto& m = *(d.out_state.mutable_custom_state());
// we can safely assume its within int32
auto secs_to_settle = static_cast<int>(t_minus_now_usecs(d.settle_start)/1000000);
// if its in settle (-ve value), its set to 0
secs_to_settle = std::max(secs_to_settle,0);
m["Seconds To Settle"].set_as_int32(secs_to_settle);
m["VWAP T1-Front"].set_as_double(d.t1_front.vwap());
m["VWAP T1-Second"].set_as_double(d.t1_second.vwap());
m["VWAP T1-Third"].set_as_double(d.t1_third.vwap());
m["VWAP T2-Front"].set_as_double(d.t2_front.vwap());
m["VWAP T2-Second"].set_as_double(d.t2_second.vwap());
m["VWAP T3-Front"].set_as_double(d.t3_front.vwap());
m["T1-Front Projected Settle"].set_as_double(d.t1_front.estimated_settle);
m["T1-Second Projected Settle"].set_as_double(d.t1_second.estimated_settle);
m["T1-Third Projected Settle"].set_as_double(d.t1_third.estimated_settle);
}
// copies the settle time/period part of the input data
bool _copy_settle_times (AlgoData& d,
const Map<std::string,DynamicOrderParam>& params){
auto hh = get_if<uint32_t>(params, "Settlement Start Hour");
auto mm = get_if<uint32_t>(params, "Settlement Start Minutes");
auto ss = get_if<uint32_t>(params, "Settlement Start Seconds");
auto settle_period_secs = get_if<uint32_t>(params, "Settlement Period (seconds)");
if (hh.has_value() && mm.has_value() &&
ss.has_value() && settle_period_secs.has_value() &&
hh.value() <= 23 && mm.value() <= 59 && ss.value() <= 59){
d.settle_start = SODPosition::today_local_time_to_utc_timestamp(
hh.value(),
mm.value(),
ss.value(),
true,
false);
d.settle_stop = SODPosition::add_seconds(d.settle_start,
settle_period_secs.value());
auto settle_start_txt = util::TimeUtil::ToString(d.settle_start);
auto settle_stop_txt = util::TimeUtil::ToString(d.settle_stop);
LOG(OrderMan, Info, "TASCounterAlgo::_copy_settle_times "
"settle_start:{} settle_stop:{} ",
settle_start_txt,
settle_stop_txt);
return true;
}
return false;
}
// copies the order execution part of the input data
void _copy_order_data (AlgoData& out_d,
const Map<std::string,DynamicOrderParam>& params){
auto copy_o = [&](ContractAutoOrder& out_order,
std::string time_name,
std::string qty_name,
std::string enabled_name
) -> bool {
out_order.enabled = false;
auto time = get_if<uint32_t>(params, time_name);
auto qty = get_if<uint32_t>(params, qty_name);
auto enabled = get_if<bool>(params, enabled_name);
if(time.has_value() && qty.has_value() && enabled.has_value()){
out_order.n_secs = time.value();
out_order.qty = qty.value();
out_order.enabled = enabled.value();
out_order.algo_start = SODPosition::add_seconds(out_d.settle_stop,
-1 * out_order.n_secs);
return true;
}
return false;
};
copy_o(out_d.t1_front_order,
"T1 Front Time",
"T1 Front Qty",
"T1 Front Order Enabled");
copy_o(out_d.t1_second_order,
"T1 Second Time",
"T1 Second Qty",
"T1 Second Order Enabled");
copy_o(out_d.t1_third_order,
"T1 Third Time",
"T1 Third Qty",
"T1 Third Order Enabled");
}
// copies all of the input params (in the algo) into proper structures
bool _setup_data(IBeforeLaunchAlgoServices& serv,
AlgoData& out_d,
std::map<SecurityKey,ContractMarketData*>& out_md_map){
auto& def = serv.definition();
// [ captures ] (parameters) -> returnTypesDeclaration { lambdaStatements; }
auto init_contract_bk = [&out_md_map](auto& out_contract_md,
const auto& params,
auto param_name) -> void {
auto k = get_if<uint32_t>(params, param_name);
if(k.has_value()){
out_contract_md.book = Book(SecurityKey(k.value()));
out_md_map[out_contract_md.book.security_key()] = &out_contract_md;
}
};
if (def.has_custom_def() && def.custom_def().has_dynamic()){
out_d.tick_size = serv.security().contract_spec().low_tick();
const auto& p = def.custom_def().dynamic().order_params();
// settlement time
if(!_copy_settle_times(out_d,p))
return false;
// main contracts
init_contract_bk(out_d.t1_front, p,"T1 Front");
init_contract_bk(out_d.t1_second, p,"T1 Second");
init_contract_bk(out_d.t1_third, p,"T1 Third");
init_contract_bk(out_d.t2_front, p,"T2 Front");
init_contract_bk(out_d.t2_second, p,"T2 Second");
init_contract_bk(out_d.t3_front, p,"T3 Front");
// TAS contracts
init_contract_bk(out_d.t1_front_tas, p,"T1 Front TAS");
init_contract_bk(out_d.t1_second_tas, p,"T1 Second TAS");
init_contract_bk(out_d.t1_third_tas, p,"T1 Third TAS");
// auto orders
_copy_order_data(out_d,p);
// order template
out_d.t1_front_order.buy_ord = _create_order_template(serv,
out_d.t1_front_tas.book.security_key(),api::Side::SIDE_BUY);
out_d.t1_front_order.sell_ord = _create_order_template(serv,
out_d.t1_front_tas.book.security_key(),api::Side::SIDE_SELL);
out_d.t1_second_order.buy_ord = _create_order_template(serv,
out_d.t1_second_tas.book.security_key(),api::Side::SIDE_BUY);
out_d.t1_second_order.sell_ord = _create_order_template(serv,
out_d.t1_second_tas.book.security_key(),api::Side::SIDE_SELL);
out_d.t1_third_order.buy_ord = _create_order_template(serv,
out_d.t1_third_tas.book.security_key(),api::Side::SIDE_BUY);
out_d.t1_third_order.sell_ord = _create_order_template(serv,
out_d.t1_third_tas.book.security_key(),api::Side::SIDE_SELL);
return true;
}
return false;
}
double round_to_nearest(double price, double tick_size){
if(os::is_nan(price))
return price;
auto buy_price = bts::securities::raw_round_to_quote_price(
price,
tick_size,
api::Side::SIDE_BUY);
auto sell_price = buy_price + tick_size;
return std::abs(price-buy_price) < std::abs(sell_price-price) ? buy_price :
sell_price;
}
// time helpers
// converts std::chrono::system_clock::time_point to google timestamp
google::protobuf::Timestamp to_pf_ts (const bts::TimeStamp& ts){
auto ts_us = std::chrono::time_point_cast<std::chrono::microseconds>(ts);
auto ts_us_val = ts_us.time_since_epoch();
auto usecs = ts_us_val.count();
return google::protobuf::util::TimeUtil::MicrosecondsToTimestamp(usecs);
}
long long t1_minus_t2_usecs (const Timestamp& t1,const Timestamp& t2){
return util::TimeUtil::TimestampToMicroseconds(t1) -
util::TimeUtil::TimestampToMicroseconds(t2);
}
long long t_minus_now_usecs (const Timestamp& t){
auto now = util::TimeUtil::GetCurrentTime();
return t1_minus_t2_usecs(t,now);
}
bool within_time_win (const Timestamp& beg, const Timestamp& end,
const Timestamp& ts){
return t1_minus_t2_usecs(ts,beg)>=0 &&
t1_minus_t2_usecs(ts,end)<=0;
}
// if current time is within time window
bool now_within_time_win (const Timestamp& beg,
const Timestamp& end){
return within_time_win(beg,end,util::TimeUtil::GetCurrentTime());
}
bool trade_within_time_win (const Timestamp& beg, const Timestamp& end,
const TickerUpdateEvent::Trade& t){
auto ts = to_pf_ts(t.ts);
return within_time_win(beg,end,ts);
}
} // namespace orderman
} // namespace bts
@@ -1,41 +0,0 @@
#pragma once
#include "lib/orderman/orders/algo/IAlgoOrder.h"
namespace bts {
namespace orderman {
class ChildTemplate;
class TASCounterAlgo : public IAlgoOrder {
public:
TASCounterAlgo();
~TASCounterAlgo();
struct TASCounterAlgoParams{
};
public:
OrderOpResult do_before_launch(IBeforeLaunchAlgoServices &) override;
void do_launch(IAlgoServices &) override;
void do_launch_attached(IAlgoServices &, OrderKey, ChildState) override;
void do_update(api::orderman::Update const &) override;
void on_book(SecurityKey, Book const &) override;
void on_ticker(SecurityKey, TradeVector const&) override;
IAlgoOrder::OnCancelResponse on_cancel() override;
void on_timer() override;
private:
enum class Status;
struct PImpl;
std::unique_ptr<PImpl> me;
private:
IAlgoServices& _algo() const ;
void _switch_state (Status new_status);
void _cxl_and_end (bool is_error, const std::string& err_msg);
void _check_and_send_order();
void _compute_settles ();
void _report_state();
bool _within_settle() const;
};
} // namespace orderman
} // namespace bts
@@ -1,152 +0,0 @@
#include "lib/orderman/orders/algo/algo_orders/limit_cover/LimitCoverAdapter.h"
#include "lib/orderman/orders/OrderOpResult.h"
#include "lib/orderman/orders/algo/utils/DynamicOrderAdapter.h"
#include <utility>
namespace bts {
namespace orderman {
template<typename T>
using Param = bts::orderman::dynamic_adapter::ParamKey<bts::orderman::LimitCoverDefinition, T>;
using DynamicOrderEnumerated = bts::api::orderman::DynamicOrderEnumerated;
using OnToward = bts::api::orderman::LeanOnToward;
using LimitCoverDefinition = bts::orderman::LimitCoverDefinition;
using namespace bts::api::orderman;
#define ON_TOWARD_NAME_PAIR(x) std::make_pair(x, #x)
template<uint32_t gate_num>
std::string gate_param_name(std::string name) {
return Formatter::fmt("Gate ", gate_num, " ", name);
}
template<>
std::string gate_param_name<0>(std::string name) {
return Formatter::fmt("Initial ", name);
}
struct PriceOffset : public Param<double> {
PriceOffset() : Param<double>(std::string("Limit"),
[](const LimitCoverDefinition& def) { return def.price_offset(); },
[](LimitCoverDefinition& def, double v) { def.price_offset(v); }) {}
};
template<uint32_t gate_num>
struct ActivationThreshold : public Param<uint32_t> {
ActivationThreshold() : Param<uint32_t>(gate_param_name<gate_num>("Activation Threshold"),
[](const LimitCoverDefinition& def) { return def.gate(gate_num).activation_threshold(); },
[](LimitCoverDefinition& def, uint32_t v) { def.mgate(gate_num).activation_threshold(v); }) { }
};
template<uint32_t gate_num>
struct CoverThreshold : public Param<uint32_t> {
CoverThreshold() : Param<uint32_t>(gate_param_name<gate_num>("Cover Threshold"),
[](const LimitCoverDefinition& def) { return def.gate(gate_num).cover_threshold(); },
[](LimitCoverDefinition& def, uint32_t v) { def.mgate(gate_num).cover_threshold(v); }) { }
};
template<uint32_t gate_num>
struct DeleteThreshold : public Param<uint32_t> {
DeleteThreshold() : Param<uint32_t>(gate_param_name<gate_num>("Delete Threshold"),
[](const LimitCoverDefinition& def) { return def.gate(gate_num).delete_threshold(); },
[](LimitCoverDefinition& def, uint32_t v) { def.mgate(gate_num).delete_threshold(v); }) { }
};
template<uint32_t gate_num>
struct HedgeTicks : public Param<uint32_t> {
HedgeTicks() : Param<uint32_t>(gate_param_name<gate_num>("Hedge Ticks"),
[](const LimitCoverDefinition& def) { return def.gate(gate_num).hedge_ticks(); },
[](LimitCoverDefinition& def, uint32_t v) { def.mgate(gate_num).hedge_ticks(v); }) { }
};
template<uint32_t gate_num>
struct TopTicksOff : public Param<uint32_t> {
TopTicksOff() : Param<uint32_t>(gate_param_name<gate_num>("Top Ticks Offset"),
[](const LimitCoverDefinition& def) { return def.gate(gate_num).top_ticks_offset(); },
[](LimitCoverDefinition& def, uint32_t v) { def.mgate(gate_num).top_ticks_offset(v); }) { }
};
template<uint32_t gate_num>
struct MaxChaseTicks : public Param<uint32_t> {
MaxChaseTicks() : Param<uint32_t>(gate_param_name<gate_num>("Max Chase Ticks"),
[](const LimitCoverDefinition& def) { return def.gate(gate_num).max_chase_ticks(); },
[](LimitCoverDefinition& def, uint32_t v) { def.mgate(gate_num).max_chase_ticks(v); }) { }
};
template<uint32_t gate_num>
struct TradeTowardBehavior : public dynamic_adapter::EnumParamKey<LimitCoverDefinition, OnToward> {
TradeTowardBehavior() : EnumParamKey<LimitCoverDefinition, OnToward>(
gate_param_name<gate_num>("Trade Toward Behavior"), {
ON_TOWARD_NAME_PAIR(NO_CHANGE),
ON_TOWARD_NAME_PAIR(CANCEL),
ON_TOWARD_NAME_PAIR(DETACH),
ON_TOWARD_NAME_PAIR(REPRICE)
},
[](const LimitCoverDefinition& def) { return def.gate(gate_num).on_toward(); },
[](LimitCoverDefinition& def, OnToward v) { def.mgate(gate_num).on_toward(v); })
{}
};
template<>
struct ActivationThreshold<0> : public Param<uint32_t> {
ActivationThreshold() : Param<uint32_t>(std::string("Entry Threshold"),
[](const LimitCoverDefinition& def) { return def.gate(0).activation_threshold(); },
[](LimitCoverDefinition& def, uint32_t v) {
auto& g = def.mgate(0);
g.activation_threshold(v);
g.cover_threshold(v);
g.delete_threshold(v);
}) {}
};
using Adapter = dynamic_adapter::DynamicOrderAdapter<LimitCoverDefinition,
PriceOffset,
// [gate 0]
ActivationThreshold<0>,
HedgeTicks<0>,
TopTicksOff<0>,
MaxChaseTicks<0>,
TradeTowardBehavior<0>,
// gate 1
ActivationThreshold<1>,
CoverThreshold<1>,
DeleteThreshold<1>,
HedgeTicks<1>,
TopTicksOff<1>,
MaxChaseTicks<1>,
TradeTowardBehavior<1>,
// gate 2
ActivationThreshold<2>,
CoverThreshold<2>,
DeleteThreshold<2>,
HedgeTicks<2>,
TopTicksOff<2>,
MaxChaseTicks<2>,
TradeTowardBehavior<2>>;
LimitCoverDefinition LimitCoverAdapter::from_proto(const api::orderman::OrderDefinition& order) {
if (order.has_custom_def())
return from_proto(order.custom_def());
return LimitCoverDefinition();
}
LimitCoverDefinition LimitCoverAdapter::from_proto(const api::orderman::CustomOrderDefinition& custom_def) {
LimitCoverDefinition rv;
if (custom_def.has_dynamic())
Adapter().from_proto(custom_def.dynamic(), rv);
return rv;
}
#define INVALID_DEF(x) OrderOpResult(api::orderman::ORDER_ERROR_INVALID_ORDER_DEFINITON, x)
OrderOpResult LimitCoverAdapter::validate_proto(const api::orderman::DynamicOrderDefinition& dyn) {
return Adapter().validate_proto(dyn) ?
OrderOpResult() :
INVALID_DEF("One or more dynamic parameters are missing or invalid.");
}
void LimitCoverAdapter::init_proto(const LimitCoverDefinition& def, api::orderman::DynamicOrderDefinition& dyn) {
Adapter().to_proto(dyn, def);
}
void LimitCoverAdapter::define_proto(api::orderman::DynamicOrderDescriptor& desc) {
Adapter().define_proto(desc);
}
} // namespace orderman
} // namespace bts
Loaded 100 of 128 files, more files were not shown because too many files have changed in this diff. Show more