refactor: Move PNL data types to spark_api csproj

This commit is contained in:
John Colvin committed 2025-03-23 13:08:46 -04:00
1 parent 547d83e1b8
commit 90f1bb0851
13 files changed
+450 -399

No files matched your search

@@ -11,8 +11,8 @@ namespace Spark.Trading {
using mbts.analytics;
using mbts.spark;
using mbts.ui;
using Spark.Api.Data;
using Spark.Api.Orders;
using Spark.Api.Reactive;
using Spark.Core;
@@ -5,6 +5,7 @@ using mbts.spark;
using mbts.ui;
using mbts.ui.shell;
using Spark.Api.Data;
using Spark.Core.Data;
using Spark.Core.Disposables;
using Spark.Core.Reflection;
@@ -8,6 +8,7 @@ using bts.utils;
using mbts.ui;
using mbts.ui.controls;
using Spark.Api.Data;
using Spark.Api.Orders;
using Spark.Core.Collections;
using Spark.ViewModel.Commands;
@@ -36,169 +36,6 @@ namespace bts.shell.pnl {
Settle
}
readonly struct WorkingOrderData {
public readonly WorkingOrderSideData long_data, short_data;
WorkingOrderData(WorkingOrderSideData long_data, WorkingOrderSideData short_data) {
this.long_data = long_data;
this.short_data = short_data;
}
public static WorkingOrderData Empty =>
new WorkingOrderData(WorkingOrderSideData.EmptyLong, WorkingOrderSideData.EmptyShort);
public double top_bid =>
long_data.data.Count > 0 ?
long_data.data.First().Key :
double.NaN;
public double top_ask =>
short_data.data.Count > 0 ?
short_data.data.First().Key :
double.NaN;
public PositionPriceSize summary =>
new PositionPriceSize(long_data.working_total, long_data.avg_price, short_data.working_total, short_data.avg_price);
public static WorkingOrderData Create(
IEnumerable<OrderRecordImmutable> orders, QuantityConversionData<double> qty_conversion) =>
Create(orders.Select(o => (o, qty_conversion)));
public static WorkingOrderData Create(
IEnumerable<(OrderRecordImmutable order, QuantityConversionData<double> qty_conversion)> orders) =>
orders.Aggregate(Empty, (seed, tup) => seed.Add(tup.order, tup.qty_conversion));
public WorkingOrderData Add(OrderRecordImmutable order, QuantityConversionData<double> qty_conversion) {
if (order.working_quantity() <= 0)
return new WorkingOrderData(long_data, short_data);
switch (order.side()) {
case Side.Buy: return new WorkingOrderData(long_data.Add(order, qty_conversion), short_data);
case Side.Sell: return new WorkingOrderData(long_data, short_data.Add(order, qty_conversion));
default: throw ExceptionBuilder.Argument.unexpected_case(order.side(), "order.side");
}
}
public WorkingOrderData Remove(OrderRecordImmutable order) {
if (order.working_quantity() <= 0)
return new WorkingOrderData(long_data, short_data);
switch (order.side()) {
case Side.Buy: return new WorkingOrderData(long_data.Remove(order.Key, order.price()), short_data);
case Side.Sell: return new WorkingOrderData(long_data, short_data.Remove(order.Key, order.price()));
default: throw ExceptionBuilder.Argument.unexpected_case(order.side(), "order.side");
}
}
}
readonly struct WorkingOrderSideData {
public readonly double avg_price, display_avg_price;
public readonly ImmutableSortedDictionary<double, ImmutableDictionary<uint, (OrderRecordImmutable order, QuantityConversionData<double> qty_conversion)>> data;
public readonly double working_total;
public readonly double display_working_total;
WorkingOrderSideData(
double avg_price,
double working_total,
double display_avg_price,
double display_working_total,
ImmutableSortedDictionary<double, ImmutableDictionary<uint, (OrderRecordImmutable, QuantityConversionData<double>)>> data
) {
this.avg_price = avg_price;
this.working_total = working_total;
this.display_avg_price = display_avg_price;
this.data = data;
this.display_working_total = display_working_total;
}
public static WorkingOrderSideData EmptyLong => new(
double.NaN, 0, double.NaN, 0,
ImmutableSortedDictionary.Create<double, ImmutableDictionary<uint, (OrderRecordImmutable, QuantityConversionData<double>)>>(
new ReverseComparer<double>(new OrderPriceComparer())));
public static WorkingOrderSideData EmptyShort => new(
double.NaN, 0, double.NaN, 0,
ImmutableSortedDictionary.Create<double, ImmutableDictionary<uint, (OrderRecordImmutable, QuantityConversionData<double>)>>(
new OrderPriceComparer()));
public double top_price =>
data.Count > 0 ?
data.First().Key :
double.NaN;
public double top_volume =>
data.Count > 0 ?
data.Values.First().Values.Sum(o => o.order.working_quantity()) :
0;
public double display_top_volume =>
data.Count > 0 ?
data.Values.First().Values.Sum(o => o.qty_conversion
.convert_numeric_type<double>()
.to_display(o.order.working_quantity())) :
0;
public WorkingOrderSideData Add(OrderRecordImmutable order_record) =>
Add(order_record, new());
public WorkingOrderSideData Add(
OrderRecordImmutable order_record, QuantityConversionData<double> qty_conversion) {
var working_qty = order_record.working_quantity();
if (working_qty <= 0)
throw new ArgumentException(nameof(working_qty));
uint order = order_record.Key;
var dworking_qty = qty_conversion.to_display(working_qty);
double price = order_record.price();
if (working_total == 0) {
Log.assert(display_working_total == 0);
return new WorkingOrderSideData(price, working_qty, display_avg_price, dworking_qty, data.Add(
price, ImmutableDictionary<uint, (OrderRecordImmutable, QuantityConversionData<double>)>.Empty.Add(order, (order_record, qty_conversion))));
} else return new WorkingOrderSideData(
avg_price + ((price - avg_price) * ((double)working_qty / (working_total + working_qty))),
working_total + working_qty,
display_avg_price + ((price - display_avg_price) * ((double)dworking_qty / (display_working_total + dworking_qty))),
display_working_total + dworking_qty,
data.SetItem(price, data.TryGetValue(price, out var curr) ?
curr.Add(order, (order_record, qty_conversion)) :
ImmutableDictionary<uint, (OrderRecordImmutable, QuantityConversionData<double>)>.Empty.Add(order, (order_record, qty_conversion))));
}
public WorkingOrderSideData Remove(uint order, double price) {
var tmp_data = data;
if (!tmp_data.TryGetValue(price, out var wdata))
throw new KeyNotFoundException(nameof(price));
if (!wdata.TryGetValue(order, out var worder))
throw new KeyNotFoundException(nameof(order));
var wqty = worder.order.working_quantity();
var dwqty = worder.qty_conversion.to_display(wqty);
wdata = wdata.Remove(order);
if (wdata.Count == 0)
tmp_data = tmp_data.Remove(price);
if (tmp_data.Count == 0)
return new(
double.NaN, 0, double.NaN, 0,
ImmutableSortedDictionary.Create<double, ImmutableDictionary<uint, (OrderRecordImmutable, QuantityConversionData<double>)>>(
data.KeyComparer));
return new(
avg_price - ((price - avg_price) * (wqty / (working_total - wqty))),
working_total - wqty,
display_avg_price - ((price - display_avg_price) * (dwqty / (display_working_total - dwqty))),
display_working_total - dwqty,
tmp_data);
}
public override string ToString() {
if (data.Count > 0) {
var best_order = data.Values.First().Values.First();
return OrderUtils.order_collection_summary(
best_order.order.price(),
display_avg_price,
best_order.qty_conversion.to_display(best_order.order.working_quantity()),
display_working_total,
Security.Defaults.ContractSpecificationImmutable);
}
return string.Empty;
}
}
readonly struct PNLRowData : IEquatable<PNLRowData> {
public static readonly Func<PNLRowData, PNLKey> key_fn = d => d.key;
public static IComparer<PNLRowData> key_comparer = Comparer<PNLKey>.Default.wrap<PNLKey, PNLRowData>(d => d.key);
@@ -6,6 +6,7 @@
using mbts.ui;
using mbts.ui.shell;
using Spark.Api.Data;
using Spark.Core.Disposables;
using System;
@@ -0,0 +1,27 @@
namespace mbts.ui;
using mbts.ui.shell;
using Spark.Api.Data;
using Spark.Core.Disposables;
using System;
static class DisplayTranslatorExtensions {
public static IDisposable connect_owner<T>(
this IDisplayTranslator<T> display_translator,
IRaiseNotifyPropertyChanged owner,
params string[] properties
) {
if (display_translator is null)
throw new ArgumentNullException(nameof(display_translator));
if (owner is null)
throw new ArgumentNullException(nameof(owner));
display_translator.value_changed += on_value_changed;
return Disposable.Create(() => display_translator.value_changed -= on_value_changed);
void on_value_changed() {
for (int i = 0; i < properties.Length; i++)
owner.raise_notify_property_changed(properties[i]);
}
}
}
@@ -1,215 +0,0 @@
using bts.utils;
using mbts.ui.shell;
using Spark.Core;
using Spark.Core.Disposables;
using System;
using System.Collections.Generic;
using System.Numerics;
using System.Reactive.Linq;
namespace mbts.ui {
interface IDisplayTranslator<T> {
T display_value { get; set; }
T actual_value { get; set; }
event Action value_changed;
}
enum QuantityConversionOpType {
None,
MultiplyActual,
DivideActual
}
readonly struct QuantityConversionData<T> : IEquatable<QuantityConversionData<T>>
where T : INumber<T> {
public QuantityConversionData(T value, QuantityConversionOpType op) {
this.value = value;
this.op = op;
}
public enum OpType {
None,
MultiplyActual,
DivideActual
}
public T value { get; }
public QuantityConversionOpType op { get; }
public QuantityConversionData<TResult> convert_numeric_type<TResult>()
where TResult : INumber<TResult> =>
new(NumericCastConverter<T, TResult>.convert(value), op);
public bool Equals(QuantityConversionData<T> other) =>
value == other.value &&
op == other.op;
public override bool Equals(object obj) =>
obj is QuantityConversionData<T> other && Equals(other);
public override int GetHashCode() =>
EqualityComparer.auto_phase(value.GetHashCode(), op.GetHashCode());
public static bool operator ==(QuantityConversionData<T> x, QuantityConversionData<T> y) =>
x.Equals(y);
public static bool operator !=(QuantityConversionData<T> x, QuantityConversionData<T> y) =>
!x.Equals(y);
}
static class DisplayQuantityMultiplier {
public static DisplayQuantityMultiplier<uint> create_uint() => new(
DisplayTranslatorExtensions.to_display,
DisplayTranslatorExtensions.from_display);
public static DisplayQuantityMultiplier<double> create_double() => new(
DisplayTranslatorExtensions.to_display,
DisplayTranslatorExtensions.from_display);
}
class DisplayQuantityMultiplier<T> : IDisplayTranslator<T> where T : struct, INumber<T> {
readonly Func<QuantityConversionData<T>, T, T> _to_display, _from_display;
readonly IEqualityComparer<T> _comparer;
T _actual_value;
QuantityConversionData<T> _conversion_data;
public DisplayQuantityMultiplier(
Func<QuantityConversionData<T>, T, T> to_display,
Func<QuantityConversionData<T>, T, T> from_display,
IEqualityComparer<T> comparer = null,
T actual_value = default,
QuantityConversionData<T> conversion_data = default) {
//
_to_display = to_display ?? throw new ArgumentNullException(nameof(to_display));
_from_display = from_display ?? throw new ArgumentNullException(nameof(from_display));
_comparer = comparer ?? EqualityComparer<T>.Default;
_actual_value = actual_value;
_conversion_data = conversion_data;
}
public event Action value_changed;
public T actual_value {
get => _actual_value;
set {
if (!_comparer.Equals(_actual_value, value)) {
_actual_value = value;
value_changed?.Invoke();
}
}
}
public T display_value {
get => _to_display(_conversion_data, _actual_value);
set => actual_value = _from_display(_conversion_data, value);
}
public QuantityConversionData<T> conversion_data {
get => _conversion_data;
set {
if (_conversion_data != value) {
_conversion_data = value;
value_changed?.Invoke();
}
}
}
}
class OptionalDisplayQuantityMultiplier<T> : IDisplayTranslator<T?> where T : struct, INumber<T> {
T? _actual_value;
QuantityConversionData<T> _conversion_data;
public event Action value_changed;
public T? actual_value {
get => _actual_value;
set {
if (_actual_value != value) {
_actual_value = value;
value_changed?.Invoke();
}
}
}
public T? display_value {
get => _actual_value.HasValue ?
_conversion_data.to_display(_actual_value.Value) : _actual_value;
set => actual_value = value.HasValue ?
_conversion_data.from_display(value.Value) : value;
}
public QuantityConversionData<T> conversion_data {
get => _conversion_data;
set {
if (_conversion_data != value) {
_conversion_data = value;
value_changed?.Invoke();
}
}
}
}
static class DisplayTranslatorExtensions {
public static IDisposable connect_owner<T>(
this IDisplayTranslator<T> display_translator,
IRaiseNotifyPropertyChanged owner,
params string[] properties
) {
if (display_translator is null)
throw new ArgumentNullException(nameof(display_translator));
if (owner is null)
throw new ArgumentNullException(nameof(owner));
display_translator.value_changed += on_value_changed;
return Disposable.Create(() => display_translator.value_changed -= on_value_changed);
void on_value_changed() {
for (int i = 0; i < properties.Length; i++)
owner.raise_notify_property_changed(properties[i]);
}
}
public static IObservable<T> subscribe_actual_value<T>(
this IDisplayTranslator<T> display_translator) =>
subscribe_actual_value(display_translator, EqualityComparer<T>.Default);
public static IObservable<T> subscribe_actual_value<T>(
this IDisplayTranslator<T> display_translator, IEqualityComparer<T> comparer) {
if (comparer is null)
throw new ArgumentNullException(nameof(comparer));
return Observable.Create<T>(o => {
var curr = display_translator.actual_value;
o.OnNext(curr);
display_translator.value_changed += on_value_changed;
return Disposable.Create(() => display_translator.value_changed -= on_value_changed);
void on_value_changed() {
var next = display_translator.actual_value;
if (!comparer.Equals(curr, next))
o.OnNext(curr = next);
}
});
}
public static T to_display<T>(
this QuantityConversionData<T> quantity_conversion_data, T actual_value)
where T : INumber<T> =>
quantity_conversion_data.op switch {
QuantityConversionOpType.DivideActual =>
actual_value.safe_divide(quantity_conversion_data.value),
QuantityConversionOpType.MultiplyActual =>
actual_value * quantity_conversion_data.value,
_ => actual_value,
};
public static T from_display<T>(
this QuantityConversionData<T> quantity_conversion_data, T display_value)
where T : INumber<T> =>
quantity_conversion_data.op switch {
QuantityConversionOpType.DivideActual => display_value * quantity_conversion_data.value,
QuantityConversionOpType.MultiplyActual =>
display_value.safe_divide(quantity_conversion_data.value),
_ => display_value,
};
}
}
@@ -0,0 +1,69 @@
namespace bts.shell.pnl;
using bts.api;
using bts.api.orderman;
using mbts.spark;
using mbts.utils;
using Spark.Api.Data;
using Spark.Api.Orders;
using Spark.Api.Position;
using System.Collections.Generic;
using System.Linq;
readonly struct WorkingOrderData {
public readonly WorkingOrderSideData long_data, short_data;
WorkingOrderData(WorkingOrderSideData long_data, WorkingOrderSideData short_data) {
this.long_data = long_data;
this.short_data = short_data;
}
public static WorkingOrderData Empty =>
new(WorkingOrderSideData.EmptyLong, WorkingOrderSideData.EmptyShort);
public double top_bid =>
long_data.data.Count > 0 ?
long_data.data.First().Key :
double.NaN;
public double top_ask =>
short_data.data.Count > 0 ?
short_data.data.First().Key :
double.NaN;
public PositionPriceSize summary =>
new(long_data.working_total, long_data.avg_price, short_data.working_total, short_data.avg_price);
public static WorkingOrderData Create(
IEnumerable<OrderRecordImmutable> orders, QuantityConversionData<double> qty_conversion) =>
Create(orders.Select(o => (o, qty_conversion)));
public static WorkingOrderData Create(
IEnumerable<(OrderRecordImmutable order, QuantityConversionData<double> qty_conversion)> orders) =>
orders.Aggregate(Empty, (seed, tup) => seed.Add(tup.order, tup.qty_conversion));
public WorkingOrderData Add(OrderRecordImmutable order, QuantityConversionData<double> qty_conversion) {
if (order.working_quantity() <= 0) {
return new(long_data, short_data);
}
return order.side() switch {
Side.Buy => new(long_data.Add(order, qty_conversion), short_data),
Side.Sell => new(long_data, short_data.Add(order, qty_conversion)),
_ => throw ExceptionBuilder.Argument.unexpected_case(order.side(), "order.side"),
};
}
public WorkingOrderData Remove(OrderRecordImmutable order) {
if (order.working_quantity() <= 0) {
return new(long_data, short_data);
}
return order.side() switch {
Side.Buy => new(long_data.Remove(order.Key, order.price()), short_data),
Side.Sell => new(long_data, short_data.Remove(order.Key, order.price())),
_ => throw ExceptionBuilder.Argument.unexpected_case(order.side(), "order.side"),
};
}
}
@@ -0,0 +1,128 @@
namespace bts.shell.pnl;
using bts.api;
using bts.api.orderman;
using mbts.spark;
using mbts.utils;
using Spark.Api.Data;
using Spark.Api.Orders;
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
public readonly struct WorkingOrderSideData {
public readonly double avg_price, display_avg_price;
public readonly ImmutableSortedDictionary<double, ImmutableDictionary<uint, (OrderRecordImmutable order, QuantityConversionData<double> qty_conversion)>> data;
public readonly double working_total;
public readonly double display_working_total;
WorkingOrderSideData(
double avg_price,
double working_total,
double display_avg_price,
double display_working_total,
ImmutableSortedDictionary<double, ImmutableDictionary<uint, (OrderRecordImmutable, QuantityConversionData<double>)>> data
) {
this.avg_price = avg_price;
this.working_total = working_total;
this.display_avg_price = display_avg_price;
this.data = data;
this.display_working_total = display_working_total;
}
public static WorkingOrderSideData EmptyLong => new(
double.NaN, 0, double.NaN, 0,
ImmutableSortedDictionary.Create<double, ImmutableDictionary<uint, (OrderRecordImmutable, QuantityConversionData<double>)>>(
new ReverseComparer<double>(new OrderPriceComparer())));
public static WorkingOrderSideData EmptyShort => new(
double.NaN, 0, double.NaN, 0,
ImmutableSortedDictionary.Create<double, ImmutableDictionary<uint, (OrderRecordImmutable, QuantityConversionData<double>)>>(
new OrderPriceComparer()));
public double top_price =>
data.Count > 0 ?
data.First().Key :
double.NaN;
public double top_volume =>
data.Count > 0 ?
data.Values.First().Values.Sum(o => o.order.working_quantity()) :
0;
public double display_top_volume =>
data.Count > 0 ?
data.Values.First().Values.Sum(o => o.qty_conversion
.convert_numeric_type<double>()
.to_display(o.order.working_quantity())) :
0;
public WorkingOrderSideData Add(OrderRecordImmutable order_record) =>
Add(order_record, new());
public WorkingOrderSideData Add(
OrderRecordImmutable order_record, QuantityConversionData<double> qty_conversion) {
var working_qty = order_record.working_quantity();
if (working_qty <= 0)
throw new ArgumentException(nameof(working_qty));
uint order = order_record.Key;
var dworking_qty = qty_conversion.to_display(working_qty);
double price = order_record.price();
if (working_total == 0) {
Log.assert(display_working_total == 0);
return new WorkingOrderSideData(price, working_qty, display_avg_price, dworking_qty, data.Add(
price, ImmutableDictionary<uint, (OrderRecordImmutable, QuantityConversionData<double>)>.Empty.Add(order, (order_record, qty_conversion))));
} else return new WorkingOrderSideData(
avg_price + ((price - avg_price) * ((double)working_qty / (working_total + working_qty))),
working_total + working_qty,
display_avg_price + ((price - display_avg_price) * ((double)dworking_qty / (display_working_total + dworking_qty))),
display_working_total + dworking_qty,
data.SetItem(price, data.TryGetValue(price, out var curr) ?
curr.Add(order, (order_record, qty_conversion)) :
ImmutableDictionary<uint, (OrderRecordImmutable, QuantityConversionData<double>)>.Empty.Add(order, (order_record, qty_conversion))));
}
public WorkingOrderSideData Remove(uint order, double price) {
var tmp_data = data;
if (!tmp_data.TryGetValue(price, out var wdata))
throw new KeyNotFoundException(nameof(price));
if (!wdata.TryGetValue(order, out var worder))
throw new KeyNotFoundException(nameof(order));
var wqty = worder.order.working_quantity();
var dwqty = worder.qty_conversion.to_display(wqty);
wdata = wdata.Remove(order);
if (wdata.Count == 0)
tmp_data = tmp_data.Remove(price);
if (tmp_data.Count == 0)
return new(
double.NaN, 0, double.NaN, 0,
ImmutableSortedDictionary.Create<double, ImmutableDictionary<uint, (OrderRecordImmutable, QuantityConversionData<double>)>>(
data.KeyComparer));
return new(
avg_price - ((price - avg_price) * (wqty / (working_total - wqty))),
working_total - wqty,
display_avg_price - ((price - display_avg_price) * (dwqty / (display_working_total - dwqty))),
display_working_total - dwqty,
tmp_data);
}
public override string ToString() {
if (data.Count > 0) {
if (display_working_total == 0) {
return string.Empty;
}
var spec = Security.Defaults.ContractSpecificationImmutable;
var best_order = data.Values.First().Values.First();
var best_price_volume = best_order.qty_conversion.to_display(best_order.order.working_quantity());
var best_price = best_order.order.price();
return display_working_total == best_price_volume ?
$"{best_price_volume} @ {spec.format(best_price)}" :
$"{best_price_volume} ({display_working_total}) @ {spec.format(best_price)}";
}
return string.Empty;
}
}
@@ -0,0 +1,99 @@
namespace Spark.Api.Data;
using mbts.ui;
using System;
using System.Collections.Generic;
using System.Numerics;
public class DisplayQuantityMultiplier<T> : IDisplayTranslator<T> where T : struct, INumber<T> {
readonly Func<QuantityConversionData<T>, T, T> _to_display, _from_display;
readonly IEqualityComparer<T> _comparer;
T _actual_value;
QuantityConversionData<T> _conversion_data;
public DisplayQuantityMultiplier(
Func<QuantityConversionData<T>, T, T> to_display,
Func<QuantityConversionData<T>, T, T> from_display,
IEqualityComparer<T> comparer = null,
T actual_value = default,
QuantityConversionData<T> conversion_data = default) {
//
_to_display = to_display ?? throw new ArgumentNullException(nameof(to_display));
_from_display = from_display ?? throw new ArgumentNullException(nameof(from_display));
_comparer = comparer ?? EqualityComparer<T>.Default;
_actual_value = actual_value;
_conversion_data = conversion_data;
}
public event Action value_changed;
public T actual_value {
get => _actual_value;
set {
if (!_comparer.Equals(_actual_value, value)) {
_actual_value = value;
value_changed?.Invoke();
}
}
}
public T display_value {
get => _to_display(_conversion_data, _actual_value);
set => actual_value = _from_display(_conversion_data, value);
}
public QuantityConversionData<T> conversion_data {
get => _conversion_data;
set {
if (_conversion_data != value) {
_conversion_data = value;
value_changed?.Invoke();
}
}
}
}
public class OptionalDisplayQuantityMultiplier<T> : IDisplayTranslator<T?> where T : struct, INumber<T> {
T? _actual_value;
QuantityConversionData<T> _conversion_data;
public event Action value_changed;
public T? actual_value {
get => _actual_value;
set {
if (_actual_value != value) {
_actual_value = value;
value_changed?.Invoke();
}
}
}
public T? display_value {
get => _actual_value.HasValue ?
_conversion_data.to_display(_actual_value.Value) : _actual_value;
set => actual_value = value.HasValue ?
_conversion_data.from_display(value.Value) : value;
}
public QuantityConversionData<T> conversion_data {
get => _conversion_data;
set {
if (_conversion_data != value) {
_conversion_data = value;
value_changed?.Invoke();
}
}
}
}
public static class DisplayQuantityMultiplier {
public static DisplayQuantityMultiplier<uint> create_uint() => new(
DisplayTranslatorExtensions.to_display,
DisplayTranslatorExtensions.from_display);
public static DisplayQuantityMultiplier<double> create_double() => new(
DisplayTranslatorExtensions.to_display,
DisplayTranslatorExtensions.from_display);
}
@@ -0,0 +1,60 @@
using bts.utils;
using Spark.Core.Disposables;
using System;
using System.Collections.Generic;
using System.Numerics;
using System.Reactive.Linq;
namespace Spark.Api.Data;
public interface IDisplayTranslator<T> {
T display_value { get; set; }
T actual_value { get; set; }
event Action value_changed;
}
public static class DisplayTranslatorExtensions {
public static IObservable<T> subscribe_actual_value<T>(
this IDisplayTranslator<T> display_translator) =>
subscribe_actual_value(display_translator, EqualityComparer<T>.Default);
public static IObservable<T> subscribe_actual_value<T>(
this IDisplayTranslator<T> display_translator, IEqualityComparer<T> comparer) {
if (comparer is null)
throw new ArgumentNullException(nameof(comparer));
return Observable.Create<T>(o => {
var curr = display_translator.actual_value;
o.OnNext(curr);
display_translator.value_changed += on_value_changed;
return Disposable.Create(() => display_translator.value_changed -= on_value_changed);
void on_value_changed() {
var next = display_translator.actual_value;
if (!comparer.Equals(curr, next))
o.OnNext(curr = next);
}
});
}
public static T to_display<T>(
this QuantityConversionData<T> quantity_conversion_data, T actual_value)
where T : INumber<T> =>
quantity_conversion_data.op switch {
QuantityConversionOpType.DivideActual =>
actual_value.safe_divide(quantity_conversion_data.value),
QuantityConversionOpType.MultiplyActual =>
actual_value * quantity_conversion_data.value,
_ => actual_value,
};
public static T from_display<T>(
this QuantityConversionData<T> quantity_conversion_data, T display_value)
where T : INumber<T> =>
quantity_conversion_data.op switch {
QuantityConversionOpType.DivideActual => display_value * quantity_conversion_data.value,
QuantityConversionOpType.MultiplyActual =>
display_value.safe_divide(quantity_conversion_data.value),
_ => display_value,
};
}
@@ -0,0 +1,43 @@
namespace Spark.Api.Data;
using Spark.Core;
using System;
using System.Numerics;
public enum QuantityConversionOpType {
None,
MultiplyActual,
DivideActual
}
public readonly struct QuantityConversionData<T> : IEquatable<QuantityConversionData<T>>
where T : INumber<T> {
public QuantityConversionData(T value, QuantityConversionOpType op) {
this.value = value;
this.op = op;
}
public T value { get; }
public QuantityConversionOpType op { get; }
public QuantityConversionData<TResult> convert_numeric_type<TResult>()
where TResult : INumber<TResult> =>
new(NumericCastConverter<T, TResult>.convert(value), op);
public bool Equals(QuantityConversionData<T> other) =>
value == other.value &&
op == other.op;
public override bool Equals(object obj) =>
obj is QuantityConversionData<T> other && Equals(other);
public override int GetHashCode() =>
HashCode.Combine(value, op);
public static bool operator ==(QuantityConversionData<T> x, QuantityConversionData<T> y) =>
x.Equals(y);
public static bool operator !=(QuantityConversionData<T> x, QuantityConversionData<T> y) =>
!x.Equals(y);
}
@@ -1,20 +1,20 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace mbts.utils {
public class ReverseComparer<T> : IComparer<T> {
private readonly IComparer<T> _wrapped;
public ReverseComparer(IComparer<T> wrapped) {
_wrapped = wrapped;
}
public int Compare(T x, T y) {
// reverse operands
return _wrapped.Compare(y, x);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace mbts.utils {
public class ReverseComparer<T> : IComparer<T> {
private readonly IComparer<T> _wrapped;
public ReverseComparer(IComparer<T> wrapped) {
_wrapped = wrapped;
}
public int Compare(T x, T y) {
// reverse operands
return _wrapped.Compare(y, x);
}
}
}