Esempio n. 1
0
        private IEnumerable <ScalePosition> Project(IList <Category> categories, ScaleElementDefinition element, CategoryScaleUnit defaultUnit)
        {
            this.RecalculateIfEmpty();
            double?interval1 = Scale <double, double, CategoryScaleUnit> .GetInterval(element);

            double?intervalOffset = Scale <double, double, CategoryScaleUnit> .GetIntervalOffset(element);

            CategoryScaleUnit?intervalUnit = Scale <double, double, CategoryScaleUnit> .GetIntervalUnit(element);

            double            interval2         = interval1.HasValue ? interval1.Value : 1.0;
            double            num1              = intervalOffset.HasValue ? intervalOffset.Value : 0.0;
            CategoryScaleUnit categoryScaleUnit = intervalUnit.HasValue ? intervalUnit.Value : defaultUnit;
            double            num2              = defaultUnit == CategoryScaleUnit.MinorInterval ? 0.5 : 0.0;
            NumericSequence   numericSequence   = defaultUnit == CategoryScaleUnit.MinorInterval ? this._minorSequence : this._majorSequence;
            NumericSequence   sequence          = (NumericSequence)null;
            NumericRangeInfo  range             = new NumericRangeInfo((DoubleR10)this.ActualMinimum, (DoubleR10)this.ActualMaximum);

            switch (categoryScaleUnit)
            {
            case CategoryScaleUnit.Index:
                sequence = interval2 != this.ActualMajorInterval || num1 != this.ActualMinorIntervalOffset ? NumericSequence.Calculate(range, new double?(interval2), new double?(num1 + num2), 100, int.MinValue, (DoubleR10[])null, true, 1.0) : numericSequence;
                break;

            case CategoryScaleUnit.MajorInterval:
                sequence = interval2 != this.ActualMajorInterval || num1 != this.ActualMajorIntervalOffset ? (NumericSequence)RelativeSequence.Calculate(this._majorSequence, new double?(interval2), new double?(num1), 1.0) : this._majorSequence;
                break;

            case CategoryScaleUnit.MinorInterval:
                sequence = interval2 != this.ActualMinorInterval || num1 != this.ActualMinorIntervalOffset ? (NumericSequence)RelativeSequence.Calculate(this._minorSequence, new double?(interval2), new double?(num1 + 0.5), 1.0) : this._minorSequence;
                break;
            }
            return(this.Project(categories, sequence, interval2));
        }
Esempio n. 2
0
 internal void ShrinkByStep(NumericRangeInfo range, DoubleR10 step, bool useZeroRefPoint)
 {
     if (this.Minimum == 0 && this.Maximum == 0)
         this.Maximum = (DoubleR10)1;
     else if (this.Minimum < 0 && this.Maximum <= 0)
     {
         this.Maximum = this.Maximum.DecrementByStep(range.Maximum, step);
         this.Minimum = this.Maximum.DecrementByStep(range.Minimum, step);
         if (!(this.Minimum == this.Maximum))
             return;
         this.Minimum = this.Minimum - step;
     }
     else if (this.Minimum >= 0 && this.Maximum > 0 || !useZeroRefPoint)
     {
         this.Minimum = this.Minimum.IncrementByStep(range.Minimum, step);
         this.Maximum = this.Minimum.IncrementByStep(range.Maximum, step);
         if (!(this.Minimum == this.Maximum))
             return;
         this.Maximum = this.Maximum + step;
     }
     else
     {
         this.Minimum = (DoubleR10)0;
         this.Maximum = (DoubleR10)0;
         this.Minimum = this.Minimum.DecrementByStep(range.Minimum, step);
         if (this.Minimum == this.Maximum)
             this.Minimum = this.Minimum - step;
         this.Maximum = this.Maximum.IncrementByStep(range.Maximum, step);
         if (!(this.Minimum == this.Maximum))
             return;
         this.Maximum = this.Maximum + step;
     }
 }
Esempio n. 3
0
        private static long GetCount(NumericRangeInfo range, NumericRangeInfo roundRange, DoubleR10 step, bool canExtendMin, bool canExtendMax, double maxAllowedMargin, long maxCount)
        {
            long num = DoubleR10.CountSteps(roundRange.Size, step);

            if (maxCount < num && num < maxCount + 3L)
            {
                num = NumericSequence.GetExactCount(range, roundRange, step, canExtendMin, canExtendMax, maxAllowedMargin);
            }
            return(num);
        }
Esempio n. 4
0
        public override void Recalculate()
        {
            this.CalculateActualProperties();
            this.RealizeCategories();
            NumericRangeInfo range = new NumericRangeInfo((DoubleR10)this.ActualViewMinimum, (DoubleR10)this.ActualViewMaximum);

            this._majorSequence = NumericSequence.Calculate(range, new double?(this.ActualMajorInterval), new double?(this.ActualMajorIntervalOffset), 1000, int.MinValue, (DoubleR10[])null, true, 1.0);
            this._minorSequence = NumericSequence.Calculate(range, new double?(this.ActualMinorInterval), new double?(this.ActualMinorIntervalOffset + 0.5), 1000, int.MinValue, (DoubleR10[])null, true, 1.0);
            base.Recalculate();
        }
Esempio n. 5
0
        private void CalculateRangeInfo()
        {
            this.ActualIncludeZero = ValueHelper.ToBoolean(this.IncludeZero, ValueHelper.ToBoolean(this.Defaults.IncludeZero, false));
            this.ActualMaxMargin   = this.GetMaxAllowedMargin(this.MaxCount);
            Range <double>?dataRange     = RangeHelper.Add <double>(this.ActualDataRange, this.CrossingPosition);
            double?        viewMinimum   = this.ViewMinimum;
            double?        minimum       = viewMinimum.HasValue ? new double?(viewMinimum.GetValueOrDefault()) : this.Minimum;
            double?        viewMaximum   = this.ViewMaximum;
            double?        maximum       = viewMaximum.HasValue ? new double?(viewMaximum.GetValueOrDefault()) : this.Maximum;
            int            num           = this.ActualIncludeZero ? 1 : 0;
            double?        majorInterval = this.MajorInterval;
            double?        interval      = majorInterval.HasValue ? new double?(majorInterval.GetValueOrDefault()) : this.MinorInterval;

            this._rangeInfo = NumericRangeInfo.Calculate(dataRange, minimum, maximum, num != 0, interval);
        }
Esempio n. 6
0
 public static NumericRangeInfo Calculate(Range<double>? dataRange, double? minimum, double? maximum, bool includeZero, double? interval = null)
 {
     NumericRangeInfo numericRangeInfo = new NumericRangeInfo();
     numericRangeInfo.HasDataRange = dataRange.HasValue && dataRange.Value.HasData;
     numericRangeInfo.HasMin = minimum.HasValue;
     numericRangeInfo.HasMax = maximum.HasValue;
     double num1 = numericRangeInfo.HasDataRange ? dataRange.Value.Minimum : double.MaxValue;
     double num2 = numericRangeInfo.HasDataRange ? dataRange.Value.Maximum : double.MinValue;
     double num3 = numericRangeInfo.HasMin ? minimum.Value : double.MaxValue;
     double num4 = numericRangeInfo.HasMax ? maximum.Value : double.MinValue;
     if (numericRangeInfo.HasMin && numericRangeInfo.HasMax)
     {
         numericRangeInfo.Minimum = (DoubleR10)num3;
         numericRangeInfo.Maximum = (DoubleR10)num4;
     }
     else if (numericRangeInfo.HasMin)
     {
         numericRangeInfo.Minimum = numericRangeInfo.Maximum = (DoubleR10)num3;
         if (num3 <= num2)
             numericRangeInfo.Maximum = (DoubleR10)num2;
     }
     else if (numericRangeInfo.HasMax)
     {
         numericRangeInfo.Minimum = numericRangeInfo.Maximum = (DoubleR10)num4;
         if (num4 >= num1)
             numericRangeInfo.Minimum = (DoubleR10)num1;
     }
     else if (numericRangeInfo.HasDataRange)
     {
         numericRangeInfo.Minimum = (DoubleR10)num1;
         numericRangeInfo.Maximum = (DoubleR10)num2;
     }
     else
         numericRangeInfo.Minimum = numericRangeInfo.Maximum = (DoubleR10)0;
     if (includeZero)
         numericRangeInfo.IncludeZero();
     numericRangeInfo.FixIfEmpty(interval, includeZero);
     numericRangeInfo.FixDirection();
     if (includeZero)
     {
         if (numericRangeInfo.Minimum == 0)
             numericRangeInfo.HasMin = true;
         if (numericRangeInfo.Maximum == 0)
             numericRangeInfo.HasMax = true;
     }
     return numericRangeInfo;
 }
Esempio n. 7
0
 public static NumericRangeInfo Calculate(Range<double>? dataRange, double? minimum, double? maximum, bool includeZero, double? interval = null)
 {
     NumericRangeInfo numericRangeInfo = new NumericRangeInfo();
     numericRangeInfo.HasDataRange = dataRange.HasValue && dataRange.Value.HasData;
     numericRangeInfo.HasMin = minimum.HasValue;
     numericRangeInfo.HasMax = maximum.HasValue;
     double num1 = numericRangeInfo.HasDataRange ? dataRange.Value.Minimum : double.MaxValue;
     double num2 = numericRangeInfo.HasDataRange ? dataRange.Value.Maximum : double.MinValue;
     double num3 = numericRangeInfo.HasMin ? minimum.Value : double.MaxValue;
     double num4 = numericRangeInfo.HasMax ? maximum.Value : double.MinValue;
     if (numericRangeInfo.HasMin && numericRangeInfo.HasMax)
     {
         numericRangeInfo.Minimum = (DoubleR10)num3;
         numericRangeInfo.Maximum = (DoubleR10)num4;
     }
     else if (numericRangeInfo.HasMin)
     {
         numericRangeInfo.Minimum = numericRangeInfo.Maximum = (DoubleR10)num3;
         if (num3 <= num2)
             numericRangeInfo.Maximum = (DoubleR10)num2;
     }
     else if (numericRangeInfo.HasMax)
     {
         numericRangeInfo.Minimum = numericRangeInfo.Maximum = (DoubleR10)num4;
         if (num4 >= num1)
             numericRangeInfo.Minimum = (DoubleR10)num1;
     }
     else if (numericRangeInfo.HasDataRange)
     {
         numericRangeInfo.Minimum = (DoubleR10)num1;
         numericRangeInfo.Maximum = (DoubleR10)num2;
     }
     else
         numericRangeInfo.Minimum = numericRangeInfo.Maximum = (DoubleR10)0;
     if (includeZero)
         numericRangeInfo.IncludeZero();
     numericRangeInfo.FixIfEmpty(interval, includeZero);
     numericRangeInfo.FixDirection();
     if (includeZero)
     {
         if (numericRangeInfo.Minimum == 0)
             numericRangeInfo.HasMin = true;
         if (numericRangeInfo.Maximum == 0)
             numericRangeInfo.HasMax = true;
     }
     return numericRangeInfo;
 }
Esempio n. 8
0
        private static long GetExactCount(NumericRangeInfo range, NumericRangeInfo roundRange, DoubleR10 step, bool canExtendMin, bool canExtendMax, double maxAllowedMargin)
        {
            long      num       = 0L;
            DoubleR10 min1      = NumericSequence.GetMin(range.Minimum, roundRange.Minimum, step, canExtendMin, (DoubleR10)maxAllowedMargin);
            DoubleR10 min2      = NumericSequence.GetMin(range.Maximum, roundRange.Maximum, step, canExtendMax, (DoubleR10)maxAllowedMargin);
            DoubleR10 doubleR10 = roundRange.Minimum;

            while (doubleR10 < roundRange.Maximum)
            {
                if (min1 <= doubleR10 && doubleR10 <= min2)
                {
                    ++num;
                }
                doubleR10 += step;
            }
            return(num - 1L);
        }
Esempio n. 9
0
 private void FixDoubleOverflow(NumericRangeInfo range)
 {
     if (this._interval > NumericSequence.MaxGoodLookingDouble)
     {
         this._interval = NumericSequence.MaxGoodLookingDouble;
         if (this._min.IsDoubleInfinity())
         {
             this._min = -NumericSequence.MaxGoodLookingDouble;
         }
     }
     else if (this._min.IsDoubleInfinity())
     {
         this._min = this._min + this._interval;
     }
     if (!this._max.IsDoubleInfinity())
     {
         return;
     }
     this._max = range.Maximum;
 }
Esempio n. 10
0
        public static DateTimeSequence CalculateCenturies(Range <DateTime> range, int?interval, int?intervalOffset, int maxCount)
        {
            NumericRangeInfo range1 = new NumericRangeInfo((DoubleR10)range.Minimum.Year, (DoubleR10)range.Maximum.Year);
            int?   nullable1        = interval;
            double?interval1        = nullable1.HasValue ? new double?((double)nullable1.GetValueOrDefault()) : new double?();
            int?   nullable2        = intervalOffset;
            double?intervalOffset1  = nullable2.HasValue ? new double?((double)nullable2.GetValueOrDefault()) : new double?();
            int    maxCount1        = maxCount;
            int    minPower         = 2;

            DoubleR10[] steps = new DoubleR10[3]
            {
                (DoubleR10)1,
                (DoubleR10)2,
                (DoubleR10)5
            };
            int              num = 1;
            double           maxAllowedMargin = 1.0;
            NumericSequence  numericSequence  = NumericSequence.Calculate(range1, interval1, intervalOffset1, maxCount1, minPower, steps, num != 0, maxAllowedMargin);
            DateTimeSequence dateTimeSequence = new DateTimeSequence(DateTimeScaleUnit.Years);

            try
            {
                foreach (DoubleR10 doubleR10 in numericSequence)
                {
                    int year = (int)doubleR10;
                    if (year > 0)
                    {
                        dateTimeSequence.Add(new DateTime(year, 1, 1));
                    }
                }
            }
            catch (ArgumentOutOfRangeException ex)
            {
            }
            dateTimeSequence.Interval       = numericSequence.Interval;
            dateTimeSequence.IntervalOffset = numericSequence.IntervalOffset;
            return(dateTimeSequence);
        }
Esempio n. 11
0
        public static NumericSequence Calculate(NumericRangeInfo range, double?interval = null, double?intervalOffset = null, int maxCount = 10, int minPower = -2147483648, DoubleR10[] steps = null, bool useZeroRefPoint = true, double maxAllowedMargin = 1.0)
        {
            NumericSequence numericSequence = new NumericSequence();

            if (steps == null)
            {
                steps = NumericSequence.DefaultGridSteps;
            }
            long num1 = 0L;

            numericSequence._maxAllowedMargin = (DoubleR10)maxAllowedMargin;
            if (range.ForsedSingleStop.HasValue)
            {
                DoubleR10 doubleR10 = range.ForsedSingleStop.Value;
                numericSequence._interval       = range.Maximum - range.Minimum;
                numericSequence._intervalOffset = doubleR10;
                numericSequence._min            = range.Minimum;
                numericSequence._max            = range.Maximum;
                numericSequence._sequence.Add(doubleR10);
                numericSequence.ExtendToCover(range.Minimum, range.Maximum);
                return(numericSequence);
            }
            numericSequence._interval       = interval.HasValue ? (DoubleR10)Math.Abs(interval.Value) : DoubleR10.Zero;
            numericSequence._intervalOffset = intervalOffset.HasValue ? (DoubleR10)intervalOffset.Value : DoubleR10.MinValue;
            numericSequence._min            = DoubleR10.Zero;
            numericSequence._max            = DoubleR10.Zero;
            maxCount = Math.Max(maxCount, 1);
            maxCount = Math.Min(maxCount, 1000);
            numericSequence._canExtendMin = maxAllowedMargin > 0.0 && range.HasDataRange && !range.HasMin && range.Minimum != 0;
            numericSequence._canExtendMax = maxAllowedMargin > 0.0 && range.HasDataRange && !range.HasMax && range.Maximum != 0;
            if (interval.HasValue && numericSequence._interval != 0 && intervalOffset.HasValue)
            {
                num1 = (long)(range.Size / numericSequence._interval);
                numericSequence._min = range.Minimum;
                numericSequence._max = range.Minimum + (DoubleR10)num1 * numericSequence._interval;
            }
            else
            {
                int num2 = !(numericSequence._interval != 0) ? (!(range.Size != 0) ? range.Maximum.Log10() : range.Size.Log10()) : numericSequence._interval.Log10() + 1;
                int num3 = steps[0].Log10();
                int num4 = num2 - num3 - 1 - ((DoubleR10)maxCount - (DoubleR10)1).Log10();
                if (minPower != int.MinValue)
                {
                    num4 = Math.Max(num4, minPower - num3);
                }
                if (numericSequence._interval != 0)
                {
                    NumericRangeInfo numericRangeInfo = new NumericRangeInfo(DoubleR10.Floor(range.Minimum, num4), DoubleR10.Ceiling(range.Maximum, num4));
                    numericRangeInfo.ShrinkByStep(range, numericSequence._interval, useZeroRefPoint);
                    numericSequence._min = numericRangeInfo.Minimum;
                    numericSequence._max = numericRangeInfo.Maximum;
                    num1 = DoubleR10.CountSteps(numericRangeInfo.Size, numericSequence._interval);
                }
                else
                {
                    for (int index1 = 0; index1 < 3; ++index1)
                    {
                        int       exp       = num4 + index1;
                        DoubleR10 doubleR10 = DoubleR10.Pow10(exp);
                        DoubleR10 minimum   = DoubleR10.Floor(range.Minimum, exp);
                        DoubleR10 maximum   = DoubleR10.Ceiling(range.Maximum, exp);
                        for (int index2 = 0; index2 < steps.Length; ++index2)
                        {
                            DoubleR10 step = steps[index2] * doubleR10;
                            step.Normalize();
                            NumericRangeInfo roundRange = new NumericRangeInfo(minimum, maximum);
                            if (steps == NumericSequence.DefaultGridSteps)
                            {
                                roundRange.ShrinkByStepQuick(range, step);
                            }
                            else
                            {
                                roundRange.ShrinkByStep(range, step, useZeroRefPoint);
                            }
                            if (numericSequence._canExtendMin && range.Minimum == roundRange.Minimum && maxAllowedMargin >= 1.0)
                            {
                                roundRange.Minimum -= step;
                            }
                            if (numericSequence._canExtendMax && range.Maximum == roundRange.Maximum && maxAllowedMargin >= 1.0)
                            {
                                roundRange.Maximum += step;
                            }
                            num1 = NumericSequence.GetCount(range, roundRange, step, numericSequence._canExtendMin, numericSequence._canExtendMin, maxAllowedMargin, (long)maxCount);
                            if (num1 <= (long)maxCount || index1 == 2 && index2 == steps.Length - 1)
                            {
                                numericSequence._interval = step;
                                numericSequence._min      = roundRange.Minimum;
                                numericSequence._max      = roundRange.Maximum;
                                break;
                            }
                        }
                        if (numericSequence._interval != 0)
                        {
                            break;
                        }
                    }
                }
            }
            if (num1 > (long)(maxCount * 32))
            {
                num1 = (long)(maxCount * 32);
                numericSequence._interval = numericSequence.Size / (DoubleR10)num1;
            }
            if (intervalOffset.HasValue)
            {
                numericSequence._intervalOffset = numericSequence._intervalOffset % numericSequence._interval;
                DoubleR10 doubleR10 = range.Minimum + numericSequence._intervalOffset - numericSequence._min;
                numericSequence._min = numericSequence._min + doubleR10;
                numericSequence._max = numericSequence._max + doubleR10;
            }
            else
            {
                numericSequence._intervalOffset = numericSequence._min - range.Minimum;
            }
            numericSequence.FixDoubleOverflow(range);
            numericSequence._sequence = (IList <DoubleR10>) new List <DoubleR10>();
            DoubleR10 doubleR10_1 = numericSequence._min;

            numericSequence._sequence.Add(doubleR10_1);
            for (int index = 0; (long)index < num1; ++index)
            {
                doubleR10_1 = doubleR10_1.Add(ref numericSequence._interval);
                if (!doubleR10_1.IsDoubleInfinity())
                {
                    numericSequence._sequence.Add(doubleR10_1);
                }
            }
            numericSequence.ExtendToCover(range.Minimum, range.Maximum);
            return(numericSequence);
        }
Esempio n. 12
0
 internal void ShrinkByStepQuick(NumericRangeInfo range, DoubleR10 step)
 {
     this.Minimum = this.Minimum.IncrementByStep(range.Minimum, step);
     this.Maximum = this.Maximum.DecrementByStep(range.Maximum, step);
 }
Esempio n. 13
0
 internal void ShrinkByStep(NumericRangeInfo range, DoubleR10 step, bool useZeroRefPoint)
 {
     if (this.Minimum == 0 && this.Maximum == 0)
         this.Maximum = (DoubleR10)1;
     else if (this.Minimum < 0 && this.Maximum <= 0)
     {
         this.Maximum = this.Maximum.DecrementByStep(range.Maximum, step);
         this.Minimum = this.Maximum.DecrementByStep(range.Minimum, step);
         if (!(this.Minimum == this.Maximum))
             return;
         this.Minimum = this.Minimum - step;
     }
     else if (this.Minimum >= 0 && this.Maximum > 0 || !useZeroRefPoint)
     {
         this.Minimum = this.Minimum.IncrementByStep(range.Minimum, step);
         this.Maximum = this.Minimum.IncrementByStep(range.Maximum, step);
         if (!(this.Minimum == this.Maximum))
             return;
         this.Maximum = this.Maximum + step;
     }
     else
     {
         this.Minimum = (DoubleR10)0;
         this.Maximum = (DoubleR10)0;
         this.Minimum = this.Minimum.DecrementByStep(range.Minimum, step);
         if (this.Minimum == this.Maximum)
             this.Minimum = this.Minimum - step;
         this.Maximum = this.Maximum.IncrementByStep(range.Maximum, step);
         if (!(this.Minimum == this.Maximum))
             return;
         this.Maximum = this.Maximum + step;
     }
 }
Esempio n. 14
0
 internal void ShrinkByStepQuick(NumericRangeInfo range, DoubleR10 step)
 {
     this.Minimum = this.Minimum.IncrementByStep(range.Minimum, step);
     this.Maximum = this.Maximum.DecrementByStep(range.Maximum, step);
 }