/// <summary>Uses Ruffini's rule</summary> public PolynomialEq EliminateRootNoRemainder(double root) { List<double> tempList = new List<double>(coefficients.Count); List<double> newCoef = new List<double>(coefficients.Count); //last guy is the remainder newCoef.Add(coefficients[0]); for (int i = 1; i < coefficients.Count - 1; i++) { tempList.Add( newCoef.Last()* root); newCoef.Add(coefficients[i] + tempList.Last()); } return new PolynomialEq(newCoef.ToArray()); }
public static Token TestForTokenInference(List<Token> tokens, Token tokenToAdd) { if (tokens.Count() > 0) { //When a minus or plus sign is read as a negative number, add a plus sign before the number //IE: 4 -5 becomes 4 + -5 TokenizerRules.CharInfo lastTknInfo = TokenizerRules.CharacterInfo.GetCharInfo(tokens.Last().TokenString); TokenizerRules.CharInfo currentTknInfo = TokenizerRules.CharacterInfo.GetCharInfo(tokenToAdd.TokenString); TokenizerRules.CharInfo lastCharInfo = TokenizerRules.CharacterInfo.GetCharInfo(tokenToAdd.TokenString[0].ToString()); if ((tokenToAdd.TokenType == TokenType.numberLiteral) && (tokens.Last().TokenType == TokenType.numberLiteral || (lastTknInfo != null && lastTknInfo.Type == TokenizerRules.CharType.closedBrace)) || ((Keywords.KeywordLookup.ContainsKey(tokens.Last().TokenString.ToLower()) && Keywords.KeywordLookup[tokens.Last().TokenString.ToLower()].TokenType == TokenType.numberLiteral) && (lastCharInfo != null && lastCharInfo.Type == TokenizerRules.CharType.plusMinus))) { return new Token("+", TokenType.operatorOrPunctuation); } //Infer a multiplication sign between two sets of parenthesis //IE: (3)(5) becomes (3)*(5) if ((TokenizerRules.CharacterInfo.ContainsKey(tokenToAdd.TokenString) && TokenizerRules.CharacterInfo.ContainsKey(tokens.Last().TokenString)) && TokenizerRules.CharacterInfo[tokenToAdd.TokenString].Type == TokenizerRules.CharType.openBrace && TokenizerRules.CharacterInfo[tokens.Last().TokenString].Type == TokenizerRules.CharType.closedBrace) { return new Token("*", TokenType.operatorOrPunctuation); } //Infer a multiplication sign between parenthesis and a number (that doesn't start with a minus sign) //IE: 3(4) becomes 3*(4) if (TokenizerRules.CharacterInfo.ContainsKey(tokenToAdd.TokenString) && TokenizerRules.CharacterInfo[tokenToAdd.TokenString].Type == TokenizerRules.CharType.openBrace && tokens.Last().TokenType == TokenType.numberLiteral) { return new Token("*", TokenType.operatorOrPunctuation); } //IE: (4)3 becomes (4)*3 if (TokenizerRules.CharacterInfo.ContainsKey(tokens.Last().TokenString) && tokenToAdd.TokenType == TokenType.numberLiteral && TokenizerRules.CharacterInfo[tokens.Last().TokenString].Type == TokenizerRules.CharType.closedBrace && tokenToAdd.TokenString[0] != '-') { return new Token("*", TokenType.operatorOrPunctuation); } } return null; }
private IEnumerable<RouteElement> GetRandomRoute( IRoadElement startElement ) { var result = new List<RouteElement> { new RouteElement { CanStopOnIt = true, PriorityType = PriorityType.None, RoadElement = startElement } }; result.AddRange( startElement.Routes.GetRandomRoute( this._rng ) ); while ( true ) { var nextRoute = result.Last().RoadElement.Routes.GetRandomRoute( this._rng ).ToArray(); if ( nextRoute.Length == 0 ) { break; } result.AddRange( nextRoute ); } return result; }
public FilesUploadResult LoadPostPictures(int id) { List<string> result = new List<string>(); UserDTO user = _userSvc.Get(id); string rootPath = HttpContext.Current.Request.MapPath("~/Temp/"); string userDirectoryPath = Path.Combine(rootPath, user.email); if (!Directory.Exists(userDirectoryPath)) { string standartImageDirectoryPath = Path.Combine(userDirectoryPath, "Standart"); string mediumImageDirectoryPath = Path.Combine(userDirectoryPath, "Medium"); string smallImageDirectoryPath = Path.Combine(userDirectoryPath, "Small"); Directory.CreateDirectory(userDirectoryPath); Directory.CreateDirectory(standartImageDirectoryPath); Directory.CreateDirectory(mediumImageDirectoryPath); Directory.CreateDirectory(smallImageDirectoryPath); } var httpRequest = HttpContext.Current.Request; if (httpRequest.Files.Count > 0) { FilesUploadResult res = new FilesUploadResult { }; foreach (string file in httpRequest.Files) { var postedFile = httpRequest.Files[file]; result.Add(Convert.ToString(Guid.NewGuid() + Path.GetExtension(postedFile.FileName))); var standartImagePath = HttpContext.Current.Server.MapPath("~/temp/" + user.email + "/Standart/" + result.Last()); var mediumImagePath = HttpContext.Current.Server.MapPath("~/temp/" + user.email + "/Medium/" + result.Last()); var smallImagePath = HttpContext.Current.Server.MapPath("~/temp/" + user.email + "/Small/" + result.Last()); postedFile.SaveAs(standartImagePath); PictureProvider.SaveMiniatureImage(standartImagePath, mediumImagePath, 200); PictureProvider.SaveMiniatureImage(standartImagePath, smallImagePath, 100); res.Files = new List<FileUploadResult> { new FileUploadResult { Name = postedFile.FileName, Size = postedFile.ContentLength, Url = "/temp/" + user.email + "/Standart/" + result.Last(), DeleteUrl = "http://test", DeleteType = "DELETE", ThumbnailUrl = "/temp/" + user.email + "/Medium/" + result.Last(), NewName = result.Last() } }; } return res; } else { throw new Exception(); } }
private double suggestSellPrice(List<Order> asks) { if (null == asks || !asks.Any()) { return _sellOrderPrice > 0.0 ? _sellOrderPrice : _minSellPrice; } const int DEC_PLACES = 14; double increment = 2.0 * _minPriceUpdate; //Find first ASK price higher than minPrice foreach (Order ask in asks) { //Don't consider own order if (ask.SequenceNumber == _sellOrderId) //TODO: this is a pure guess. In case orderbook bid/ask cannot be matched with my order, use old method (price and amount equality) { continue; } if (ask.Price >= _minSellPrice) { double sellPrice = Math.Round(ask.Price - increment, DEC_PLACES); //The difference is too small. Leave previous price to avoid server call if (-1 != _sellOrderId && Math.Abs(sellPrice - _sellOrderPrice) < _minPriceUpdate) { log(String.Format("DEBUG: SELL price {0:0.00000} too similar, using previous", sellPrice)); return _sellOrderPrice; } if (sellPrice > _maxSellPrice) { return _maxSellPrice; } return sellPrice; } } //Order book filled with junk. Use order before last, so we see it in chart double price = asks.Last().Price - increment; if (-1 != _sellOrderId && Math.Abs(price - _sellOrderPrice) < _minPriceUpdate) { return _sellOrderPrice; } return Math.Round(price, DEC_PLACES); }
private double suggestBuyPrice(List<Order> bids) { if (null == bids || !bids.Any()) { return _buyOrderPrice > 0.0 ? _buyOrderPrice : _maxBuyPrice; } const int DEC_PLACES = 14; double increment = 2.0 * _minPriceUpdate; //Find first BID price lower than max. price foreach (Order bid in bids) { //Don't consider own order if (bid.SequenceNumber == _sellOrderId) //TODO: this is a pure guess. In case orderbook bid/ask cannot be matched with my order, use old method (price and amount equality) { continue; } if (bid.Price <= _maxBuyPrice) { double buyPrice = Math.Round(bid.Price + increment, DEC_PLACES); //The difference is too small. Leave previous price to avoid server call if (-1 != _buyOrderId && Math.Abs(buyPrice - _buyOrderPrice) < _minPriceUpdate) { log(String.Format("DEBUG: BUY price {0:0.00000} too similar, using previous", buyPrice)); return _buyOrderPrice; } if (buyPrice > _maxBuyPrice) { return _maxBuyPrice; } return buyPrice; } } //Order book filled with junk. Use order before last, so we see it in chart double price = bids.Last().Price + increment; if (-1 != _buyOrderId && Math.Abs(price - _buyOrderPrice) < _minPriceUpdate) { return _buyOrderPrice; } return Math.Round(price, DEC_PLACES); }
/// <summary>There's a dump on market, best time to SELL.</summary> private static bool runningSelloff(List<TradeResponse> tradeHistory) { //There's lot of activity in recent time and price is falling const double PRICE_DIFF = 3 * 0.001; //0.3% var endTime = tradeHistory.Last().TimeTyped; var startTime = endTime.AddSeconds(-90); //Trades of past 90 seconds var pastTrades = tradeHistory.Where(trade => trade.TimeTyped >= startTime).ToList(); if (pastTrades.Count < 10) //TODO: tune up return false; var startPrice = pastTrades.First().price; var endPrice = pastTrades.Last().price; return (startPrice > endPrice && startPrice - endPrice >= startPrice * PRICE_DIFF); }
private double suggestPrice(List<FiatAsk> asks, double minPrice, double maxPrice, int currentOrderId, double currentOrderPrice, double minPriceUpdate) { if (null == asks || !asks.Any()) { return currentOrderPrice > 0.0 ? currentOrderPrice : minPrice; } const int DEC_PLACES = 14; double increment = 2.0 * minPriceUpdate; //Find first ASK price higher than minPrice foreach (FiatAsk ask in asks) { //Don't consider own order if (_config.AccessKey == ask.Account && ask.Sequence == currentOrderId) { continue; } if (ask.Price >= minPrice) { double sellPrice = Math.Round(ask.Price - increment, DEC_PLACES); //The difference is too small. Leave previous price to avoid server call if (-1 != currentOrderId && Math.Abs(sellPrice - currentOrderPrice) < minPriceUpdate) { log(String.Format("DEBUG: price {0:0.00000} too similar, using previous", sellPrice)); return currentOrderPrice; } if (sellPrice > maxPrice) { return maxPrice; } return sellPrice; } } //Order book filled with junk. Use order before last, so we see it in chart double price = asks.Last().Price - increment; if (-1 != currentOrderId && Math.Abs(price - currentOrderPrice) < minPriceUpdate) { return currentOrderPrice; } if (price < minPrice) { return minPrice; } return Math.Round(price, DEC_PLACES); }
private double suggestSellPrice(List<MarketOrder> asks) { if (null == asks || !asks.Any()) { return _sellOrderPrice > 0.0 ? _sellOrderPrice : _sellMinPrice; } const int DEC_PLACES = 14; double increment = 2.0 * _minPriceUpdate; //Find first ASK price higher than minPrice foreach (MarketOrder ask in asks) { //Don't consider own order if (ask.Amount.eq(_sellOrderAmount) && ask.Price.eq(_sellOrderPrice)) { continue; } if (ask.Price >= _sellMinPrice) { double sellPrice = Math.Round(ask.Price - increment, DEC_PLACES); //The difference is too small. Leave previous price to avoid server call if (-1 != _sellOrderId && Math.Abs(sellPrice - _sellOrderPrice) < _minPriceUpdate) { log($"DEBUG: price {sellPrice:0.#####} too similar, using previous"); return _sellOrderPrice; } if (sellPrice > _sellMaxPrice) { return _sellMaxPrice; } return sellPrice; } } //Order book filled with junk. Use order before last, so we see it in order book double price = asks.Last().Price - increment; if (-1 != _sellOrderId && Math.Abs(price - _sellOrderPrice) < _minPriceUpdate) { return _sellOrderPrice; } if (price < _sellMinPrice) { return _sellMinPrice; } return Math.Round(price, DEC_PLACES); }
private double suggestBuyPrice(List<MarketOrder> bids) { if (null == bids || !bids.Any()) { return _buyOrderPrice > 0.0 ? _buyOrderPrice : _buyMaxPrice; } const int DEC_PLACES = 14; double increment = 2.0 * _minPriceUpdate; //Find first BID price lower than maxPrice foreach (MarketOrder bid in bids) { //Don't consider own order if (bid.Amount.eq(_buyOrderAmount) && bid.Price.eq(_buyOrderPrice)) { continue; } if (bid.Price <= _buyMaxPrice) { double buyPrice = Math.Round(bid.Price + increment, DEC_PLACES); //The difference is too small. Leave previous buy price to avoid server call if (-1 != _buyOrderId && Math.Abs(buyPrice - _buyOrderPrice) < _minPriceUpdate) { log($"DEBUG: price {buyPrice:0.#####} too similar, using previous"); return _buyOrderPrice; } if (buyPrice < _buyMinPrice) { return _buyMinPrice; } return buyPrice; } } //Order book filled with junk. Use order before last, so we see it in order book double price = bids.Last().Price + increment; if (-1 != _buyOrderId && Math.Abs(price - _buyOrderPrice) < _minPriceUpdate) { return _buyOrderPrice; } if (price > _buyMaxPrice) { return _buyMaxPrice; } return Math.Round(price, DEC_PLACES); }
private bool isRising(List<Candle> candles) { const int MIN_CANDLES = 3; if (candles.Count < MIN_CANDLES) return false; candles = candles.TakeLast(MIN_CANDLES).ToList(); //Present candle is significant rise if (candles.Last().ClosingPrice > candles.Last().OpeningPrice + 3.0*PRICE_SIGNIFICANCE_LIMIT) return true; //Previous 2 candles were rises and latest price was rise too //TODO: maybe something more sofisticated return candles[0].ClosingPrice > candles[0].OpeningPrice + PRICE_SIGNIFICANCE_LIMIT && candles[1].ClosingPrice > candles[1].OpeningPrice + PRICE_SIGNIFICANCE_LIMIT && candles[1].ClosingPrice < candles.Last().ClosingPrice; //Most recent price decides }