/// <summary> /// Vrifico se ci sono bolle particolamente vecchie da eliminare /// </summary> private void CheckBubblesToCancel() { //recupero le vecchie bolle solo se sono in una situazione di stallo e mi mancano bolle if (_market.Bubbles.Count + this.WishList.Count < _configuration.MaxBubbles*(decimal) 0.8) { return; } // ne creo solo una (distruggere le bolle costa) foreach (CBubble bubble in _market.Bubbles) { if (bubble.SellAt > _market.Ask * BubbleDestructionLevel) { // distruggi la bolla var marketValue = _market.Ask; var orderId = ""; _market.DoOrder(CUtility.OrderType.Sell, marketValue, bubble.Coins, ref orderId, true); CUtility.Log("*** Bubble destroyed"); bubble.Deleted = true; _bubblesCanceled++; // crea una bolla in wishlist WishList.Add(CBubble.Create(_market, CUtility.OrderType.Buy, bubble.Coins, bubble.BuyAt, _configuration.Gain,orderId)); break; } } var removed = _market.Bubbles.RemoveAll(o => o.Deleted == true); }
public void Log(string msg) { if (MainConfiguration.Configuration.Verbose) { CUtility.Log(msg); } }
/// <summary> /// il tick è il momento in cui vengono prese le decisioni di buy/sell /// </summary> private void OnTick() { CUtility.Log("*** tick"); // in questo simulatore se il mercato scende non ci muoviamo if (_trend < 0) { // verifico se ci sono bolle irraggiungibili if (EnableBubbleDestruction) { CheckBubblesToCancel(); } CUtility.Log("*** trend down... skip"); return; } // analizzo il numero di bolle, per crearne almeno una var numBubbles = _market.Bubbles.Count() + WishList.Count(); if (numBubbles < _configuration.MaxBubbles) { CreateBubble(); } // mostro le bolle _market.ShowBubbles(); }
public void Print() { foreach (Tag t in _tags.Values) { CUtility.Log(string.Format("{0} {1} {2}", t.Label, t.Called, t.Confirmed)); } }
public void Log() { CUtility.Log(string.Format("Candle {0} {1} {2}", this.Date.ToString(CultureInfo.InvariantCulture), Math.Round(this.Close, 4).ToString(CultureInfo.InvariantCulture), this.Color.ToString())); //CUtility.Log("Date : " + this.Date.ToString(CultureInfo.InvariantCulture)); //CUtility.Log("Bid : " + Math.Round(this.Close, 4).ToString(CultureInfo.InvariantCulture)); //CUtility.Log("Color : " + this.Color.ToString()); CUtility.Log(""); }
public void Print() { CUtility.Log("money : " + Money.ToString(CultureInfo.InvariantCulture)); CUtility.Log("coins : " + Coins.ToString(CultureInfo.InvariantCulture)); CUtility.Log("coinvalue : " + Coinvalue.ToString(CultureInfo.InvariantCulture)); CUtility.Log("value : " + Value.ToString(CultureInfo.InvariantCulture)); CUtility.Log("i : " + i.ToString(CultureInfo.InvariantCulture)); CUtility.Log("j : " + j.ToString(CultureInfo.InvariantCulture)); CUtility.Log("w : " + w.ToString(CultureInfo.InvariantCulture)); CUtility.Log("k : " + k.ToString(CultureInfo.InvariantCulture)); }
private void CreateBubble() { CUtility.Log("*** order buy"); var marketValue = _market.Bid; string orderId = ""; // non compro perchè il valore di mercato è circa il 10% di altre bolle presenti if (_market.Bubbles.Any(o => Math.Abs(o.MarketValue - marketValue) <= marketValue/10)) { return; } // soldi nel wallet, ma non piu' del massimo consentito decimal availableMoney = _market.TotMoney; if (availableMoney > _configuration.MaxMoney) { availableMoney = _configuration.MaxMoney; } // come creo una bolla ? var money = availableMoney / _configuration.MaxBubbles; var coins = money / marketValue; if (coins > _configuration.MaxCoinsPerBubble) { coins = _configuration.MaxCoinsPerBubble; } // verifico di non aver impiegato troppi soldi // verifico di non aver superato le soglie minime di coins e soldi _market.DoOrder(CUtility.OrderType.Buy, marketValue, coins, ref orderId, true); CUtility.Log("*** Bubble added"); _bubblesCreated++; _market.Bubbles.Add(CBubble.Create(_market, CUtility.OrderType.Buy, coins, marketValue, _configuration.Gain, orderId)); }
/// <summary> /// elimina le bolle che hanno raggiunto il guadagno /// </summary> private bool CheckBubbles() { if (_trend >= 0) { // se il trend è in salita aspetto (dovrebbe ottimizzare i guadagni) //return false; } if (_market.Bubbles.Count > 0 ) { // scoppio le bolle foreach (CBubble bubble in _market.Bubbles) { if (bubble.SellAt < _market.Ask) { //scoppio la bolla: cioè vendo i bitcoin per poterli riutilizzare var marketValue = _market.Ask; var orderId = ""; _market.DoOrder(CUtility.OrderType.Sell, marketValue, bubble.Coins, ref orderId, true); CUtility.Log("*** Bubble removed"); _bubblesExploded++; bubble.Deleted = true; // occorrerebbe mettere un acquisto di btc appena sono convenienti } } // rimuovo le bolle scoppiate var removed = _market.Bubbles.RemoveAll(o => o.Deleted == true); // se ho scoppiato bolle aspetto un tick if (removed > 0) { _market.ShowBubbles(); //return; } return removed > 0; } return false; }
public Trend SuggestedTrend() { double perc = 0; var prediction = Guess(out perc); CUtility.Log("Perc : " + perc); CUtility.Log("Pattern: " + prediction.ToString().Replace("BitVector32{","").Replace("}","").Substring(28)); if (perc > 0.33) { var numGreen = 0; for (var i = 0; i < Dim2;i++) { if (prediction[0]) { numGreen++; } } if (numGreen >= Dim2*3/4) { return Trend.Raise; } else { if (numGreen == Dim2/2) { return Trend.Stable; } else { return Trend.Fall; } } } else { return Trend.Unknown; } }
// Specify what you want to happen when the Elapsed event is raised. private void OnHeartBeat(object source, ElapsedEventArgs e) { try { // è scattato un heartbeat //var stop = false; CUtility.Log("*** heartbeat"); // verifico lo stato del mercato _market.GetTicker(); // aggiorno la mia situazione _market.GetWallet(); /* // trend _trend = _market.Trend.CalculateTrend(); // ema _ema = _market.Trend.Ema; // il trend deve essere affidabile altrimenti esce if (!_market.Trend.TrendIsValid) { return; } */ if (!_market.CandleMaker.Analyze.IsValid()) { return; } // elimina le bolle (ad ogni tick.. prima si fa e meglio è) var hasExplodedBubbles = CheckBubbles(); // check wishlist var hasResolvedWishList = CheckWishList(); if (!hasExplodedBubbles && !hasResolvedWishList) { // strategia per il tick if (_configuration.TickDynamic) { _ticksPerHearthBeat = NextTick(_ticksPerHearthBeat); } // verifico se deve scattare un tick _tickCounter++; if (_tickCounter >= _ticksPerHearthBeat) { // non uso il mod perchè potrei dover usare un // cambio dinamico al tickcounter _tickCounter = 0; OnTick(); } } // al termine dei task decido se fermare il processo oppure no if (_market.Stop) { _stopwatch.Stop(); _heartBeatTimer.Enabled = false; CUtility.Log("Time Elapsed : " + _stopwatch.Elapsed); } // secondo me questo è il momento in cui vanno salvate le persistenze } catch (Exception) { CUtility.Log("Error in hearthbeat : "); //throw; } finally { CUtility.Log("Created : " + this._bubblesCreated); CUtility.Log("Exploded : " + this._bubblesExploded); CUtility.Log("Canceled : " + this._bubblesCanceled); CUtility.Log("Whish : " + this.WishList.Count); } }
public override void Run() { //creo il file per l'esecuzione corrente var filename = string.Format(@"log\{0}_{1}.txt", "Test2", DateTime.Now.ToString("ddMMyyyy_hhmm")); // System.IO.File.Create(filename); //apro lo stream writer // using (System.IO.StreamWriter sw = new System.IO.StreamWriter(@"..\..\log\mtgoxcandlesMonth-15m", true)) { //lettura delle configurazioni var configuration = new ConfigurationHoldAndBuy() { Gain = (decimal)0.05, // 1% //HeartBeat = (decimal)0.001, // 1m MaxBubbles = 1, //(j+1), MaxCoinsPerBubble = (decimal)(0.6), MinimumCoinsPerBubble = (decimal)0.01, //MaxMoney = 100, //Tick = 1, //w+1, //TickDynamic = false }; //parametri MACD var arr = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; var param = from i in arr from j in arr from k in arr select new { i, j, k }; //iterazione lungo i parametri param.ToList().ForEach(p => { //generazione del market var market = new CMarketSimulator(); //(15, 17, 12 + p.i, 20 + p.j, 5 + p.k); //istanzio il manager var manager = new Manager.CManagerHoldBuy() { ConfigurationHoldAndBuy = configuration, Market = market };//(configuration, market, true); //lancio il test // salvo il risultato var test = new TestUnit() { Bubbles = configuration.MaxBubbles, Coins = market.TotCoins, Money = market.TotMoney, Gain = configuration.Gain, Maxcoinsperbubble = configuration.MaxCoinsPerBubble, Coinvalue = market.Bid, //Ticks = configuration.Tick, Value = market.TotValue, Average = market.Average, i = p.i, j = p.j, //w=w, k = p.k }; //stampo il test CUtility.Log("*** TEST"); // test.PrintOnFile(sw); //test.PrintOnConsole(); test.Print(); }); } }
private decimal _lastCoin = -1; // non si puo' usare decimal.MinValue public override bool OnHeartBeat() { const decimal gain = 0M; // sellat, buyat // devo vendere o devo comprare? var action = this.SuggestedAction; /* * // mi salvo il massimo value * if (Market.TotValue > this.MaxValue) * { * this.MaxValue = Market.TotValue; * } * * if (Market.TotCoins > this.MaxCoins) * { * this.MaxCoins = Market.TotCoins; * } */ /************************************************************** * CHECK CONFERMA (DOPPIO COMANDO) **************************************************************/ // questa parte di codice esegue l'operazione se c'è una conferma if (action != TradeAction.StrongBuy && action != TradeAction.StrongSell) { if (action != _lastTradeActionSuggested) { //CUtility.Log("refused: wait confirm with 2nd command"); LogTrade.Motivation = "refused: wait confirm with 2nd command"; _lastTradeActionSuggested = action; action = TradeAction.Unknown; } } else { LogTrade.Motivation = ("refused: single command"); _lastTradeActionSuggested = TradeAction.Unknown; } LogTrade.Action = action; /************************************************************** * BUY **************************************************************/ // compro o vendo? string orderId = ""; if (action == TechnicalAnalysis.TradeAction.Buy || action == TechnicalAnalysis.TradeAction.StrongBuy) { /* * per comprare devo usare il valore ask */ var buyvalue = Market.Buy; var money = (Market.TotMoney - SavedMoney) * PercCapital; // impegno solo una percentuale del capitale SavedMoney += (Market.TotMoney - SavedMoney) * (1 - PercCapital); if (money == 0) { LogTrade.Motivation = ("refused: no money"); goto exitif; } if (PercCapital < 1.0M) { // se uso una percentuale, allora devo evitare che ripetuti comandi // uguali, mi facciamo dissipare il risparmio accantonato if (_lastTradeActionExecuted == CUtility.OrderType.Buy) { goto exitif; } } if (Conservative) { // impegno sempre non più di una certa cifra // sia per vendere che per comprare if (money > MainConfiguration.Configuration.ManagerConservativeMaxMoneyToInvest) { SavedMoney += (money - MainConfiguration.Configuration.ManagerConservativeMaxMoneyToInvest); money = MainConfiguration.Configuration.ManagerConservativeMaxMoneyToInvest; } } var amount = money / buyvalue; // coins if (amount > MinBitCoin) { // compro solo se i coin risultanti sono più dei precedenti var coins = (amount) * (1 - Market.Fee); /* onlyIfGain attiva o disattiva il blocco delle vendite se i soldi ricavati sono inferiori rispetto alla vendita precedente */ var onlyIfGain = MainConfiguration.Configuration.GreedyWithCoins; // --> disabilità il blocco var greedyPerc = MainConfiguration.Configuration.GreedyWithCoinsGain; if (MainConfiguration.Configuration.GreedyWithLongTermTrend) { // diventa avido se il trend a lungo termine è in discesa onlyIfGain = this.CurrentLongTermTrend == Trend.Fall; var longTermCoefficienteAngolare = this.Market.CandleMaker.LongTermTrendSpeed(); greedyPerc = GreedyNess(longTermCoefficienteAngolare); } if (!onlyIfGain || action == TechnicalAnalysis.TradeAction.StrongBuy || coins > _lastCoin * greedyPerc) { // evito che il trading mi mandi sotto del numero iniziale di coins if (MainConfiguration.Configuration.UndervalueAllowed || (coins + SavedCoins) > MainConfiguration.Configuration.StartWalletCoins * (1 - MainConfiguration.Configuration.UndervalueTolerance)) { _lastCoin = coins; var result = Market.DoOrder(CUtility.OrderType.Buy, buyvalue, amount, ref orderId, true); if (result.Length > 0) { LogTrade.Motivation = "BUY"; _lastTradeActionExecuted = CUtility.OrderType.Buy; TotBid++; // avvisa l'analitic che l'ultima label inserita con AnalyticsTools.Call(xxxx) è completata AnalyticsTools.Confirm(); SellAt = (1 + gain) * (buyvalue * (1 + (2 * Market.Fee))); BuyAt = 0; } else { // c'è stato un fallimento LogTrade.Motivation = "BUY FAILED"; } } else { LogTrade.Motivation = ("under my initial value"); } } else { LogTrade.Motivation = ("greedy of coins: waiting for better performance " + Math.Round(_lastCoin * greedyPerc, 4).ToString(CultureInfo.InvariantCulture)); } } // _stoploss.Reset(); } /************************************************************** * SELL **************************************************************/ if (action == TechnicalAnalysis.TradeAction.Sell || action == TechnicalAnalysis.TradeAction.StrongSell) { var sellvalue = Market.Sell; var amount = (Market.TotCoins - SavedCoins) * PercCapital;// - SavedCoins; SavedCoins += (Market.TotCoins - SavedCoins) * (1 - PercCapital); if (amount == 0) { LogTrade.Motivation = ("refused: no coins"); goto exitif; } if (PercCapital < 1.0M) { // se uso una percentuale, allora devo evitare che ripetuti comandi // uguali, mi facciamo dissipare il risparmio accantonato if (_lastTradeActionExecuted == CUtility.OrderType.Sell) { goto exitif; } } if (Conservative) { // impegno sempre non più di una certa cifra // sia per vendere che per comprare var maxmoney = MainConfiguration.Configuration.ManagerConservativeMaxMoneyToInvest; if (amount > maxmoney / sellvalue) { SavedCoins += (amount - maxmoney / sellvalue); if (SavedCoins > 100) { CUtility.Log("error"); } amount = maxmoney / sellvalue; } } if (amount > MinBitCoin) { var money = (amount * sellvalue) * (1 - Market.Fee); /* onlyIfGain attiva o disattiva il blocco delle vendite se i soldi ricavati sono inferiori rispetto alla vendita precedente */ var onlyIfGain = MainConfiguration.Configuration.GreedyWithMoney; // --> disabilita il blocco var greedyPerc = MainConfiguration.Configuration.GreedyWithMoneyGain; if (MainConfiguration.Configuration.GreedyWithLongTermTrend) { // diventa avido se il trend a lungo termine è in salita onlyIfGain = this.CurrentLongTermTrend == Trend.Raise; var longTermCoefficienteAngolare = this.Market.CandleMaker.LongTermTrendSpeed(); greedyPerc = GreedyNess(longTermCoefficienteAngolare); } if (!onlyIfGain || action == TechnicalAnalysis.TradeAction.StrongSell || money > _lastMoney * greedyPerc) { // evito che il trading mi butti sotto del numero iniziale di soldi if (MainConfiguration.Configuration.UndervalueAllowed || (money + SavedMoney) > MainConfiguration.Configuration.StartWalletMoney * (1 - MainConfiguration.Configuration.UndervalueTolerance)) { // vendo solo se la vendita produce piu' soldi di prima _lastMoney = money; var result = Market.DoOrder(CUtility.OrderType.Sell, sellvalue, amount, ref orderId, true); if (result.Length > 0) { TotAsk++; BuyAt = (1 - gain) * (sellvalue * (1 - (2 * Market.Fee))); SellAt = 0; // avvisa l'analitic che l'ultima label inserita con AnalyticsTools.Call(xxxx) è completata AnalyticsTools.Confirm(); _lastTradeActionExecuted = CUtility.OrderType.Sell; LogTrade.Motivation = "SELL"; } else { LogTrade.Motivation = "SELL FAILED"; } /* * if (action == TechnicalAnalysis.TradeAction.SellStopLoss) * { * TotStopLoss++; * } */ } else { LogTrade.Motivation = ("under my initial value"); } } else { LogTrade.Motivation = ("greedy of money: waiting for better performance " + Math.Round(_lastMoney * greedyPerc, 4).ToString(CultureInfo.InvariantCulture)); } } } exitif: /************************************************************** * LOG **************************************************************/ Log(string.Format("B:{0} A:{1} SL:{2} Max$:{3} MaxC:{4} MaxV:{5}", TotBid, TotAsk, 0, Math.Round(Market.MaxMoney, 4).ToString(CultureInfo.InvariantCulture), Math.Round(Market.MaxCoins, 4).ToString(CultureInfo.InvariantCulture), Math.Round(Market.MaxValue, 4).ToString(CultureInfo.InvariantCulture))); LogTrade.BuyAt = BuyAt; LogTrade.SellAt = SellAt; return(true); }
public override TradeAction SuggestedAction(CMarket market) { /******************************************************************************** * COSTANTI (evaluator) ********************************************************************************/ //var timeUnit = 15; //data corrente (servirebbe la data del ticker, ma vabbè...) var now = market.CandleMaker.GetLastCandles()[0].Date; var lastCandle = new { m15 = market.CandleMaker.GetLastCandles()[0], h1 = market.CandleMakerHourly.GetLastCandles()[0], }; //valutatore var E = Evaluations.EvaluationManager.Instance; //formatta i nomi degli indicatori Func <string, string> N = (o => { return(string.Format("{0}[{1}]", o, this.Name)); }); /******************************************************************************** * COSTANTI ********************************************************************************/ var currentTrend = market.CandleMaker.Analyze.CurrentTrend; //Trend(); var roclimit = MainConfiguration.Configuration.AlarmStrongSellBuyRocLimit; var macdlimit = MainConfiguration.Configuration.AlarmStrongSellMacdLimit; /******************************************************************************** * STOP LOSS ********************************************************************************/ if (MainConfiguration.Configuration.EnableStopLoss) { if (StopLoss.IsSell(this.CoinValue)) { if (currentTrend == TechnicalAnalysis.Trend.Fall) { StopLoss.Reset(); StopLoss.SellCounter++; //EVAL: se uso lo stoploss, sto prevedendo che il prezzo scenda, anche di poco E.Add(N("stoploss"), CreatePrediction(now, TradeAction.StrongSell), timeUnit); } } } if (!IsValid()) { //AnalyticsTools.Call("notyetready"); return(TradeAction.Unknown); } /******************************************************************************** * ROC (non ancora usato) ********************************************************************************/ if (true) { var rocSpeed = Roc.Derivative.CurrentSpeed; if (Rocdiff > roclimit && rocSpeed <= 0 && currentTrend == TechnicalAnalysis.Trend.Fall) { //LogTrade.Note = "inversione: vendere"; //EVAL: se dico di vendere, vuol dire che il prezzo scenderà, anche di poco E.Add(N("-(rocdiff;rocspeed)"), CreatePrediction(now, TradeAction.Sell), timeUnit); if (CurrentMacdValue > macdlimit) { //EVAL: questo è un rafforzativo, quindi mi aspetto un grande ribasso E.Add(N("++(rocdiff;rocspeed;Macd122609)"), CreatePrediction(now, TradeAction.StrongSell), timeUnit); //return TradeAction.StrongSell; } } if (Rocdiff < -roclimit && rocSpeed <= 0 && currentTrend == TechnicalAnalysis.Trend.Raise) { //LogTrade.Note = "inversione: comprare"; //EVAL: se dico di comprare, vuol dire che il prezzo salirà, anche di poco E.Add(N("+(rocdiff;rocspeed)"), CreatePrediction(now, TradeAction.Buy), timeUnit); if (CurrentMacdValue < -macdlimit) { //EVAL: questo è un rafforzativo, quindi mi aspetto un grande rialzo E.Add(N("++(rocdiff;rocspeed;Macd122609)"), CreatePrediction(now, TradeAction.StrongBuy), timeUnit); // return TradeAction.StrongBuy; } } } if (true) { // se si mette a true, questo garantisce 12k e 15btc (l'altro pezzo sul roc va messo in tuning if (Rocdiff > roclimit && currentTrend == TechnicalAnalysis.Trend.Fall) { //LogTrade.Note = "inversione: vendere"; //EVAL: se dico di vendere, vuol dire che il prezzo scenderà, anche di poco E.Add(N("-(rocdiff)"), CreatePrediction(now, TradeAction.Sell), timeUnit); if (CurrentMacdValue > 2) { //EVAL: questo è un rafforzativo, quindi mi aspetto un grande ribasso E.Add(N("--(rocdiff;Macd122609)"), CreatePrediction(now, TradeAction.StrongSell), timeUnit); //return TradeAction.StrongSell; } } if (Rocdiff < -roclimit && currentTrend == TechnicalAnalysis.Trend.Raise) { //LogTrade.Note = "inversione: comprare"; //EVAL: se dico di comprare, vuol dire che il prezzo salirà, anche di poco E.Add(N("+(rocdiff;rocspeed)"), CreatePrediction(now, TradeAction.Buy), timeUnit); if (CurrentMacdValue < -2) { //EVAL: questo è un rafforzativo, quindi mi aspetto un grande rialzo E.Add(N("++(rocdiff;rocspeed;Macd122609)"), CreatePrediction(now, TradeAction.StrongBuy), timeUnit); // return TradeAction.StrongBuy; } } /******************************************************************************** * ALLARMI ********************************************************************************/ var emadiffValue = EmaDiff.CurrentValue; //EmaDiff.Calculate(); // potrebbe essere inutile (lo abbiamo già) var macdValue = this.CurrentMacdValue; // potrebbe essere inutile (lo abbiamo già) //var roclimit = 5.0M; if (Math.Sign(emadiffValue) == Math.Sign(macdValue)) { var limit = MainConfiguration.Configuration.AlarmStrongSellBuyLimit; // occorre capire che valori sono i migliori if ((emadiffValue < -limit && macdValue < -limit)) { //LogTrade.Note = ("suggestion: (emadiffValue < -limit && macdValue < -limit)"); // AnalyticsTools.Call("ema;macd;limit;-"); //return TradeAction.StrongSell; //EVAL: E.Add(N("--(ema;macd;limit;)"), CreatePrediction(now, TradeAction.StrongSell), timeUnit); } if (emadiffValue > limit && macdValue > limit) { //LogTrade.Note = ("suggestion: (emadiffValue > limit && macdValue > limit)"); // AnalyticsTools.Call("ema;macd;limit;+"); // return TradeAction.StrongBuy; //EVAL: E.Add(N("++(ema;macd;limit;)"), CreatePrediction(now, TradeAction.StrongBuy), timeUnit); } if (emadiffValue < -1 && macdValue < -1) { //LogTrade.Note = ("suggestion: (emadiffValue < -1 && macdValue < -1)"); // AnalyticsTools.Call("ema;macd;-1"); // return TradeAction.Sell; //EVAL: E.Add(N("-(ema;macd;-1;)"), CreatePrediction(now, TradeAction.Sell), timeUnit); } if (emadiffValue > 1 && macdValue > 1) { // AnalyticsTools.Call("ema;macd;+1"); //LogTrade.Note = ("suggestion: (emadiffValue > 1 && macdValue > 1)"); //return TradeAction.Buy; //EVAL: E.Add(N("+(ema;macd;+1;)"), CreatePrediction(now, TradeAction.Buy), timeUnit); } } var poll = new Poll(); /******************************************************************************** * MACD ********************************************************************************/ //foreach (MacdItem item in this.MacdList) { poll.Add(Macd122609.SuggestedAction(CurrentMacdValue, currentTrend)); CUtility.Log(string.Format("MACD {0}", Math.Round(CurrentMacdValue, 4).ToString(CultureInfo.InvariantCulture))); } /******************************************************************************** * EMADIFF ********************************************************************************/ var emadiffSuggestion = EmaDiff.SuggestedAction(CurrentEmaDiff, currentTrend); poll.Add(emadiffSuggestion); CUtility.Log(string.Format("EMADIFF {0}", Math.Round(CurrentEmaDiff, 4).ToString(CultureInfo.InvariantCulture))); /******************************************************************************** * DECISION ********************************************************************************/ //LogTrade.Note = "poll"; var result = poll.Result(); if (true) { // questo sistema di sicurezza non genera troppi problemi, ma non aumenta il reddito // pero' aumenta la media dei redditi // sistema di sicurezza da testare const decimal securitylimit = 1.5M; // va bene cosi' if (result == TradeAction.Buy && market.Buy >= securitylimit * LogTrade.BuyAt && LogTrade.BuyAt > 0 && currentTrend == TechnicalAnalysis.Trend.Raise) { // AnalyticsTools.Call("expensive"); // return TradeAction.Hold; //EVAL: in realtà, "expensive" scommette sul fatto che può comprare a meno E.Add(N("expensive"), new Evaluations.Prediction() { Date = now, Type = Evaluations.PredictionType.LessThan, Value = this.CoinValue * (1 - 0.01M) }, timeUnit); } if (result == TradeAction.Sell && market.Sell <= securitylimit * LogTrade.SellAt && LogTrade.SellAt > 0 && currentTrend == TechnicalAnalysis.Trend.Fall) { // AnalyticsTools.Call("cheap"); // return TradeAction.Hold; //EVAL: in realtà, "cheap" scommette sul fatto che può vendere a più E.Add(N("cheap"), new Evaluations.Prediction() { Date = now, Type = Evaluations.PredictionType.GreatherThan, Value = this.CoinValue * (1 + 0.01M) }, timeUnit); } } if (result != TradeAction.Hold) { // AnalyticsTools.Call("poll " + result.ToString()); } //return result; //EVAL: globale, ovvero cosa fa l'algoritmo // E.Add("GLOBAL", CreatePrediction(now, result), timeUnit); return(TradeAction.Unknown); } }
public override void Run() { var tests = new List <TestUnit>(); var testResultFileName = @"data\output\results" + DateTime.Now.ToString("yyyyMMddhhmmss") + ".csv"; //TODO: caricare da configurazioni var testLoad = GetTestData(); //List<TestParam> testLoad = null; if (testLoad == null || testLoad.Count == 0) { testLoad = new List <TestParam>() { new TestParam(0, 0, 0, 0) }; } var e = Evaluations.EvaluationManager.Instance; foreach (var testParam in testLoad) { e.Clear(); /******************************************************************** * CONFIGURAZIONE *******************************************************************/ //MainConfiguration.Configuration = new Configuration(); //configuration; // MainConfiguration.Configuration = Configuration.BuildFromFile("global.json", "personal.json"); MainConfiguration.Configuration = Configuration.BuildFromDirectory(@"data/configuration"); MainConfiguration.Configuration.Init(); Configuration.SaveToFile(MainConfiguration.Configuration, @"data/configuration/serialized.result.json"); // chiama la configurazione Customize(testParam); /******************************************************************** * MANAGER *******************************************************************/ var manager = Manager.Builder.Create(MainConfiguration.Configuration.ManagerClass); if (manager == null) { throw new Exception("manager not configured"); } manager.Start(); if (MainConfiguration.Configuration.RealTimeHeartBeat && testLoad.Count == 1) { break; } System.Console.WriteLine(manager.Market.UniqueName); // salvo il risultato var test = new TestUnit() { Coins = manager.Market.TotCoins, Money = manager.Market.TotMoney, Coinvalue = manager.Market.Buy, Value = manager.Market.TotValue, Average = manager.Market.Average, MaxCoins = manager.Market.MaxCoins, MaxMoney = manager.Market.MaxMoney, MaxValue = manager.Market.MaxValue, Bids = manager.Market.TotBids, Ask = manager.Market.TotAsks, Gain = manager.Statistics.Gain, i = testParam.I, j = testParam.J, w = testParam.W, k = testParam.K }; /******************************************************************** * VISUALIZZAZIONE *******************************************************************/ // stampa il risultato test.Print(); if (test.Average > MainConfiguration.Configuration.StartWalletMoney) // deve esserci stato almeno un trade { if (test.Value > MainConfiguration.Configuration.StartWalletMoney) // devo aver guadagnato piu' di quanto ho investito { // salva il risultato se ci sono stati risultati incoraggianti CUtility.Log("*** GOOD"); tests.Add(test); /* * // scrive il risultato su csv * using (var log = new StreamWriter(testResultFileName, true)) * { * test.Print(log); * log.Flush(); * log.Close(); * } * */ // scrive il risultato con codice using (var log = new StreamWriter(testResultFileName + ".txt", true)) { test.PrintCode(log); log.Flush(); log.Close(); } // salvo la migliore configurazione var best = tests.OrderByDescending(o => o.Coins * o.Coinvalue + o.Money).FirstOrDefault(); if (best != null) { Configuration.SaveToFile(MainConfiguration.Configuration, @"data/configuration/best.result.json"); } var bestAvg = tests.OrderByDescending(o => o.Average).FirstOrDefault(); if (bestAvg != null) { Configuration.SaveToFile(MainConfiguration.Configuration, @"data/configuration/bestavg.result.json"); } } } AnalyticsTools.Print(); e.Finalize(); } /******************************************************************** * RISULTATI *******************************************************************/ if (MainConfiguration.Configuration.RealTimeHeartBeat && testLoad.Count == 1) { } else { // mostro la performance migliore CUtility.Log("*** BEST VALUE"); var firstOrDefault = tests.OrderByDescending(o => o.Coins * o.Coinvalue + o.Money).FirstOrDefault(); if (firstOrDefault != null) { firstOrDefault.Print(); } CUtility.Log("*** BEST AVERAGE"); var orDefault = tests.OrderByDescending(o => o.Average).FirstOrDefault(); if (orDefault != null) { orDefault.Print(); } } }