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