Esempio n. 1
0
        public double CalculateEquityUtilization(ITradingObject tradingObject)
        {
            var boardIndexTradingObject = _context.GetBoardIndexTradingObject(tradingObject);

            if (boardIndexTradingObject == null)
            {
                return(1.0);
            }

            var ma10values = _ma10.GetMetricValues(boardIndexTradingObject);

            if (ma10values == null)
            {
                // the board index value is not ready yet, back off to main board index
                boardIndexTradingObject = _context.GetBoardIndexTradingObject(StockBoard.MainBoard);
            }

            var closeValue = _close.GetMetricValues(boardIndexTradingObject)[0];
            var ma5Value   = _ma5.GetMetricValues(boardIndexTradingObject)[0];
            var ma10Value  = _ma10.GetMetricValues(boardIndexTradingObject)[0];
            var ma20Value  = _ma20.GetMetricValues(boardIndexTradingObject)[0];
            var ma60Value  = _ma60.GetMetricValues(boardIndexTradingObject)[0];

            if (ma5Value < ma20Value)
            {
                // descending trends
                if (closeValue < ma5Value)
                {
                    return(0.0);
                }
                else if (closeValue >= ma5Value && closeValue < ma20Value)
                {
                    return(0.15);
                }
                else if (closeValue >= ma20Value)
                {
                    return(0.3);
                }
            }
            else
            {
                // ascending trends
                if (closeValue >= ma5Value)
                {
                    return(1.0);
                }
                else if (closeValue >= ma20Value && closeValue < ma5Value)
                {
                    return(0.7);
                }
                else if (closeValue < ma20Value)
                {
                    return(0.5);
                }
            }

            return(0.0);
        }
        public double[] GetValues(ITradingObject tradingObject)
        {
            ITradingObject trueObject = IsBoardIndexMetric ? _context.GetBoardIndexTradingObject(tradingObject) : tradingObject;

            var values = Proxy.GetMetricValues(trueObject);

            if (values == null)
            {
                if (!object.ReferenceEquals(trueObject, tradingObject))
                {
                    trueObject = _context.GetBoardIndexTradingObject(StockBoard.MainBoard);
                    values     = Proxy.GetMetricValues(trueObject);
                }
            }

            return(values);
        }
Esempio n. 3
0
        public double CalculateEquityUtilization(ITradingObject tradingObject)
        {
            var boardIndexTradingObject = _context.GetBoardIndexTradingObject(tradingObject);

            if (boardIndexTradingObject == null)
            {
                return(1.0);
            }

            var maValues = _ma.GetMetricValues(boardIndexTradingObject);

            if (maValues == null)
            {
                // the board index value is not ready yet, back off to main board index
                boardIndexTradingObject = _context.GetBoardIndexTradingObject(StockBoard.MainBoard);
            }

            var closeValue = _close.GetMetricValues(boardIndexTradingObject)[0];
            var maValue    = _ma.GetMetricValues(boardIndexTradingObject)[0];

            var percentage = closeValue / maValue;

            double utilization;

            //if (percentage > 1.1)
            //{
            //    utilization = 1.0 - (percentage - 1.1) * 2.0;
            //}
            //else if (percentage < 0.9)
            //{
            //    utilization = 1.0;
            //}
            //else
            //{
            //    utilization = 0.7;
            //}

            utilization = 1.0;
            return(Math.Max(Math.Min(utilization, 1.0), 0.1));

            //var utilization = NormalDistribution(1.0, 0.1, percentage) / _normalDistribution0;

            //return Math.Max(utilization, 0.1);
        }
Esempio n. 4
0
        public void Dump(ITradingObject tradingObject)
        {
            if (tradingObject == null)
            {
                throw new ArgumentNullException();
            }

            var bars       = _provider.GetAllBarsForTradingObject(tradingObject.Index);
            var currentBar = _context.GetBarOfTradingObjectForCurrentPeriod(tradingObject);

            int index = FindIndexOfBar(bars, currentBar);

            if (index < 0)
            {
                throw new InvalidOperationException("Logic error");
            }

            var sequence = new List <Bar>(_numberOfBarsToDump);

            int actualIndexToStartWith;

            if (index < _numberOfBarsBacktrace)
            {
                for (int i = 0; i < _numberOfBarsBacktrace - index; ++i)
                {
                    sequence.Add(Bar.DefaultValue);
                }

                actualIndexToStartWith = 0;
            }
            else
            {
                actualIndexToStartWith = index - _numberOfBarsBacktrace;
            }

            index = actualIndexToStartWith;
            while (index < bars.Length && sequence.Count < _numberOfBarsToDump)
            {
                var bar = bars[index];

                if (bar.Time != Bar.InvalidTime)
                {
                    sequence.Add(bar);
                }

                ++index;
            }

            while (sequence.Count < _numberOfBarsToDump)
            {
                sequence.Add(Bar.DefaultValue);
            }

            foreach (var bar in sequence)
            {
                // Time, O, H, L, C
                _writer.Write(
                    "{4:yyyy-MM-dd},{0:0.000},{1:0.000},{2:0.000},{3:0.000},",
                    bar.OpenPrice,
                    bar.HighestPrice,
                    bar.LowestPrice,
                    bar.ClosePrice,
                    bar.Time);
            }

            // dump metrics
            if (_metricProxies != null)
            {
                for (int j = 0; j < _metricProxies.Length; ++j)
                {
                    ITradingObject trueObject = _forBoardIndex[j] ? _context.GetBoardIndexTradingObject(tradingObject) : tradingObject;

                    double value = 0.0;

                    var values = _metricProxies[j].GetMetricValues(trueObject);
                    if (values == null)
                    {
                        if (!object.ReferenceEquals(trueObject, tradingObject))
                        {
                            trueObject = _context.GetBoardIndexTradingObject(StockBoard.MainBoard);
                            values     = _metricProxies[j].GetMetricValues(trueObject);
                        }
                    }

                    if (values == null)
                    {
                        value = 0.0;
                    }
                    else
                    {
                        value = values[0];
                    }

                    _writer.Write("{0:0.0000},", value);
                }
            }

            _writer.WriteLine();
        }