Indicators

Author: artemiusgreat

Core/Core/Conventions/Indicator.cs

@@ -1,4 +1,5 @@
 using Core.Models;
+using Core.Services;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
@@ -35,6 +36,11 @@ public class Indicator : IIndicator
     /// </summary>
     public virtual Price Response { get; protected set; } = new();
 
+    /// <summary>
+    /// Average
+    /// </summary>
+    public virtual AverageService Average { get; protected set; } = new();
+
     /// <summary>
     /// Calculate indicator values
     /// </summary>

Core/Core/Indicators/AtrIndicator.cs

@@ -0,0 +1,47 @@
+using Core.Conventions;
+using Core.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Core.Indicators
+{
+  public class AtrIndicator : Indicator
+  {
+    /// <summary>
+    /// Number of bars to average
+    /// </summary>
+    public int Interval { get; set; }
+
+    /// <summary>
+    /// Calculate single value
+    /// </summary>
+    /// <param name="collection"></param>
+    public override Task<IIndicator> Update(IList<Price> collection)
+    {
+      var response = Task.FromResult<IIndicator>(this);
+      var currentPoint = collection.ElementAtOrDefault(collection.Count - 1);
+      var previousPoint = collection.ElementAtOrDefault(collection.Count - 2);
+
+      if (currentPoint is null || previousPoint is null)
+      {
+        return response;
+      }
+
+      var interval = Math.Min(Interval, collection.Count);
+      var value =
+        Math.Max(currentPoint.Bar.High.Value, previousPoint.Bar.Close.Value) -
+        Math.Min(currentPoint.Bar.Low.Value, previousPoint.Bar.Close.Value);
+
+      if (interval is not 0)
+      {
+        value = ((Response.Last ?? 1) * Math.Max(Interval - 1, 0) + value) / interval;
+      }
+
+      Response = Response with { Last = value };
+
+      return response;
+    }
+  }
+}

Core/Core/Indicators/ImbalanceIndicator.cs

@@ -0,0 +1,45 @@
+using Core.Conventions;
+using Core.Models;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Core.Indicators
+{
+  public class ImbalanceIndicator : Indicator
+  {
+    /// <summary>
+    /// Mode
+    /// </summary>
+    public virtual int Mode { get; set; } = 0;
+
+    /// <summary>
+    /// Calculate indicator value
+    /// </summary>
+    /// <param name="collection"></param>
+    /// <param name="side"></param>
+    public override Task<IIndicator> Update(IList<Price> collection)
+    {
+      var response = Task.FromResult<IIndicator>(this);
+      var currentPoint = collection.LastOrDefault();
+
+      if (currentPoint is null)
+      {
+        return response;
+      }
+
+      var value = 0.0;
+
+      switch (Mode)
+      {
+        case 0: value = currentPoint.AskSize.Value - currentPoint.BidSize.Value; break;
+        case 1: value = currentPoint.AskSize.Value; break;
+        case -1: value = currentPoint.BidSize.Value; break;
+      }
+
+      Response = Response with { Last = value };
+
+      return response;
+    }
+  }
+}

Core/Core/Indicators/MaIndicator.cs

@@ -0,0 +1,63 @@
+using Core.Conventions;
+using Core.Extensions;
+using Core.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Core.Indicators
+{
+  /// <summary>
+  /// Calculation mode
+  /// </summary>
+  public enum AveragePriceEnum : byte
+  {
+    Bid = 1,
+    Ask = 2,
+    Close = 3
+  }
+
+  public class MaIndicator : Indicator
+  {
+    /// <summary>
+    /// Number of bars to average
+    /// </summary>
+    public int Interval { get; set; }
+
+    /// <summary>
+    /// Calculation mode
+    /// </summary>
+    public AveragePriceEnum Mode { get; set; }
+
+    /// <summary>
+    /// Calculate single value
+    /// </summary>
+    /// <param name="collection"></param>
+    public override Task<IIndicator> Update(IList<Price> collection)
+    {
+      var response = Task.FromResult<IIndicator>(this);
+      var currentPoint = collection.LastOrDefault();
+
+      if (currentPoint is null)
+      {
+        return response;
+      }
+
+      var value = currentPoint.Last.Value;
+
+      switch (Mode)
+      {
+        case AveragePriceEnum.Bid: value = currentPoint.Bid.Value; break;
+        case AveragePriceEnum.Ask: value = currentPoint.Ask.Value; break;
+      }
+
+      var interval = Math.Min(Interval, collection.Count);
+      var average = Average.LinearWeightAverage(collection.Select(o => o.Last.Value), collection.Count - 1, interval) as double?;
+
+      Response = Response with { Last = average.Is(0) ? value : average };
+
+      return response;
+    }
+  }
+}

Core/Core/Indicators/RsiIndicator.cs

@@ -0,0 +1,58 @@
+using Core.Conventions;
+using Core.Extensions;
+using Core.Models;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Core.Indicators
+{
+  public class RsiIndicator : Indicator
+  {
+    /// <summary>
+    /// Number of bars to average
+    /// </summary>
+    public int Interval { get; set; }
+
+    /// <summary>
+    /// Calculate single value
+    /// </summary>
+    /// <param name="collection"></param>
+    public override Task<IIndicator> Update(IList<Price> collection)
+    {
+      var response = Task.FromResult<IIndicator>(this);
+      var currentPoint = collection.LastOrDefault();
+
+      if (currentPoint is null)
+      {
+        return response;
+      }
+
+      var ups = new List<double>(Interval);
+      var downs = new List<double>(Interval);
+
+      for (var i = 1; i <= Interval; i++)
+      {
+        var nextPrice = collection.ElementAtOrDefault(collection.Count - i);
+        var previousPrice = collection.ElementAtOrDefault(collection.Count - i - 1);
+
+        if (nextPrice is not null && previousPrice is not null)
+        {
+          ups.Add(Math.Max(nextPrice.Last.Value - previousPrice.Last.Value, 0.0));
+          downs.Add(Math.Max(previousPrice.Last.Value - nextPrice.Last.Value, 0.0));
+        }
+      }
+
+      var interval = Math.Min(Interval, collection.Count);
+      var averageUp = Average.SimpleAverage(ups, ups.Count - 1, interval);
+      var averageDown = Average.SimpleAverage(downs, downs.Count - 1, interval) as double?;
+      var average = averageDown.Is(0) ? 1.0 : averageUp / averageDown;
+
+      Response = Response with { Last = 100.0 - 100.0 / (1.0 + average) };
+
+      return response;
+    }
+  }
+}

Core/Core/Indicators/ScaleIndicator.cs

@@ -33,11 +33,11 @@ public class ScaleIndicator : Indicator
     /// <summary>
     /// Calculate indicator value
     /// </summary>
-    /// <param name="prices"></param>
-    public override Task<IIndicator> Update(IList<Price> prices)
+    /// <param name="collection"></param>
+    public override Task<IIndicator> Update(IList<Price> collection)
     {
       var response = Task.FromResult<IIndicator>(this);
-      var currentPoint = prices.LastOrDefault();
+      var currentPoint = collection.LastOrDefault();
 
       if (currentPoint is null)
       {

Core/Core/Indicators/VwapIndicator.cs

@@ -0,0 +1,63 @@
+using Core.Conventions;
+using Core.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Core.Indicators
+{
+  public class VwapIndicator : Indicator
+  {
+    /// <summary>
+    /// Calculate indicator value
+    /// </summary>
+    /// <param name="collection"></param>
+    public override Task<IIndicator> Update(IList<Price> collection)
+    {
+      var response = Task.FromResult<IIndicator>(this);
+      var currentPoint = collection.LastOrDefault();
+
+      if (currentPoint?.Bar is null)
+      {
+        return response;
+      }
+
+      var cumPrice = 0.0;
+      var cumVolume = 0.0;
+      var items = new List<(double Price, double Volume)>();
+
+      Response = Response with { Bar = Response.Bar ?? new() };
+
+      foreach (var point in collection)
+      {
+        var price = (point.Bar.Low + point.Bar.High + point.Bar.Close).Value / 3.0;
+        var volume = point.Volume ?? (point.BidSize ?? 0 + point.AskSize ?? 0);
+
+        cumPrice += price * volume;
+        cumVolume += volume;
+
+        items.Add((price, volume));
+
+        var average = cumPrice / cumVolume;
+        var variance = items
+            .Select(o => o.Volume * (o.Price - average) * (o.Price - average))
+            .Sum() / cumVolume;
+
+        var deviation = Math.Sqrt(variance);
+
+        Response = Response with
+        {
+          Last = average,
+          Bar = Response.Bar with
+          {
+            High = average + 2.0 * deviation,
+            Low = average - 2.0 * deviation
+          }
+        };
+      }
+
+      return response;
+    }
+  }
+}

Dashboard/Dashboard/Pages/BasePage.cs

@@ -1,3 +1,4 @@
+using BitMart.Net.Enums;
 using Canvas.Core.Models;
 using Canvas.Core.Shapes;
 using Core.Conventions;
@@ -97,14 +98,16 @@ protected virtual string GetDate(IList<IShape> items, int index)
     /// <summary>
     /// Open position
     /// </summary>
+    /// <param name="adapter"></param>
     /// <param name="asset"></param>
     /// <param name="side"></param>
-    protected virtual async Task OpenPosition(IGateway adapter, Instrument asset, OrderSideEnum side)
+    /// <param name="amount"></param>
+    protected virtual async Task OpenPosition(IGateway adapter, Instrument asset, OrderSideEnum side, double amount = 1)
     {
       var order = new Order
       {
-        Amount = 1,
         Side = side,
+        Amount = amount,
         Type = OrderTypeEnum.Market,
         Operation = new() { Instrument = asset }
       };
@@ -115,9 +118,11 @@ protected virtual async Task OpenPosition(IGateway adapter, Instrument asset, Or
     /// <summary>
     /// Close positions
     /// </summary>
+    /// <param name="adapter"></param>
     /// <param name="condition"></param>
-    protected virtual async Task ClosePosition(IGateway adapter, Func<Order, bool> condition = null)
+    protected virtual async Task<List<Order>> ClosePosition(IGateway adapter, Func<Order, bool> condition = null)
     {
+      var response = new List<Order>();
       var positions = await adapter.GetPositions(default);
 
       foreach (var position in positions.Data)
@@ -136,8 +141,12 @@ protected virtual async Task ClosePosition(IGateway adapter, Func<Order, bool> c
           };
 
           await adapter.SendOrder(order);
+
+          response.Add(order);
         }
       }
+
+      return response;
     }
   }
 }