/// <summary>
        /// Gets the trend direction symbolic interpretation
        /// </summary>
        /// <param name="direction">The direction.</param>
        /// <returns></returns>
        public static string GetTrendDirectionSymbols(this measureTrendDirection direction)
        {
            // ▲▼▴▾○◦●■□
            string output = "";

            string left  = "";
            string right = "";

            if (direction.HasFlag(measureTrendDirection.macroStable))
            {
                left  += "-";
                right += "-";
            }

            if (direction.HasFlag(measureTrendDirection.microStable))
            {
                left  += "-";
                right += "-";
            }

            if (direction.HasFlag(measureTrendDirection.macroDown))
            {
                left += "<-";
            }
            if (direction.HasFlag(measureTrendDirection.microDown))
            {
                left += "<<";
            }

            if (direction.HasFlag(measureTrendDirection.microUp))
            {
                right += ">>";
            }
            if (direction.HasFlag(measureTrendDirection.macroUp))
            {
                right += "->";
            }

            output = left + "" + right;

            return(output);
        }
        /// <summary>
        /// Deploys the sample.
        /// </summary>
        /// <param name="samples">The samples.</param>
        protected void deploySample(IEnumerable <double> samples)
        {
            SampleState = trendTaker.GetSampleState(samples.Count());
            sampleSize  = samples.Count();
            sPeriod     = sampledPeriod.GetRatio(sampleSize);

            if (SampleState.HasFlag(measureTrendSampleState.macroMean))
            {
                var smp = samples.Take(trendTaker.MacroSampleSize);
                // Double smpMinutes = 0;

                // smpMinutes = sPeriod * smp.Count();

                if (trendTaker.IsTimeAverage)
                {
                    MacroMean = smp.Sum().GetRatio((sPeriod * trendTaker.MacroSampleSize)); //(sum.GetRatio(smp.Count())) / sPeriod;
                    MacroMin  = smp.Min() / sPeriod;
                    MacroMax  = smp.Max() / sPeriod;
                }
                else
                {
                    MacroMean = smp.Average();
                    MacroMin  = smp.Min();
                    MacroMax  = smp.Max();
                }
            }
            if (SampleState.HasFlag(measureTrendSampleState.microMean))
            {
                if (trendTaker.IsTimeAverage)
                {
                    MicroMean = samples.Take(trendTaker.MicroSampleSize).Sum().GetRatio((sPeriod * trendTaker.MicroSampleSize));
                }
                else
                {
                    MicroMean = samples.Take(trendTaker.MicroSampleSize).Average();
                }
            }
            if (SampleState.HasFlag(measureTrendSampleState.spearMean))
            {
                if (trendTaker.IsTimeAverage)
                {
                    SpearMean = samples.Take(trendTaker.SpearSampleSize).Sum().GetRatio((sPeriod * trendTaker.SpearSampleSize));
                }
                else
                {
                    SpearMean = samples.Take(trendTaker.SpearSampleSize).Average();
                }
            }

            if (SampleState.HasFlag(measureTrendSampleState.microMean))
            {
                MicroTrend = (MicroMean - SpearMean).GetRatio(MicroMean);

                Trend = MicroTrend - MicroMean;
            }

            if (SampleState.HasFlag(measureTrendSampleState.macroMean))
            {
                MacroTrend = (MacroMean - MicroMean).GetRatio(MacroMean);

                Trend = MacroTrend - MicroTrend;
            }

            measureTrendDirection __direction = measureTrendDirection.ready;

            if (Math.Abs(MicroTrend) <= trendTaker.ZeroMargin)
            {
                __direction |= measureTrendDirection.microStable;
            }
            else
            {
                if (MicroTrend > 0)
                {
                    __direction |= measureTrendDirection.microUp;
                }
                else
                {
                    __direction |= measureTrendDirection.microDown;
                }
            }

            if (Math.Abs(MacroTrend) <= trendTaker.ZeroMargin)
            {
                __direction |= measureTrendDirection.macroStable;
            }
            else
            {
                if (MicroTrend > 0)
                {
                    __direction |= measureTrendDirection.macroUp;
                }
                else
                {
                    __direction |= measureTrendDirection.macroDown;
                }
            }

            Direction = __direction;
        }