public virtual double ConvertScaleToAxisUnits(double value, double axisLength)
{
value = RangeHelper.Project(AxisPresenter.DefaultScaleRange, value, this.ActualScaleRange);
if (this.ActualIsScaleReversed)
{
return(axisLength - axisLength * value);
}
return(axisLength * value);
}
public void NormalizeRange_ReturnsRangeWithNoChange()
{
// Arrange & Act
var normalizedRange = RangeHelper.NormalizeRange(new RangeItemHeaderValue(1, 3), 4);
// Assert
Assert.Equal(1, normalizedRange.From);
Assert.Equal(3, normalizedRange.To);
}
/// <summary>
/// Adds the period to an array of dates.
/// </summary>
/// <param name="baseDate">The base dates.</param>
/// <param name="dayType">The day type.</param>
/// <param name="periodArray">The period interval array.</param>
/// <param name="businessDayConvention">The business day convention.</param>
/// <param name="locationsAsArray">The calendars.</param>
/// <returns>A range of dates.</returns>
public object[,] AddManyPeriods2(DateTime baseDate, string dayType, Excel.Range periodArray, string businessDayConvention, Excel.Range locationsAsArray)
{
List <string> unqVals = DataRangeHelper.StripRange(locationsAsArray);
List <string> periodVals = DataRangeHelper.StripRange(periodArray);
List <DateTime> periods = CalendarService.AddPeriods(baseDate, dayType, periodVals.ToArray(), businessDayConvention, unqVals.ToArray());
var resVals = RangeHelper.ConvertArrayToRange(periods);
return(resVals);
}
/// <summary>
/// Adds the period to an array of dates.
/// </summary>
/// <param name="dateArray">The dates as an array.</param>
/// <param name="dayType">The day type.</param>
/// <param name="periodInterval">The period interval.</param>
/// <param name="businessDayConvention">The business day convention.</param>
/// <param name="locationsAsArray">The calendars.</param>
/// <returns>A range of dates.</returns>
public object[,] AddPeriods(Excel.Range dateArray, string dayType, string periodInterval, string businessDayConvention, Excel.Range locationsAsArray)
{
List <string> unqVals = DataRangeHelper.StripRange(locationsAsArray);
List <DateTime> dateVals = DataRangeHelper.StripDateTimeRange(dateArray);
List <DateTime> periods = CalendarService.AddPeriods(dateVals.ToArray(), dayType, periodInterval, businessDayConvention, unqVals.ToArray());
var resVals = RangeHelper.ConvertArrayToRange(periods);
return(resVals);
}
/// <summary>
/// Gets the Last trading based on a given month.
/// </summary>
/// <param name="exchangeCommodityName">Name of the exchange commodity.</param>
/// <param name="monthsArray">The array of months.</param>
/// <param name="yearsArray">The array of years as integers.</param>
/// <returns></returns>
public object[,] LastTradingDayByMonth(string exchangeCommodityName, Excel.Range monthsArray, Excel.Range yearsArray)
{
List <int> unqMonths = DataRangeHelper.StripIntRange(monthsArray);
List <int> unqYears = DataRangeHelper.StripIntRange(yearsArray);
List <DateTime> dates = LastTradingDayHelper.GetLastTradingDays(exchangeCommodityName, unqMonths.ToArray(), unqYears.ToArray());
var resVals = RangeHelper.ConvertArrayToRange(dates);
return(resVals);
}
public void NormalizeRange_ReturnsNormalizedRange(long?start, long?end, long?normalizedStart, long?normalizedEnd)
{
// Arrange & Act
var normalizedRange = RangeHelper.NormalizeRange(new RangeItemHeaderValue(start, end), 3);
// Assert
Assert.Equal(normalizedStart, normalizedRange.From);
Assert.Equal(normalizedEnd, normalizedRange.To);
}
public override double ProjectDataValue(object value)
{
double num = this.ConvertToPositionType(value);
if (num < this.ActualMinimum || num > this.ActualMaximum)
{
return(double.NaN);
}
return(RangeHelper.Project(new Range <double>(this.ActualViewMinimum, this.ActualViewMaximum), num + 0.5, Scale.PercentRange));
}
public override void ZoomToPercent(double viewMinimum, double viewMaximum)
{
double minSize = 1.0 / this.ActualZoomRange.Maximum;
double maxSize = 1.0 / this.ActualZoomRange.Minimum;
RangeHelper.BoxRangeInsideAnother(ref viewMinimum, ref viewMaximum, 0.0, 1.0, minSize, maxSize, 0.01);
Range <double> targetRange = new Range <double>(this.ActualMinimum, this.ActualMaximum);
this.ZoomToValue(RangeHelper.Project(Scale.PercentRange, viewMinimum, targetRange), RangeHelper.Project(Scale.PercentRange, viewMaximum, targetRange));
}
/// <summary>
/// Gets the unadjusted calculation period start dates.
/// </summary>
/// <param name="effectiveDate">The effective date.</param>
/// <param name="terminationDate">The termination date.</param>
/// <param name="periodInterval">The period interval.</param>
/// <param name="rollConvention">The roll convention.</param>
/// <param name="firstRegularPeriodDate">The first regular period date.</param>
/// <param name="stubPeriodType">Type of the stub period.</param>
/// <returns>A vertival range of dates.</returns>
public object[,] GetUnadjustedCalculationPeriodDates(DateTime effectiveDate, DateTime terminationDate, string periodInterval, string rollConvention,
DateTime firstRegularPeriodDate, string stubPeriodType)
{
var dates = DateScheduler.GetUnadjustedCalculationPeriodDates(effectiveDate, terminationDate,
periodInterval, rollConvention,
firstRegularPeriodDate, stubPeriodType);
var result = RangeHelper.ConvertArrayToRange(dates);
return(result);
}
internal virtual void CalculateActualZoomRange()
{
Range <double> range = this.ZoomRange.HasValue ? this.ZoomRange.Value : Scale.DefaultZoomRange;
double minimum = range.Minimum;
double maximum = range.Maximum;
double minPossibleZoom = this.GetMinPossibleZoom();
double maxPossibleZoom = this.GetMaxPossibleZoom();
RangeHelper.BoxRangeInsideAnother(ref minimum, ref maximum, minPossibleZoom, maxPossibleZoom);
this.ActualZoomRange = new Range <double>(minimum, maximum);
}
private static bool ValidLatitude(string?range)
{
var parsedRange = RangeHelper.ParseRange(range);
if (parsedRange == null)
{
return(false);
}
return(Angle.FromRadians(parsedRange.Value.Start).Degrees <= 90 && Angle.FromRadians(parsedRange.Value.End).Degrees >= -90);
}
/// <summary>
/// Adjusteds the dates from effective date.
/// </summary>
/// <param name="effectiveDate">The effective date.</param>
/// <param name="terminationDate">The termination date.</param>
/// <param name="periodInterval">The period interval.</param>
/// <param name="rollConvention">The roll convention.</param>
/// <param name="businessCenters">The business centers.</param>
/// <param name="dateAdjustmentConvention">The date adjustment convention.</param>
/// <returns>A vertical arrray of dates.</returns>
public object[,] AdjustedDatesFromEffectiveDate(DateTime effectiveDate, DateTime terminationDate, string periodInterval, string rollConvention,
string businessCenters, string dateAdjustmentConvention)
{
BusinessCenters centers = BusinessCentersHelper.Parse(businessCenters);
IBusinessCalendar calendar = Engine.ToBusinessCalendar(centers);
var adjustments = EnumHelper.Parse <BusinessDayConventionEnum>(dateAdjustmentConvention);
var adjustedDateSchedule = AdjustedDateScheduler.AdjustedDatesFromEffectiveDate(effectiveDate, terminationDate, periodInterval, rollConvention, calendar, adjustments);
var result = RangeHelper.ConvertArrayToRange(adjustedDateSchedule);
return(result);
}
/// <summary>
/// Gets the greeks.
/// </summary>
/// <param name="style">The style.</param>
/// <param name="spot">The spot.</param>
/// <param name="strike">The strike.</param>
/// <param name="vol">The vol.</param>
/// <param name="expiry"></param>
/// <param name="paystyle">The paystyle.</param>
/// <param name="zeroDatesAsArray"></param>
/// <param name="zeroRatesAsArray">The zero curve.</param>
/// <param name="divDatesAsArray"></param>
/// <param name="divAmsAsArray">The div curve.</param>
/// <param name="gridsteps">The gridsteps.</param>
/// <param name="smoo">The smoo.</param>
/// <param name="flatFlag">if set to <c>true</c> [flat flag].</param>
/// <param name="today"></param>
/// <returns></returns>
public object[,] BinomialRelativeGetGreeks(string style, double spot, double strike, double vol, DateTime today, DateTime expiry,
string paystyle, Excel.Range zeroDatesAsArray, Excel.Range zeroRatesAsArray, Excel.Range divDatesAsArray, Excel.Range divAmsAsArray, double gridsteps, string smoo, bool flatFlag)
{
var zeroDates = DataRangeHelper.StripDateTimeRange(zeroDatesAsArray);
var zeroRates = DataRangeHelper.StripDoubleRange(zeroRatesAsArray);
var divDates = DataRangeHelper.StripDateTimeRange(divDatesAsArray);
var divAms = DataRangeHelper.StripDoubleRange(divAmsAsArray);
var retArray = EquitiesLibrary.BinomialRelativeGetGreeks(style, spot, strike, vol, today, expiry, paystyle, zeroDates.ToArray(), zeroRates.ToArray(), divDates.ToArray(), divAms.ToArray(), gridsteps, smoo, flatFlag);
var result = RangeHelper.ConvertArrayToRange(retArray);
return(result);
}
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 override IEnumerable <double> ProjectValues(IEnumerable values)
{
if (values != null)
{
Range <double> fromRange = new Range <double>(this.ActualViewMinimum, this.ActualViewMaximum);
foreach (object obj in values)
{
double x = this.ConvertToPositionType(obj);
yield return(RangeHelper.Project(fromRange, x, Scale.PercentRange));
}
}
}
public static void Exchange_From_IsNotGreater_To()
{
// Arrange
var range = new Range <int>(10, 12);
// Act
var result = RangeHelper.ExchangeIfFromGreaterTo(range, (from, to) => from.CompareTo(to));
// Assert
Assert.Equal(10, result.From);
Assert.Equal(12, result.To);
}
/// <summary>
/// Gets the adjusted calculation period start dates.
/// </summary>
/// <param name="effectiveDate">The effective date.</param>
/// <param name="terminationDate">The termination date.</param>
/// <param name="periodInterval">The period interval.</param>
/// <param name="rollConvention">The roll convention.</param>
/// <param name="firstRegularPeriodDate">The first regular period date.</param>
/// <param name="stubPeriodType">Type of the stub period.</param>
/// <param name="calendars">The holiday array.</param>
/// <param name="businessDayConvention">The business day convention.</param>
/// <returns>A vertival range of dates.</returns>
public object[,] GetAdjustedCalculationPeriodDates(DateTime effectiveDate, DateTime terminationDate,
string periodInterval, string rollConvention, DateTime firstRegularPeriodDate, string stubPeriodType,
Excel.Range calendars, string businessDayConvention)
{
List <string> unqVals = DataRangeHelper.StripRange(calendars);
IBusinessCalendar businessCalendar = CalendarService.GetCalendar(unqVals.ToArray());
var dates = AdjustedDateScheduler.GetAdjustedCalculationPeriodDates(effectiveDate, terminationDate,
periodInterval, rollConvention, firstRegularPeriodDate, stubPeriodType,
businessCalendar, businessDayConvention);
var result = RangeHelper.ConvertArrayToRange(dates);
return(result);
}
/// <summary>
/// Returns the unadjusted the calculation dates
/// </summary>
/// <param name="effectiveDate">The effective date.</param>
/// <param name="terminationDate">The termination date.</param>
/// <param name="intervalToFirstRegularPeriodStart">The interval to first regular period start.</param>
/// <param name="periodInterval">The period interval.</param>
/// <param name="rollConvention">The roll convention.</param>
/// <param name="stubPeriodType">Type of the stub period.</param>
/// <returns>A vertical arrray of dates.</returns>
public object[,] UnadjustedCalculationDatesFromFirstRegularInterval(DateTime effectiveDate, DateTime terminationDate,
string intervalToFirstRegularPeriodStart, string periodInterval, string rollConvention, string stubPeriodType)
{
var dates = DateScheduler.UnadjustedCalculationDatesFromFirstRegularInterval(effectiveDate,
terminationDate,
intervalToFirstRegularPeriodStart,
periodInterval,
rollConvention,
stubPeriodType);
var result = RangeHelper.ConvertArrayToRange(dates);
return(result);
}
private (byte[] FormatChunk, RangeHelper.Range DataChunk) ReadChunkRanges(FixtureModel model)
{
using var stream = model.ToTargetInformation(this.RealFileSystem).FileStream;
var riffChunk = Wave.FindRiffChunk(stream);
var waveChunk = riffChunk.Bind(r => Wave.FindWaveChunk(stream, r));
var formatChunk = waveChunk.Bind(w => Wave.FindFormatChunk(stream, w));
var dataChunk = waveChunk.Bind(w => Wave.FindDataChunk(stream, w));
var formatSpan = RangeHelper.ReadRange(stream, (RangeHelper.Range)formatChunk);
return(formatSpan.ToArray(), (RangeHelper.Range)dataChunk);
}
private IEnumerable <ScalePosition> ProjectMinor(IList <Category> categories, ScaleElementDefinition definition, int level)
{
this.RecalculateIfEmpty();
int step = 1;
int maxCount = this.MaxCount;
if (categories.Count > maxCount && categories.Count > 50)
{
if (level != this._realizedCategoryLevels.Count - 1)
{
yield break;
}
else
{
switch (maxCount)
{
case 0:
yield break;
case 1:
yield break;
case 2:
step = categories.Count - 1;
break;
default:
step = categories.Count / (maxCount - 1);
if (categories.Count % maxCount != 0)
{
step = (int)Math.Ceiling((double)categories.Count / ((double)maxCount - 2.0));
break;
}
break;
}
}
}
Range <double> fromRange = new Range <double>(this.ActualViewMinimum, this.ActualViewMaximum);
int i = 0;
while (i < categories.Count)
{
Category category = categories[i];
double bucketMinX = (double)(this._minLeafIndex + category.LeafIndexRange.Minimum);
double bucketMaxX = (double)(this._minLeafIndex + category.LeafIndexRange.Maximum);
double x = (bucketMaxX + bucketMinX) / 2.0;
yield return(new ScalePosition(category.Content, RangeHelper.Project(fromRange, x, Scale.PercentRange), RangeHelper.Project(fromRange, bucketMinX, Scale.PercentRange), RangeHelper.Project(fromRange, bucketMaxX, Scale.PercentRange)));
i += step;
}
}
private void ComputeRange()
{
// 14.35 Range
// http://tools.ietf.org/html/draft-ietf-httpbis-p5-range-24
// A server MUST ignore a Range header field received with a request method other
// than GET.
if (!_isGet)
{
return;
}
(_isRangeRequest, _range) = RangeHelper.ParseRange(_context, _requestHeaders, _length, _logger);
}
private static bool ValidRange(string?range)
{
var parsedRange = RangeHelper.ParseRange(range);
if (parsedRange == null)
{
return(false);
}
// Ensure that the start angle isn't the same as the end
var unwrappedRange = parsedRange.Value.UnwrapLongitude();
return(Math.Abs(unwrappedRange.Start - unwrappedRange.End) > Constants.FloatingTolerance);
}
public void ParseRange_ReturnsNullWhenMultipleRangesProvidedInRangeHeader(string range)
{
// Arrange
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers.Range = range;
// Act
var(isRangeRequest, parsedRangeResult) = RangeHelper.ParseRange(httpContext, httpContext.Request.GetTypedHeaders(), 10, NullLogger.Instance);
// Assert
Assert.False(isRangeRequest);
Assert.Null(parsedRangeResult);
}
public override IEnumerable <double> ProjectValues(IEnumerable values)
{
this.RecalculateIfEmpty();
if (values != null)
{
Range <double> fromRange = new Range <double>((double)this.ActualViewMinimum.Ticks, (double)this.ActualViewMaximum.Ticks);
foreach (object obj in values)
{
DateTime time = this.ConvertToPositionType(obj);
double x = (double)time.Ticks;
yield return(RangeHelper.Project(fromRange, x, Scale.PercentRange));
}
}
}
public static async ValueTask <Fin <FirmwareRecord> > ReadFirmwareAsync(FileStream stream)
{
var vorbisChunk = Flac.ScanForChunk(stream, Flac.VorbisCommentBlockNumber);
if (vorbisChunk.IsFail)
{
return((Error)vorbisChunk);
}
var vorbisSpan = await RangeHelper.ReadRangeAsync(stream, (RangeHelper.Range) vorbisChunk);
// find the frontier labs vorbis vendor comment
return(FindInBufferFirmware(vorbisSpan, ((RangeHelper.Range)vorbisChunk).Start));
}
/// <summary>
///
/// </summary>
/// <param name="baseAmount"></param>
/// <param name="valueDate"></param>
/// <param name="finalDatesAsArray"></param>
/// <param name="paymentDatesAsArray"></param>
/// <param name="paymentAmountsAsArray"></param>
/// <param name="zeroDatesAsArray"></param>
/// <param name="zeroRatesAsArray"></param>
/// <returns></returns>
public object[,] DivYield(double baseAmount, DateTime valueDate, Excel.Range finalDatesAsArray, Excel.Range paymentDatesAsArray,
Excel.Range paymentAmountsAsArray, Excel.Range zeroDatesAsArray,
Excel.Range zeroRatesAsArray)
{
var finalDates = DataRangeHelper.StripDateTimeRange(finalDatesAsArray);
var paymentDates = DataRangeHelper.StripDateTimeRange(paymentDatesAsArray);
var paymentAmounts = DataRangeHelper.StripDoubleRange(paymentAmountsAsArray);
var zeroDates = DataRangeHelper.StripDateTimeRange(zeroDatesAsArray);
var zeroRates = DataRangeHelper.StripDoubleRange(zeroRatesAsArray);
var retArray = EquitiesLibrary.DivYield(baseAmount, valueDate, finalDates.ToArray(), paymentDates.ToArray(), paymentAmounts.ToArray(), zeroDates.ToArray(), zeroRates.ToArray());
var result = RangeHelper.ConvertArrayToRange(retArray);
return(result);
}
/// <summary>
/// Gets a dates schedule.
/// </summary>
/// <param name="metaScheduleDefinitionRange">This must have 3 columns: interval, interval, rollconventionenum.</param>
/// <param name="startDate">The start date of the schedule to be generated.</param>
/// <param name="calendar">The relevant calendar.</param>
/// <param name="businessDayAdjustment">The business day adjustments.</param>
/// <returns>A vertical arrray of dates.</returns>
public object[,] GetMetaDatesSchedule(Excel.Range metaScheduleDefinitionRange,
DateTime startDate,
string calendar,
string businessDayAdjustment)
{
var values = metaScheduleDefinitionRange.Value[System.Reflection.Missing.Value] as object[, ];
List <ThreeStringsRangeItem> metaScheduleDefinition = ObjectToArrayOfPropertiesConverter.CreateListFromHorizontalArrayRange <ThreeStringsRangeItem>(values);
BusinessCenters centers = BusinessCentersHelper.Parse(calendar);
IBusinessCalendar businessCalendar = Engine.ToBusinessCalendar(centers);
var metaSchedule = AdjustedDatesMetaSchedule.GetMetaDatesSchedule(metaScheduleDefinition, startDate, businessCalendar, calendar, businessDayAdjustment);
var result = RangeHelper.ConvertArrayToRange(metaSchedule);
return(result);
}
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 void Tick()
{
foreach (var subsystemTuple in _subsystemMatcher.MatchingEntities)
{
var sum = subsystemTuple.Component3.Value;
foreach (var itemContainer in subsystemTuple.Component2.Items)
{
ComponentEntityTuple <IItemType, ConsumeMemory> itemTuple;
if (itemContainer.Item != null && _itemMatcher.TryGetMatchingEntity(itemContainer.Item.Value, out itemTuple))
{
sum += itemTuple.Component2.Value;
}
}
subsystemTuple.Component3.Value = RangeHelper.AssignWithinBounds(sum, 0, subsystemTuple.Component3.Maximum);
}
}
public void ParseRange_ReturnsSingleRangeWhenInputValid()
{
// Arrange
var httpContext = new DefaultHttpContext();
var range = new RangeHeaderValue(1, 2);
httpContext.Request.Headers.Range = range.ToString();
// Act
var(isRangeRequest, parsedRange) = RangeHelper.ParseRange(httpContext, httpContext.Request.GetTypedHeaders(), 4, NullLogger.Instance);
// Assert
Assert.True(isRangeRequest);
Assert.Equal(1, parsedRange.From);
Assert.Equal(2, parsedRange.To);
}
