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)); }
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; } }
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); }
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(); }
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); }
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; }
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); }
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; }
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); }
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); }
internal void ShrinkByStepQuick(NumericRangeInfo range, DoubleR10 step) { this.Minimum = this.Minimum.IncrementByStep(range.Minimum, step); this.Maximum = this.Maximum.DecrementByStep(range.Maximum, step); }