diff --git a/src/client/spark_core/data/ticks/TickExtensions.cs b/src/client/spark_core/data/ticks/TickExtensions.cs index 75b40bbad..bd1c0535d 100644 --- a/src/client/spark_core/data/ticks/TickExtensions.cs +++ b/src/client/spark_core/data/ticks/TickExtensions.cs @@ -1,17 +1,17 @@ -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 { + using bts; + using bts.api; + using bts.utils; + + using mbts.spark; + using mbts.user.settings; + + using System; + using System.Globalization; + public static class TickExtensions { - public static string _nan_text => TickDisplaySettings.Default.nan_text; + 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) => (tick.tick_unit > 0 && tick.tick_unit <= (tick.tick_base * 0.5)) || tick.tick_unit == tick.tick_base; @@ -25,7 +25,7 @@ namespace mbts { public static double tick_unit_frac(this TickFactors tick) => tick.tick_unit / tick.tick_base; - public static double reduced_base(this TickFactors tick) => factor_out(tick.tick_base, 10); + public static double reduced_base(this TickFactors tick) => MathUtils.factor_out(tick.tick_base, 10); public static string format_without_decimal_part(this TickFactors tick, double value) => format(tick, value, double.NaN, false, _nan_text, true); @@ -37,12 +37,18 @@ namespace mbts { format(tick, value, double.NaN, show_commas, _nan_text); public static string format(this TickFactors tick, double value, TickDisplaySettings settings) { - if (settings is null) + 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, settings.display_multiplier, settings.show_commas); - return _format_tick(tick, value, settings); + } + if (double.IsNaN(value)) { + return settings.nan_text; + } + if (double.IsInfinity(value)) { + return value.ToString(); + } + return tick.is_valid() ? + _format_tick(tick, value, settings) : + _format_no_tick(value, settings.display_multiplier, settings.show_commas); } public static string format( @@ -52,39 +58,54 @@ namespace mbts { bool show_commas, string nan_text, bool show_decimal_part = true) => - tick.format(value, TickDisplaySettings.Default.with( - display_multiplier: display_multiplier, - show_commas: show_commas, - nan_text: nan_text, - show_decimal_part: show_decimal_part)); + 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); + 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, TickDisplaySettings settings = null) => - format(value <= regional_tick.low_tick_inclusive_end ? regional_tick.low_tick : regional_tick.high_tick, value, settings); + 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, bool show_commas, string nan_text) => - format(value <= regional_tick.low_tick_inclusive_end ? regional_tick.low_tick : regional_tick.high_tick, value, display_multiplier, show_commas, nan_text); + format( + value <= regional_tick.low_tick_inclusive_end ? regional_tick.low_tick : regional_tick.high_tick, + value, + display_multiplier, + show_commas, nan_text); public static double parse(this TickFactors tick, string text, TickDisplaySettings display_settings) => display_settings is null ? parse(tick, text, double.NaN, _nan_text) : parse(tick, text, display_settings.display_multiplier, display_settings.nan_text ?? string.Empty); - public static double parse(this TickFactors tick, string text, double display_multiplier, string nan_text) { - if (!tick.is_valid()) return _parse_no_tick(text, display_multiplier); - return _parse(tick, text, display_multiplier, nan_text); - } + public static double parse(this TickFactors tick, string text, double display_multiplier, string nan_text) => + tick.is_valid() ? + _parse(tick, text, display_multiplier, nan_text) : + _parse_no_tick(text, display_multiplier); - public static double parse(this RegionalTickFactors regional_tick, string text, double display_multiplier, string nan_text) { - if (!regional_tick.is_valid()) return _parse_no_tick(text, display_multiplier); - return _parse(regional_tick, text, display_multiplier, nan_text); - } + public static double parse(this RegionalTickFactors regional_tick, string text, double display_multiplier, string nan_text) => + regional_tick.is_valid() ? + _parse(regional_tick, text, display_multiplier, nan_text) : + _parse_no_tick(text, display_multiplier); + + public static double tickup(this TickFactors tick, double input) => + tick.tickup(input, 1); - public static double tickup(this TickFactors tick, double input) { return tick.tickup(input, 1); } public static double tickup(this TickFactors tick, double input, uint count) { - if (DoubleHelper.IsNaNOrInfinity(input)) return input; + if (DoubleHelper.IsNaNOrInfinity(input)) { + return input; + } double tuf = tick.tick_unit_frac(); input -= input % tuf; double val = input + tuf * count; @@ -97,11 +118,16 @@ namespace mbts { 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; + public static double tickup(this RegionalTickFactors regional_tick, double input, uint count, double precision) { + if (!precision.is_real_positive()) { + throw new ArgumentException("Must be a real positive number.", nameof(precision)); + } + if (DoubleHelper.IsNaNOrInfinity(input) || count == 0) { + return input; + } + + double val; + double tuf; if (input < regional_tick.low_tick_inclusive_end) { tuf = regional_tick.low_tick.tick_unit_frac(); double ieeer = Math.IEEERemainder(input, tuf); @@ -123,76 +149,21 @@ namespace mbts { return _round_tick(tuf, val); } - public static ContractSpecification to_spec(this TickFactors tick) { - if (tick == null) - return null; - double tick_frac = tick.tick_unit_frac(); - return new ContractSpecification { - LowTick = tick_frac, - HighTick = tick_frac, - PriceBreak = double.MaxValue, - MainFraction = (uint)factor_out(tick.tick_base, 10), - PriceDisplayFormat = (uint)tick.display_digits(), - PriceMultiplier = 1, - CashPerPoint = 1 - }; - } + public static double tickdown(this TickFactors tick, double input) => + tick.tickdown(input, 1); - public static bool try_get_tickdiff(this RegionalTickFactors regional_tick, double x, double y, out int n_low, out int n_high) { - if (DoubleHelper.IsNaNOrInfinity(x) || DoubleHelper.IsNaNOrInfinity(y)) { - n_low = default; - n_high = default; - return false; - } - (n_low, n_high) = tickdiff_unchecked(regional_tick, x, y); - return true; - } - - /// - /// Callers should be certain that and are not nan or infinity. - /// - /// - /// - /// - internal static (int n_low, int n_high) tickdiff_unchecked(this RegionalTickFactors regional_tick, double x, double y) { - double ltie = regional_tick.low_tick_inclusive_end; - double raw_diff = x - y; - if (x < ltie) { - double low_unit_frac = regional_tick.low_tick.tick_unit_frac(); - if (y < ltie) { - return (round_fractional_units(raw_diff, low_unit_frac), 0); - } else { - double high_unit_frac = regional_tick.high_tick.tick_unit_frac(); - double low_diff = ltie - x; - double high_diff = raw_diff - low_diff; - int n_low = round_fractional_units(low_diff, low_unit_frac); - int n_high = round_fractional_units(high_diff, high_unit_frac); - return (n_low, n_high); - } - } else { - double high_unit_frac = regional_tick.high_tick.tick_unit_frac(); - if (y < ltie) { - double low_unit_frac = regional_tick.low_tick.tick_unit_frac(); - double high_diff = x - ltie; - double low_diff = raw_diff - high_diff; - int n_low = round_fractional_units(low_diff, low_unit_frac); - int n_high = round_fractional_units(high_diff, high_unit_frac); - return (n_low, n_high); - } else { - return (0, round_fractional_units(raw_diff, high_unit_frac)); - } - } - } - - 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; + if (DoubleHelper.IsNaNOrInfinity(input)) { + return input; + } double tuf = tick.tick_unit_frac(); double remainder = input % tuf; - if (remainder > 0) input += tuf - remainder; + if (remainder > 0) { + input += tuf - remainder; + } double val = input - tuf * count; return _round_tick(tuf, val); - } + } public static double tickdown(this RegionalTickFactors regional_tick, double input) => regional_tick.tickdown(input, 1); @@ -201,8 +172,9 @@ namespace mbts { 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 (!precision.is_real_positive()) { + throw new ArgumentException("Must be a real positive number.", nameof(precision)); + } if (DoubleHelper.IsNaNOrInfinity(input) || count == 0) return input; double val, tuf; if (input > regional_tick.low_tick_inclusive_end) { @@ -226,18 +198,81 @@ namespace mbts { return _round_tick(tuf, val); } - public static double round(this TickFactors tick, double input) { return _round_tick(tick.tick_unit_frac(), input); } - public static double round(this RegionalTickFactors regional_tick, double input) { - if (DoubleHelper.IsNaNOrInfinity(input)) return input; - return input <= regional_tick.low_tick_inclusive_end ? regional_tick.low_tick.round(input) : regional_tick.high_tick.round(input); + public static ContractSpecification to_spec(this TickFactors tick) => + tick is null ? null : + new ContractSpecification { + LowTick = tick.tick_unit_frac(), + HighTick = tick.tick_unit_frac(), + PriceBreak = double.MaxValue, + MainFraction = (uint)MathUtils.factor_out(tick.tick_base, 10), + PriceDisplayFormat = (uint)tick.display_digits(), + PriceMultiplier = 1, + CashPerPoint = 1 + }; + + public static bool try_get_tickdiff(this RegionalTickFactors regional_tick, double minuend, double subtrahend, out int n_low, out int n_high) { + if (DoubleHelper.IsNaNOrInfinity(minuend) || DoubleHelper.IsNaNOrInfinity(subtrahend)) { + n_low = default; + n_high = default; + return false; + } + (n_low, n_high) = tickdiff_unchecked(regional_tick, minuend, subtrahend); + return true; } + + /// + /// Computes the difference, in tick units, between and + /// + /// + /// Asserts that and are real numbers (i.e., not nan or infinity) + /// + /// The minuend + /// The subtrahend + internal static (int n_low, int n_high) tickdiff_unchecked(this RegionalTickFactors regional_tick, double minuend, double subtrahend) { + Log.assert(minuend.is_real() && subtrahend.is_real()); + + double ltie = regional_tick.low_tick_inclusive_end; + double raw_diff = minuend - subtrahend; + + if (minuend < ltie) { + if (subtrahend < ltie) { + return (MathUtils.round_fractional_units(raw_diff, regional_tick.low_tick.tick_unit_frac()), 0); + } + double low_diff = ltie - minuend; + double high_diff = raw_diff - low_diff; + int n_low = MathUtils.round_fractional_units(low_diff, regional_tick.low_tick.tick_unit_frac()); + int n_high = MathUtils.round_fractional_units(high_diff, regional_tick.high_tick.tick_unit_frac()); + return (n_low, n_high); + } + + if (subtrahend < ltie) { + double high_diff = minuend - ltie; + double low_diff = raw_diff - high_diff; + int n_low = MathUtils.round_fractional_units(low_diff, regional_tick.high_tick.tick_unit_frac()); + int n_high = MathUtils.round_fractional_units(high_diff, regional_tick.high_tick.tick_unit_frac()); + return (n_low, n_high); + } + return (0, MathUtils.round_fractional_units(raw_diff, regional_tick.high_tick.tick_unit_frac())); + } + + public static double round(this TickFactors tick, double input) => + _round_tick(tick.tick_unit_frac(), input); + + public static double round(this RegionalTickFactors regional_tick, double input) { + if (DoubleHelper.IsNaNOrInfinity(input)) { + return input; + } + return input <= regional_tick.low_tick_inclusive_end ? + regional_tick.low_tick.round(input) : + regional_tick.high_tick.round(input); + } + public static int display_digits(this TickFactors tick) { if (tick.tick_unit == tick.tick_base) { return (int)Math.Floor(Math.Log10(tick.tick_base)); } return display_digits(tick.tick_base); } - #endregion public static int display_digits(double tick_base) { double log_tick_base = Math.Log10(tick_base); @@ -249,34 +284,44 @@ namespace mbts { public static TickFactors with(this TickFactors tick_factors, double? tick_base = null, double? tick_unit = null) => new(tick_base ?? tick_factors.tick_base, tick_unit ?? tick_factors.tick_unit); - #region Private Members - private static char separator(this TickFactors tick) { + static char _separator(TickFactors tick) { double tb_log10 = Math.Log10(tick.tick_base); return tb_log10 >= 1 && tb_log10 % 1 == 0 ? '.' : '-'; } - private static string _format_no_tick(double value, double display_multiplier, bool show_commas) { - if (!double.IsNaN(display_multiplier)) value *= display_multiplier; + static string _format_no_tick(double value, double display_multiplier, bool show_commas) { + if (!double.IsNaN(display_multiplier)) { + value *= display_multiplier; + } return value.ToString(show_commas ? "#,0" : "0"); } - private static double _parse_no_tick(string text, double display_multiplier) { - double result; - if (!double.TryParse(text, out result)) return double.NaN; + static double _parse_no_tick(string text, double display_multiplier) { + if (!double.TryParse(text, out var result)) { + return double.NaN; + } return double.IsNaN(display_multiplier) || display_multiplier == 0.0 ? result : result / display_multiplier; } - private static double _get_integer_part(string integer_text) { - return string.IsNullOrEmpty(integer_text) ? 0 : int.TryParse(integer_text, NumberStyles.Any, CultureInfo.CurrentCulture, out int result) ? result : double.NaN; + static double _get_integer_part(string integer_text) { + if (integer_text.is_null_or_white_space()) { + return 0; + } + return int.TryParse(integer_text, NumberStyles.Any, CultureInfo.CurrentCulture, out var result) ? result : double.NaN; } - private static double _get_numerator_part(string numerator_text, double tick_base, double tick_unit) { - if (string.IsNullOrEmpty(numerator_text)) return 0; - double numerator_part; - if (!double.TryParse(numerator_text, out numerator_part)) return double.NaN; + static double _get_numerator_part(string numerator_text, double tick_base) { + if (string.IsNullOrEmpty(numerator_text)) { + return 0; + } + if (!double.TryParse(numerator_text, out var numerator_part)) { + return double.NaN; + } + //e.g [tick_base 64] 1989-80 == 1989-8, or 1989-320 == 1989-32 - if (numerator_part >= tick_base) numerator_part /= Math.Pow(10, Math.Ceiling(Math.Log10(numerator_part) - Math.Log10(tick_base))); - else { + if (numerator_part >= tick_base) { + numerator_part /= Math.Pow(10, Math.Ceiling(Math.Log10(numerator_part) - Math.Log10(tick_base))); + } else { //e.g [tick_base 640] 1989-8 == 1989-80, or 1989-32 == 1989-320 int ndd_diff = display_digits(tick_base) - numerator_text.Length; if (ndd_diff > 0) numerator_part *= Math.Pow(10, ndd_diff); @@ -285,49 +330,62 @@ namespace mbts { return numerator_part; } - private static double _parse(RegionalTickFactors regional_tick, string text, double display_multiplier, string nan_text) { + static double _parse(RegionalTickFactors regional_tick, string text, double display_multiplier, string nan_text) { double result = _parse(regional_tick.low_tick, text, display_multiplier, nan_text); - double ltie = double.IsNaN(display_multiplier) ? regional_tick.low_tick_inclusive_end : regional_tick.low_tick_inclusive_end * display_multiplier; - if (result > ltie) result = _parse(regional_tick.high_tick, text, display_multiplier, nan_text); + double ltie = display_multiplier.is_nan() ? + regional_tick.low_tick_inclusive_end : + regional_tick.low_tick_inclusive_end * display_multiplier; + if (result > ltie) { + result = _parse(regional_tick.high_tick, text, display_multiplier, nan_text); + } return result; } - private static double _parse(TickFactors tick, string text, double display_multiplier, string nan_text) { - if (string.IsNullOrWhiteSpace(text) || text == nan_text) return double.NaN; + static double _parse(TickFactors tick, string text, double display_multiplier, string nan_text) { + if (text.is_null_or_white_space() || text == nan_text) { + return double.NaN; + } text = text.Replace(" ", string.Empty); - if (text[0] == '-') return text.Length > 1 ? -_parse(tick, text.Substring(1), display_multiplier, nan_text) : double.NaN; - double d; - if (double.TryParse(text, out d)) return double.IsNaN(display_multiplier) ? d : d * display_multiplier; - var parts = text.Split(tick.separator()); + if (text[0] == '-') { + return text.Length > 1 ? -_parse(tick, text[1..], display_multiplier, nan_text) : double.NaN; + } + if (double.TryParse(text, out var d)) { + return double.IsNaN(display_multiplier) ? d : d * display_multiplier; + } + var parts = text.Split(_separator(tick)); double integer_part = _get_integer_part(parts[0]); double result = parts.Length == 1 ? integer_part : _parse(tick, integer_part, parts[1]); return double.IsNaN(display_multiplier) ? result : display_multiplier * result; } - private static double _parse(TickFactors tick, double integer_part, string numerator_part_text) { - double numerator_part = _get_numerator_part(numerator_part_text, tick.tick_base, tick.tick_unit); + static double _parse(TickFactors tick, double integer_part, string numerator_part_text) { + double numerator_part = _get_numerator_part(numerator_part_text, tick.tick_base); return integer_part + numerator_part / tick.tick_base; } - private static string _format_tick(TickFactors tick, double value, TickDisplaySettings settings) { - if (!settings.display_multiplier.is_nan()) + 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) + 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()); + var parts = text.Split(_separator(tick)); if (parts.Length > 1 && parts[0] == "0") text = parts[1]; } - if (negate) + 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() { @@ -339,12 +397,13 @@ namespace mbts { 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', + return (integer_part + 1).ToString() + _separator(tick) + 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; @@ -354,25 +413,22 @@ namespace mbts { // 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( + return integer_part_text + _separator(tick) + decimal_part.ToString( settings.pad_with_leading_zeros ? new string('0', display_digits(tick.tick_base)) : "0"); - } else { - return integer_part_text; } + return integer_part_text; } - } - catch (OverflowException ex) { + } catch (OverflowException ex) { Log.Ui.warn($"Arithmetic overflow exception in format_tick (tick:{tick}, value:{value}):{ex}"); return "Overflow"; } } } - private static double _round_tick(double tick_unit_frac, double input) { - return input - Math.IEEERemainder(input, tick_unit_frac); - } - #endregion + static double _round_tick(double tick_unit_frac, double input) => + input - Math.IEEERemainder(input, tick_unit_frac); } }