public static DateTimeSequence CalculateYears(Range <DateTime> range, int?interval, int?intervalOffset, int maxCount) { NumericSequence numericSequence = NumericSequence.CalculateUnits(range.Minimum.Year, range.Maximum.Year, interval, intervalOffset, new int[10] { 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000 }, maxCount); DateTimeSequence dateTimeSequence = new DateTimeSequence(DateTimeScaleUnit.Years); try { foreach (DoubleR10 doubleR10 in numericSequence) { int year = (int)doubleR10; if (year > 0 && year < 10000) { dateTimeSequence.Add(new DateTime(year, 1, 1)); } } } catch (ArgumentOutOfRangeException ex) { } dateTimeSequence.Interval = numericSequence.Interval; dateTimeSequence.IntervalOffset = numericSequence.IntervalOffset; return(dateTimeSequence); }
private NumericSequence CalculateElementSequence(ScaleElementDefinition element, NumericScaleUnit defaultUnit) { double?interval = Scale <double, double, NumericScaleUnit> .GetInterval(element); double?intervalOffset = Scale <double, double, NumericScaleUnit> .GetIntervalOffset(element); NumericScaleUnit?intervalUnit = Scale <double, double, NumericScaleUnit> .GetIntervalUnit(element); NumericScaleUnit numericScaleUnit = intervalUnit.HasValue ? intervalUnit.Value : defaultUnit; int?maxCount1 = Scale <double, double, NumericScaleUnit> .GetMaxCount(element); int maxCount2 = maxCount1.HasValue ? maxCount1.Value : this.MaxCount; NumericSequence numericSequence = (NumericSequence)null; switch (numericScaleUnit) { case NumericScaleUnit.Number: numericSequence = NumericSequence.Calculate(new NumericRangeInfo((DoubleR10)this.ActualViewMinimum, (DoubleR10)this.ActualViewMaximum), interval, intervalOffset, maxCount2, int.MinValue, (DoubleR10[])null, true, 1.0); break; case NumericScaleUnit.MajorInterval: numericSequence = interval.HasValue || intervalOffset.HasValue ? (NumericSequence)RelativeSequence.Calculate(this._majorSequence, interval, intervalOffset, 1.0) : this._majorSequence; break; case NumericScaleUnit.MinorInterval: numericSequence = interval.HasValue || intervalOffset.HasValue ? (NumericSequence)RelativeSequence.Calculate(this._minorSequence, interval, intervalOffset, 1.0) : this._minorSequence; break; } return(numericSequence); }
private IEnumerable <ScalePosition> Project(IList <Category> categories, NumericSequence sequence, double interval) { this.RecalculateIfEmpty(); Range <double> fromRange = new Range <double>(this.ActualViewMinimum, this.ActualViewMaximum); Category category = (Category)null; foreach (DoubleR10 doubleR10 in sequence) { double x = (double)doubleR10; int index = (int)Math.Floor(x) - this._minLeafIndex; if (index >= 0 && index < categories.Count) { category = categories[index]; double bucketMinX = (double)(this._minLeafIndex + category.LeafIndexRange.Minimum); double bucketMaxX = (double)(this._minLeafIndex + category.LeafIndexRange.Maximum); yield return(new ScalePosition(category.Content, RangeHelper.Project(fromRange, x, Scale.PercentRange), RangeHelper.Project(fromRange, bucketMinX, Scale.PercentRange), RangeHelper.Project(fromRange, bucketMaxX, Scale.PercentRange))); } if (sequence == this._majorSequence && category != null && index == categories.Count) { double bucketMinX = Math.Floor(x); double bucketMaxX = bucketMinX; yield return(new ScalePosition(category.Content, RangeHelper.Project(fromRange, x, Scale.PercentRange), RangeHelper.Project(fromRange, bucketMinX, Scale.PercentRange), RangeHelper.Project(fromRange, bucketMaxX, Scale.PercentRange))); } } }
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)); }
public static DateTimeSequence CalculateMilliseconds(Range <DateTime> range, int?interval, int?intervalOffset, int maxCount) { DateTime dateTime = new DateTime(range.Minimum.Year, range.Minimum.Month, range.Minimum.Day, range.Minimum.Hour, range.Minimum.Minute, range.Minimum.Second); NumericSequence numericSequence = NumericSequence.CalculateUnits((int)Math.Floor(range.Minimum.Subtract(dateTime).TotalMilliseconds), (int)Math.Ceiling(range.Maximum.Subtract(dateTime).TotalMilliseconds), interval, intervalOffset, new int[10] { 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000 }, maxCount); DateTimeSequence dateTimeSequence = new DateTimeSequence(DateTimeScaleUnit.Milliseconds); try { foreach (DoubleR10 doubleR10 in numericSequence) { double num = (double)doubleR10; dateTimeSequence.Add(dateTime.AddMilliseconds(num)); } } catch (ArgumentOutOfRangeException ex) { } dateTimeSequence.Interval = numericSequence.Interval; dateTimeSequence.IntervalOffset = numericSequence.IntervalOffset; return(dateTimeSequence); }
public static DateTimeSequence CalculateHours(Range <DateTime> range, int?interval, int?intervalOffset, int maxCount) { DateTime dateTime = new DateTime(range.Minimum.Year, range.Minimum.Month, range.Minimum.Day, 0, 0, 0); NumericSequence numericSequence = NumericSequence.CalculateUnits((int)Math.Floor(range.Minimum.Subtract(dateTime).TotalHours), (int)Math.Ceiling(range.Maximum.Subtract(dateTime).TotalHours), interval, intervalOffset, new int[6] { 1, 2, 3, 6, 12, 24 }, maxCount); DateTimeSequence dateTimeSequence = new DateTimeSequence(DateTimeScaleUnit.Hours); try { foreach (DoubleR10 doubleR10 in numericSequence) { int num = (int)doubleR10; DateTime date = dateTime.AddHours((double)num); dateTimeSequence.Add(date); } } catch (ArgumentOutOfRangeException ex) { } dateTimeSequence.Interval = numericSequence.Interval; dateTimeSequence.IntervalOffset = numericSequence.IntervalOffset; return(dateTimeSequence); }
public static DateTimeSequence CalculateMonths(Range <DateTime> range, int?interval, int?intervalOffset, int maxCount) { DateTime dateTime = new DateTime(range.Minimum.Year, 1, 1); NumericSequence numericSequence = NumericSequence.CalculateUnits(range.Minimum.Month - 1, (range.Maximum.Year - dateTime.Year) * 12 + range.Maximum.Month - 1, interval, intervalOffset, new int[5] { 1, 2, 3, 6, 12 }, maxCount); DateTimeSequence dateTimeSequence = new DateTimeSequence(DateTimeScaleUnit.Months); try { foreach (DoubleR10 doubleR10 in numericSequence) { int months = (int)doubleR10; DateTime date = dateTime.AddMonths(months); dateTimeSequence.Add(date); } } catch (ArgumentOutOfRangeException ex) { } dateTimeSequence.Interval = numericSequence.Interval; dateTimeSequence.IntervalOffset = numericSequence.IntervalOffset; return(dateTimeSequence); }
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 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 RelativeSequence(NumericSequence baseSequence, double relativeInterval, double relativeIntervalOffset) { this._baseSequence = baseSequence; this.Interval = (DoubleR10)Math.Abs(relativeInterval); if (this.Interval == 0 || this.Interval.IsSpecial()) { this.Interval = (DoubleR10)0.5; } this.IntervalOffset = (DoubleR10)relativeIntervalOffset % this.Interval; this.Load(); }
private IEnumerable <ScalePosition> ProjectLabels(LabelDefinition element, NumericScaleUnit defaultUnit) { this.RecalculateIfEmpty(); NumericSequence sequence = this.CalculateElementSequence((ScaleElementDefinition)element, defaultUnit); Range <double> fromRange = new Range <double>(this.ActualViewMinimum, this.ActualViewMaximum); foreach (DoubleR10 doubleR10 in sequence) { double x = (double)doubleR10; yield return(new ScalePosition((object)x, RangeHelper.Project(fromRange, x, Scale.PercentRange))); } }
public static RelativeSequence Calculate(NumericSequence baseSequence, double?relativeInterval, double?relativeIntervalOffset, double defaultInterval) { double relativeInterval1 = relativeInterval.HasValue ? relativeInterval.Value : defaultInterval; if (relativeInterval1 == 0.0 || baseSequence.Size / (DoubleR10)relativeInterval1 > 5000 && relativeInterval1 < defaultInterval) { relativeInterval1 = defaultInterval; } double relativeIntervalOffset1 = relativeIntervalOffset.HasValue ? relativeIntervalOffset.Value : 0.0; return(new RelativeSequence(baseSequence, relativeInterval1, relativeIntervalOffset1)); }
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 CalculateMajorSequence(int maxCount, double maxAllowedMargin) { switch (this.ActualMajorIntervalUnit) { case NumericScaleUnit.Number: this._majorSequence = NumericSequence.Calculate(this._rangeInfo, this.MajorInterval, this.MajorIntervalOffset, maxCount, this.GetMinPower(), (DoubleR10[])null, true, maxAllowedMargin); break; case NumericScaleUnit.MajorInterval: this._majorSequence = NumericSequence.Calculate(this._rangeInfo, new double?(), new double?(), maxCount, int.MinValue, (DoubleR10[])null, true, 1.0); this._majorSequence = (NumericSequence)RelativeSequence.Calculate(this._majorSequence, this.MajorInterval, this.MajorIntervalOffset, 1.0); break; case NumericScaleUnit.MinorInterval: this._majorSequence = (NumericSequence)RelativeSequence.Calculate(this._minorSequence, this.MajorInterval, this.MajorIntervalOffset, 5.0); break; } }
public static DateTimeSequence CalculateWeeks(Range <DateTime> range, int?interval, int?intervalOffset, int maxCount, DayOfWeek firstDayOfWeek) { DateTime dateTime = new DateTime(range.Minimum.Year, range.Minimum.Month, range.Minimum.Day); while (dateTime.DayOfWeek != firstDayOfWeek) { dateTime = dateTime.AddDays(-1.0); } int num1 = (int)Math.Floor(range.Minimum.Subtract(dateTime).TotalDays); int num2 = (int)Math.Ceiling(range.Maximum.Subtract(dateTime).TotalDays); int min = num1; int max = num2; int?nullable = interval; int?interval1 = nullable.HasValue ? new int?(nullable.GetValueOrDefault() * 7) : new int?(); int?intervalOffset1 = intervalOffset; int[] steps = new int[2] { 7, 14 }; int maxCount1 = maxCount; NumericSequence numericSequence = NumericSequence.CalculateUnits(min, max, interval1, intervalOffset1, steps, maxCount1); DateTimeSequence dateTimeSequence = new DateTimeSequence(DateTimeScaleUnit.Weeks); try { foreach (DoubleR10 doubleR10 in numericSequence) { int num3 = (int)doubleR10; DateTime date = dateTime.AddDays((double)num3); dateTimeSequence.Add(date); } } catch (ArgumentOutOfRangeException ex) { } dateTimeSequence.Interval = numericSequence.Interval / (DoubleR10)7; dateTimeSequence.IntervalOffset = numericSequence.IntervalOffset / (DoubleR10)7; return(dateTimeSequence); }
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 CalculateUnits(int min, int max, int?interval, int?intervalOffset, int[] steps, int maxCount) { maxCount = Math.Max(maxCount, 1); maxCount = Math.Min(maxCount, 1000); if (min == max) { max = min + 1; } int num1 = max - min; int num2 = 0; int num3 = 0; if (interval.HasValue) { int?nullable1 = interval; if ((nullable1.GetValueOrDefault() != 0 ? 0 : (nullable1.HasValue ? 1 : 0)) == 0) { int num4 = num1; int?nullable2 = interval; int?nullable3 = nullable2.HasValue ? new int?(num4 / nullable2.GetValueOrDefault()) : new int?(); if ((nullable3.GetValueOrDefault() <= 1000 ? 0 : (nullable3.HasValue ? 1 : 0)) == 0) { num3 = interval.Value; num2 = num1 / num3; goto label_12; } } } for (int index = 0; index < steps.Length; ++index) { num3 = steps[index]; int num4 = num1 / num3; if (num1 % num3 != 0) { ++num4; } if (num4 <= maxCount) { break; } } label_12: int num5 = -min; if (intervalOffset.HasValue) { num5 += intervalOffset.Value; } int num6 = num5 % num3; NumericSequence numericSequence = new NumericSequence(); int num7 = min + num6; while (true) { numericSequence._sequence.Add((DoubleR10)num7); if (num7 < max) { num7 += num3; } else { break; } } numericSequence.Interval = (DoubleR10)num3; numericSequence.IntervalOffset = (DoubleR10)num6; numericSequence.Minimum = numericSequence._sequence[0]; numericSequence.Maximum = numericSequence._sequence[numericSequence._sequence.Count - 1]; numericSequence.ExtendToCover((DoubleR10)min, (DoubleR10)max); return(numericSequence); }
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); }