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);
}
