public void ImplicitOperators()
{
var symbol1 = Symbol.BTC_USDT;
var symbol2 = new Symbol(symbol1.Status, symbol1.BaseAsset, symbol1.QuoteAsset, symbol1.Quantity, symbol1.Price, symbol1.NotionalMinimumValue, symbol1.IsIcebergAllowed, symbol1.OrderTypes);
var symbol3 = Symbol.BCH_USDT;
Assert.True(symbol1 == symbol2);
Assert.True(symbol1 != symbol3);
Assert.True(symbol1 == symbol1.ToString());
Assert.True(symbol1 == symbol2.ToString());
Assert.True(symbol1 != symbol3.ToString());
var baseAsset = new Asset("TEST", 8);
var quoteAsset = Asset.BTC;
var quantityRange = new InclusiveRange(0.01m, 10.0m, 0.01m);
var priceRange = new InclusiveRange(0.01m, 100.0m, 0.01m);
const decimal minNotionalValue = 0.001m;
const bool isIcebergAllowed = true;
var orderTypes = new[] { OrderType.Limit, OrderType.Market };
var newSymbol = new Symbol(SymbolStatus.Trading, baseAsset, quoteAsset, quantityRange, priceRange, minNotionalValue, isIcebergAllowed, orderTypes);
Assert.True(newSymbol == baseAsset.Symbol + quoteAsset.Symbol);
}
public void GetLowerValidValue()
{
const decimal minimum = 0.01m;
const decimal maximum = 10.0m;
const decimal increment = 0.01m;
var range = new InclusiveRange(minimum, maximum, increment);
Assert.Equal(maximum, range.GetLowerValidValue(maximum));
Assert.Equal(minimum, range.GetLowerValidValue(minimum));
Assert.Equal(minimum + increment, range.GetLowerValidValue(minimum + increment));
Assert.Equal(maximum - increment, range.GetLowerValidValue(maximum - increment));
Assert.Equal(1.11m, range.GetLowerValidValue(1.110m));
Assert.Equal(1.11m, range.GetLowerValidValue(1.112m));
Assert.Equal(1.11m, range.GetLowerValidValue(1.115m));
Assert.Equal(1.11m, range.GetLowerValidValue(1.118m));
Assert.Equal(1.12m, range.GetLowerValidValue(1.120m));
Assert.Equal(1.12m, range.GetLowerValidValue(1.122m));
Assert.Equal(1.12m, range.GetLowerValidValue(1.125m));
Assert.Equal(1.12m, range.GetLowerValidValue(1.128m));
// 9.876 => 9.870 given range of [0.01 - 10.00] with increment of 0.01.
Assert.Equal(9.870m, range.GetLowerValidValue(9.876m));
}
private static List <Area> AllPossibleAreas(InclusiveRange realAxis, InclusiveRange imaginaryAxis, double gridSize)
{
var allAreas = new List <Area>();
var realPoints = new List <double>();
for (var realPoint = realAxis.Minimum; realPoint <= realAxis.Maximum; realPoint += gridSize)
{
realPoints.Add(realPoint);
}
var imaginaryPoints = new List <double>();
for (var imaginaryPoint = imaginaryAxis.Minimum; imaginaryPoint <= imaginaryAxis.Maximum; imaginaryPoint += gridSize)
{
imaginaryPoints.Add(imaginaryPoint);
}
for (var realIndex = 0; realIndex < realPoints.Count - 1; realIndex++)
{
for (var imaginaryIndex = 0; imaginaryIndex < imaginaryPoints.Count - 1; imaginaryIndex++)
{
var realRange = new InclusiveRange(realPoints[realIndex], realPoints[realIndex + 1]);
var imaginaryRange = new InclusiveRange(imaginaryPoints[imaginaryIndex], imaginaryPoints[imaginaryIndex + 1]);
var gridBox = new Area(
realRange,
imaginaryRange);
allAreas.Add(gridBox);
}
}
return(allAreas);
}
public void Properties()
{
const decimal minimum = 0.001m;
const decimal maximum = 10.0m;
const decimal increment = 0.01m;
var range = new InclusiveRange(minimum, maximum, increment);
Assert.Equal(minimum, range.Minimum);
Assert.Equal(maximum, range.Maximum);
Assert.Equal(increment, range.Increment);
}
private static Int64RangeNode Split(int start, int end, IList <InclusiveRange> elementaryIntervals)
{
if (start == end - 1)
{
// leaf
InclusiveRange range = elementaryIntervals[start];
return(new Int64RangeNode(range.Start, range.End, null, null, start));
}
else
{
int mid = (int)((uint)(start + end) >> 1);
Int64RangeNode left = Split(start, mid, elementaryIntervals);
Int64RangeNode right = Split(mid, end, elementaryIntervals);
return(new Int64RangeNode(left.start, right.end, left, right, -1));
}
}
public void IsValid()
{
const SymbolStatus status = SymbolStatus.Trading;
var quoteAsset = Asset.USDT;
var quantityRange = new InclusiveRange(0.01m, 10.0m, 0.01m);
var priceRange = new InclusiveRange(0.01m, 100.0m, 0.01m);
const decimal minNotionalValue = 0.001m;
const bool isIcebergAllowed = true;
var orderTypes = new [] { OrderType.Limit, OrderType.Market };
var validSymbol = Symbol.BTC_USDT;
var invalidSymbol = new Symbol(status, new Asset("...", 0), quoteAsset, quantityRange, priceRange, minNotionalValue, isIcebergAllowed, orderTypes);
Assert.True(Symbol.IsValid(validSymbol));
Assert.False(Symbol.IsValid(invalidSymbol));
}
public void Throws()
{
const SymbolStatus status = SymbolStatus.Trading;
var baseAsset = Asset.BTC;
var quoteAsset = Asset.USDT;
var quantityRange = new InclusiveRange(0.01m, 10.0m, 0.01m);
var priceRange = new InclusiveRange(0.01m, 100.0m, 0.01m);
const decimal minNotionalValue = 0.001m;
const bool isIcebergAllowed = true;
var orderTypes = new OrderType[] { OrderType.Limit, OrderType.Market };
Assert.Throws <ArgumentNullException>("baseAsset", () => new Symbol(status, null, quoteAsset, quantityRange, priceRange, minNotionalValue, isIcebergAllowed, orderTypes));
Assert.Throws <ArgumentNullException>("quoteAsset", () => new Symbol(status, baseAsset, null, quantityRange, priceRange, minNotionalValue, isIcebergAllowed, orderTypes));
Assert.Throws <ArgumentNullException>("quantity", () => new Symbol(status, baseAsset, quoteAsset, null, priceRange, minNotionalValue, isIcebergAllowed, orderTypes));
Assert.Throws <ArgumentNullException>("price", () => new Symbol(status, baseAsset, quoteAsset, quantityRange, null, minNotionalValue, isIcebergAllowed, orderTypes));
Assert.Throws <ArgumentNullException>("orderTypes", () => new Symbol(status, baseAsset, quoteAsset, quantityRange, priceRange, minNotionalValue, isIcebergAllowed, null));
}
public void GetValidValue()
{
const decimal minimum = 0.01m;
const decimal maximum = 10.0m;
const decimal increment = 0.01m;
var range = new InclusiveRange(minimum, maximum, increment);
Assert.Equal(maximum, range.GetValidValue(maximum));
Assert.Equal(minimum, range.GetValidValue(minimum));
Assert.Equal(minimum + increment, range.GetValidValue(minimum + increment));
Assert.Equal(maximum - increment, range.GetValidValue(maximum - increment));
var midpointRounding = MidpointRounding.ToEven;
Assert.Equal(1.11m, range.GetValidValue(1.110m, midpointRounding));
Assert.Equal(1.11m, range.GetValidValue(1.112m, midpointRounding));
Assert.Equal(1.12m, range.GetValidValue(1.115m, midpointRounding));
Assert.Equal(1.12m, range.GetValidValue(1.118m, midpointRounding));
Assert.Equal(1.12m, range.GetValidValue(1.120m, midpointRounding));
Assert.Equal(1.12m, range.GetValidValue(1.122m, midpointRounding));
Assert.Equal(1.12m, range.GetValidValue(1.125m, midpointRounding));
Assert.Equal(1.13m, range.GetValidValue(1.128m, midpointRounding));
midpointRounding = MidpointRounding.AwayFromZero;
Assert.Equal(1.11m, range.GetValidValue(1.110m, midpointRounding));
Assert.Equal(1.11m, range.GetValidValue(1.112m, midpointRounding));
Assert.Equal(1.12m, range.GetValidValue(1.115m, midpointRounding));
Assert.Equal(1.12m, range.GetValidValue(1.118m, midpointRounding));
Assert.Equal(1.12m, range.GetValidValue(1.120m, midpointRounding));
Assert.Equal(1.12m, range.GetValidValue(1.122m, midpointRounding));
Assert.Equal(1.13m, range.GetValidValue(1.125m, midpointRounding));
Assert.Equal(1.13m, range.GetValidValue(1.128m, midpointRounding));
// 1.234 => 1.230 given range of [0.01 - 10.00] with increment of 0.01.
Assert.Equal(1.230m, range.GetValidValue(1.234m));
// 2.345 => 2.340 given range of [0.01 - 10.00] with increment of 0.01 (midpoint rounding to even).
// ReSharper disable once RedundantArgumentDefaultValue
Assert.Equal(2.340m, range.GetValidValue(2.345m, MidpointRounding.ToEven));
// 2.345 => 2.350 given range of [0.01 - 10.00] with increment of 0.01 (midpoint rounding away from 0).
Assert.Equal(2.350m, range.GetValidValue(2.345m, MidpointRounding.AwayFromZero));
// 9.876 => 9.880 given range of [0.01 - 10.00] with increment of 0.01.
Assert.Equal(9.880m, range.GetValidValue(9.876m));
}
public void IsValid()
{
const decimal minimum = 0.01m;
const decimal maximum = 10.0m;
const decimal increment = 0.01m;
var range = new InclusiveRange(minimum, maximum, increment);
Assert.True(range.IsValid(minimum));
Assert.True(range.IsValid(maximum));
Assert.True(range.IsValid(minimum + increment));
Assert.True(range.IsValid(maximum - increment));
Assert.False(range.IsValid(minimum - increment));
Assert.False(range.IsValid(maximum + increment));
Assert.False(range.IsValid(minimum + increment / 2));
Assert.False(range.IsValid(maximum - increment / 2));
}
public void Validate()
{
const decimal minimum = 0.01m;
const decimal maximum = 10.0m;
const decimal increment = 0.01m;
var range = new InclusiveRange(minimum, maximum, increment);
range.Validate(minimum);
range.Validate(maximum);
range.Validate(minimum + increment);
range.Validate(maximum - increment);
Assert.Throws <ArgumentOutOfRangeException>("value", () => range.Validate(minimum - increment));
Assert.Throws <ArgumentOutOfRangeException>("value", () => range.Validate(maximum + increment));
Assert.Throws <ArgumentOutOfRangeException>("value", () => range.Validate(minimum + increment / 2));
Assert.Throws <ArgumentOutOfRangeException>("value", () => range.Validate(maximum - increment / 2));
}
public void Properties()
{
const SymbolStatus status = SymbolStatus.Trading;
var baseAsset = Asset.BTC;
var quoteAsset = Asset.USDT;
var quantityRange = new InclusiveRange(0.01m, 10.0m, 0.01m);
var priceRange = new InclusiveRange(0.01m, 100.0m, 0.01m);
const decimal minNotionalValue = 0.001m;
const bool isIcebergAllowed = true;
var orderTypes = new OrderType[] { OrderType.Limit, OrderType.Market };
var symbol = new Symbol(status, baseAsset, quoteAsset, quantityRange, priceRange, minNotionalValue, isIcebergAllowed, orderTypes);
Assert.Equal(status, symbol.Status);
Assert.Equal(baseAsset, symbol.BaseAsset);
Assert.Equal(quoteAsset, symbol.QuoteAsset);
Assert.Equal(quantityRange, symbol.Quantity);
Assert.Equal(priceRange, symbol.Price);
Assert.Equal(minNotionalValue, symbol.NotionalMinimumValue);
Assert.Equal(orderTypes, symbol.OrderTypes);
}
public double Next(InclusiveRange range)
{
return(range.Magnitude * NextDouble() + range.Minimum);
}
public void Increment()
{
// Arrange
var a = 1.00000000M;
var b = 0.10000000M;
var c = 0.01000000M;
var d = 0.00100000M;
var e = 0.00010000M;
var f = 0.00001000M;
var g = 0.00000100M;
var h = 0.00000010M;
var j = 0.00000001M;
// Act
var ai = new InclusiveRange {
Increment = a
};
var bi = new InclusiveRange {
Increment = b
};
var ci = new InclusiveRange {
Increment = c
};
var di = new InclusiveRange {
Increment = d
};
var ei = new InclusiveRange {
Increment = e
};
var fi = new InclusiveRange {
Increment = f
};
var gi = new InclusiveRange {
Increment = g
};
var hi = new InclusiveRange {
Increment = h
};
var ji = new InclusiveRange {
Increment = j
};
// Assert
Assert.AreEqual(ai.Increment, a);
Assert.AreEqual(bi.Increment, b);
Assert.AreEqual(ci.Increment, c);
Assert.AreEqual(di.Increment, d);
Assert.AreEqual(ei.Increment, e);
Assert.AreEqual(fi.Increment, f);
Assert.AreEqual(gi.Increment, g);
Assert.AreEqual(hi.Increment, h);
Assert.AreEqual(ji.Increment, j);
Assert.AreEqual(ai.Increment.ToString(), "1");
Assert.AreEqual(bi.Increment.ToString(), "0.1");
Assert.AreEqual(ci.Increment.ToString(), "0.01");
Assert.AreEqual(di.Increment.ToString(), "0.001");
Assert.AreEqual(ei.Increment.ToString(), "0.0001");
Assert.AreEqual(fi.Increment.ToString(), "0.00001");
Assert.AreEqual(gi.Increment.ToString(), "0.000001");
Assert.AreEqual(hi.Increment.ToString(), "0.0000001");
Assert.AreEqual(ji.Increment.ToString(), "0.00000001");
}
/// <summary>
/// Verify a value is within range and of a valid increment.
/// </summary>
/// <param name="range"></param>
/// <param name="value"></param>
/// <returns></returns>
public static bool IsValid(this InclusiveRange range, decimal value)
{
Throw.IfNull(range, nameof(range));
return(value >= range.Minimum && value <= range.Maximum && (value - range.Minimum) % range.Increment == 0);
}
