private static bool ParseDHMSTokens(string[] dhmsTokens, string decimalSeparator, string negativeSign, [MaybeNullWhen(false)] out TimeSpanValue value) { value = null; bool result = false; // We must have at least two non-empty, non-whitespace (NENWS) tokens (e.g., M:S). // Note: D.H:M input will cause the S token to still be null when we get here, so we // can't assume that everything after the first NENWS token will also be a NENWS token. // Only the first NENWS token can contain a negative sign. // Only the Seconds token can contain a decimal separator. var nenwsTokens = dhmsTokens.SkipWhile(x => string.IsNullOrWhiteSpace(x)); if (nenwsTokens.Count() >= 2 && ValidateTokens(nenwsTokens.Skip(1), x => x == null || !x.Contains(negativeSign)) && ValidateTokens(dhmsTokens.Take(3), x => x == null || !x.Contains(decimalSeparator))) { if (GetTicks(dhmsTokens[0], TimeSpan.TicksPerDay, false, out long daysTicks) && GetTicks(dhmsTokens[1], TimeSpan.TicksPerHour, false, out long hoursTicks) && GetTicks(dhmsTokens[2], TimeSpan.TicksPerMinute, false, out long minutesTicks) && GetTicks(dhmsTokens[3], TimeSpan.TicksPerSecond, true, out long secondsTicks)) { // Negative on the first token means the whole TimeSpan should be negative. // We have to check if the token text starts with a negative sign because the // numeric value might be zero (e.g., "-00:19:01"). long sign = nenwsTokens.First().StartsWith(negativeSign, StringComparison.CurrentCulture) ? -1 : 1; TimeSpan timeSpan = TimeSpan.FromTicks(sign * (daysTicks + hoursTicks + minutesTicks + secondsTicks)); value = new TimeSpanValue(timeSpan); result = true; } } return(result); }
private double?GetValue(IRun run, string columnName) { if (run == null || string.IsNullOrEmpty(columnName)) { return(null); } if (Enum.IsDefined(typeof(AxisDimension), columnName)) { AxisDimension axisDimension = (AxisDimension)Enum.Parse(typeof(AxisDimension), columnName); return(GetValue(run, axisDimension)); } else if (Enum.IsDefined(typeof(SizeDimension), columnName)) { SizeDimension sizeDimension = (SizeDimension)Enum.Parse(typeof(SizeDimension), columnName); return(GetValue(run, sizeDimension)); } else { IItem value = Content.GetValue(run, columnName); if (value == null) { return(null); } DoubleValue doubleValue = value as DoubleValue; IntValue intValue = value as IntValue; TimeSpanValue timeSpanValue = value as TimeSpanValue; DateTimeValue dateTimeValue = value as DateTimeValue; double? ret = null; if (doubleValue != null) { if (!double.IsNaN(doubleValue.Value) && !double.IsInfinity(doubleValue.Value)) { ret = doubleValue.Value; } } else if (intValue != null) { ret = intValue.Value; } else if (timeSpanValue != null) { ret = timeSpanValue.Value.TotalSeconds; } else if (dateTimeValue != null) { ret = dateTimeValue.Value.ToOADate(); } else { int columnIndex = Matrix.ColumnNames.ToList().IndexOf(columnName); ret = GetCategoricalValue(columnIndex, value.ToString()); } return(ret); } }
private void Runs_CollectionReset(object sender, CollectionItemsChangedEventArgs <IRun> e) { if (Optimizer != null) { Optimizer.Runs.RemoveRange(e.OldItems); } foreach (IRun run in e.Items) { IItem item; run.Results.TryGetValue("Execution Time", out item); TimeSpanValue executionTime = item as TimeSpanValue; if (executionTime != null) { ExecutionTime += executionTime.Value; } } }
public override int GetHashCode() { unchecked { var result = GuidValue.GetHashCode(); result = (result * 397) ^ (StringValue != null ? StringValue.GetHashCode() : 0); result = (result * 397) ^ IntValue; result = (result * 397) ^ LongValue.GetHashCode(); result = (result * 397) ^ BoolValue.GetHashCode(); result = (result * 397) ^ ByteValue.GetHashCode(); result = (result * 397) ^ DecimalValue.GetHashCode(); result = (result * 397) ^ DoubleValue.GetHashCode(); result = (result * 397) ^ DateTimeValue.GetHashCode(); result = (result * 397) ^ MaybeMoney.GetHashCode(); result = (result * 397) ^ TimeSpanValue.GetHashCode(); return(result); } }
private void Runs_ItemsAdded(object sender, CollectionItemsChangedEventArgs <IRun> e) { foreach (IRun run in e.Items) { IItem item; run.Results.TryGetValue("Execution Time", out item); TimeSpanValue executionTime = item as TimeSpanValue; if (executionTime != null) { if (Optimizer.ExecutionState == ExecutionState.Started) { runsExecutionTime += executionTime.Value; } else { ExecutionTime += executionTime.Value; } } } }
/// <summary> /// Checks if there are any holes in the data series. Returns the active periods. /// </summary> /// <param name="data"></param> /// <param name="Interval"></param> /// <returns></returns> public static TimeSpanSeries GetActivePeriods(TimeStampSeries data, TimeSpan Interval) { TimeSpanSeries toreturn = new TimeSpanSeries(); if (data.Count > 0) { TimeSpanValue currentvalue = new TimeSpanValue(data.StartTime, data.StartTime, 1); for (int i = 0; i < data.Count; i++) { if (data.Items[i].Time <= currentvalue.EndTime.Add(Interval)) currentvalue.EndTime = data.Items[i].Time; else { toreturn.Items.Add(currentvalue); currentvalue = new TimeSpanValue(data.Items[i].Time, data.Items[i].Time, 1); } } toreturn.Items.Add(currentvalue); } return toreturn; }
public override string ToString() { switch (Type) { case DataType.String: return(StringValue); case DataType.Numeric: return(NumericValue.ToString()); case DataType.Boolean: return(BoolValue.ToString()); case DataType.DateTime: return(DateTimeValue.ToString()); case DataType.TimeSpan: return(TimeSpanValue.ToString()); default: return(""); } }
/// <summary> /// Converts the value using the apropriate converter. Start time is included. Endtime is not /// </summary> /// <param name="values"></param> /// <returns></returns> public virtual TimeSpanValue Convert(TimeSpanValue val) { if (val.StartTime >= Start & val.EndTime < End) return new TimeSpanValue(val.StartTime, val.EndTime, ConvertFunction(val.Value)); else return val; }
/// <summary> /// Changes the zoomlevel of a timespanseries /// </summary> /// <param name="Data"></param> /// <param name="NewZoomLevel"></param> /// <param name="Accumulate"></param> /// <returns></returns> public static IEnumerable<TimeSpanValue> ChangeZoomLevel(TimeSpanSeries Data, TimeStepUnit NewZoomLevel, bool Accumulate) { if (Data.TimeStepSize <= NewZoomLevel) return null; List<TimeSpanValue> ToReturn = new List<TimeSpanValue>(); DateTime start = Data.StartTime; DateTime end = Data.EndTime; TimeSpanValue CurrentValue = new TimeSpanValue(GetTimeOfFirstTimeStep(start, NewZoomLevel), GetTimeOfFirstTimeStep(start, NewZoomLevel).AddTimeStepUnit(NewZoomLevel), 0); double currentcount = 0; foreach (var v in Data.Items.Where(dv => dv.Value != Data.DeleteValue)) { if (CurrentValue.StartTime <= v.StartTime & v.StartTime<= CurrentValue.EndTime) { if (CurrentValue.EndTime >= v.EndTime) //We are still within the timespan { CurrentValue.Value += v.Value; currentcount++; } else //We exceed the timespan { double outsidefraction =(v.EndTime.Subtract(CurrentValue.EndTime).TotalDays / v.EndTime.Subtract(v.StartTime).TotalDays); CurrentValue.Value += v.Value*(1 - outsidefraction); currentcount += 1 - outsidefraction; if (!Accumulate & currentcount != 0) CurrentValue.Value /= currentcount; ToReturn.Add(CurrentValue); CurrentValue = new TimeSpanValue(CurrentValue.EndTime, CurrentValue.EndTime.AddTimeStepUnit(NewZoomLevel), v.Value*outsidefraction); currentcount = outsidefraction; } } else { if (!Accumulate & currentcount != 0) CurrentValue.Value /= currentcount; ToReturn.Add(CurrentValue); CurrentValue = new TimeSpanValue(GetTimeOfFirstTimeStep(v.StartTime, NewZoomLevel), GetTimeOfFirstTimeStep(v.StartTime, NewZoomLevel).AddTimeStepUnit(NewZoomLevel), v.Value); currentcount = 1; } } if (!Accumulate & currentcount != 0) CurrentValue.Value /= currentcount; ToReturn.Add(CurrentValue); return ToReturn; }
/// <summary> /// Returns the appropriate time step for a given time period /// </summary> /// <param name="Start"></param> /// <param name="End"></param> /// <returns></returns> public static TimeStepUnit GetTimeStep(TimeSpanValue value) { return GetTimeStep(value.StartTime, value.EndTime); }
public override TimeSpanValue Convert(TimeSpanValue val) { return new TimeSpanValue(val.StartTime, val.EndTime, val.Value * val.Duration.TotalSeconds * Par2.Value); }
public static bool TryParse(string text, DateTimeFormatInfo timeFmt, NumberFormatInfo numFmt, [MaybeNullWhen(false)] out TimeSpanValue value) { value = null; bool result = false; // Only use our custom parser if time formats are using ':' separators. // If another culture is using some other time format, then the caller // should try to let the system parse it. const char c_separator = ':'; if (!string.IsNullOrEmpty(text) && timeFmt.ShortTimePattern.Contains(c_separator)) { string[] tokens = text.Trim().Split(new char[] { c_separator }, StringSplitOptions.RemoveEmptyEntries); int numTokens = tokens.Length; if (numTokens >= 2 && numTokens <= 4) { string decimalSeparator = numFmt.NumberDecimalSeparator; string[]? dhmsTokens = GetDHMSTokens(tokens, decimalSeparator); if (dhmsTokens != null) { result = ParseDHMSTokens(dhmsTokens, decimalSeparator, numFmt.NegativeSign, out value); } } } return(result); }