public static void ShiftEvents(this IEnumerable <TrackChunk> trackChunks, ITimeSpan distance, TimeDivision timeDivision) { ThrowIfArgument.IsNull(nameof(trackChunks), trackChunks); ThrowIfArgument.IsNull(nameof(distance), distance); ThrowIfArgument.IsNull(nameof(timeDivision), timeDivision); foreach (var trackChunk in trackChunks) { trackChunk.ShiftEvents(distance, timeDivision); } }
/// <summary> /// Adds a time span to the current one. /// </summary> /// <remarks> /// If <paramref name="timeSpan"/> and the current time span have the same type, /// the result time span will be of this type too; otherwise - of the <see cref="MathTimeSpan"/>. /// </remarks> /// <param name="timeSpan">Time span to add to the current one.</param> /// <param name="mode">Mode of the operation that defines meaning of time spans the /// operation will be performed on.</param> /// <returns>Time span that is a sum of the <paramref name="timeSpan"/> and the /// current time span.</returns> /// <exception cref="ArgumentNullException"><paramref name="timeSpan"/> is invalid.</exception> /// <exception cref="InvalidEnumArgumentException"><paramref name="mode"/> specified an invalid value.</exception> public ITimeSpan Add(ITimeSpan timeSpan, TimeSpanMode mode) { ThrowIfArgument.IsNull(nameof(timeSpan), timeSpan); ThrowIfArgument.IsInvalidEnumValue(nameof(mode), mode); var metricTimeSpan = timeSpan as MetricTimeSpan; return(metricTimeSpan != null ? this + metricTimeSpan : TimeSpanUtilities.Add(this, timeSpan, mode)); }
/// <summary> /// Splits chords contained in the specified <see cref="MidiFile"/> at the specified distance /// from a chord's start or end. /// </summary> /// <param name="midiFile"><see cref="MidiFile"/> to split chords in.</param> /// <param name="distance">Distance to split chords at.</param> /// <param name="from">Point of a chord <paramref name="distance"/> should be measured from.</param> /// <param name="notesTolerance">Notes tolerance that defines maximum distance of notes from the /// start of the first note of a chord. Notes within this tolerance will be considered as a chord.</param> /// <exception cref="ArgumentNullException"> /// <para>One of the following errors occured:</para> /// <list type="bullet"> /// <item> /// <description><paramref name="midiFile"/> is <c>null</c>.</description> /// </item> /// <item> /// <description><paramref name="distance"/> is <c>null</c>.</description> /// </item> /// </list> /// </exception> /// <exception cref="InvalidEnumArgumentException"><paramref name="from"/> specified an invalid value.</exception> /// <exception cref="ArgumentOutOfRangeException"><paramref name="notesTolerance"/> is negative.</exception> public static void SplitChordsAtDistance(this MidiFile midiFile, ITimeSpan distance, LengthedObjectTarget from, long notesTolerance = 0) { ThrowIfArgument.IsNull(nameof(midiFile), midiFile); ThrowIfArgument.IsNull(nameof(distance), distance); ThrowIfArgument.IsInvalidEnumValue(nameof(from), from); ThrowIfNotesTolerance.IsNegative(nameof(notesTolerance), notesTolerance); var tempoMap = midiFile.GetTempoMap(); midiFile.GetTrackChunks().SplitChordsAtDistance(distance, from, tempoMap, notesTolerance); }
/// <summary> /// Adds a time span to the current one. /// </summary> /// <remarks> /// If <paramref name="timeSpan"/> and the current time span have the same type, /// the result time span will be of this type too; otherwise - of the <see cref="MathTimeSpan"/>. /// </remarks> /// <param name="timeSpan">Time span to add to the current one.</param> /// <param name="mode">Mode of the operation that defines meaning of time spans the /// operation will be performed on.</param> /// <returns>Time span that is a sum of the <paramref name="timeSpan"/> and the /// current time span.</returns> /// <exception cref="ArgumentNullException"><paramref name="timeSpan"/> is invalid.</exception> /// <exception cref="InvalidEnumArgumentException"><paramref name="mode"/> specified an invalid value.</exception> public ITimeSpan Add(ITimeSpan timeSpan, TimeSpanMode mode) { ThrowIfArgument.IsNull(nameof(timeSpan), timeSpan); ThrowIfArgument.IsInvalidEnumValue(nameof(mode), mode); var barBeatFractionTimeSpan = timeSpan as BarBeatFractionTimeSpan; return(barBeatFractionTimeSpan != null ? this + barBeatFractionTimeSpan : TimeSpanUtilities.Add(this, timeSpan, mode)); }
internal static ITimeSpan Add(ITimeSpan timeSpan1, ITimeSpan timeSpan2, TimeSpanMode mode) { ThrowIfArgument.IsInvalidEnumValue(nameof(mode), mode); if (mode == TimeSpanMode.TimeTime) { throw new ArgumentException("Times cannot be added.", nameof(mode)); } return(new MathTimeSpan(timeSpan1, timeSpan2, MathOperation.Add, mode)); }
/// <summary> /// Sets time and length of the specified note. /// </summary> /// <param name="note">Note to set time and length to.</param> /// <param name="time">Time to set to <paramref name="note"/>.</param> /// <param name="length">Length to set to <paramref name="note"/>.</param> /// <param name="tempoMap">Tempo map that will be used for time and length conversion.</param> /// <returns>An input <paramref name="note"/> with new time and length.</returns> /// <exception cref="ArgumentNullException"><paramref name="note"/> is null. -or- /// <paramref name="time"/> is null. -or- <paramref name="length"/> is null. -or- /// <paramref name="tempoMap"/> is null.</exception> public static Note SetTimeAndLength(this Note note, ITimeSpan time, ITimeSpan length, TempoMap tempoMap) { ThrowIfArgument.IsNull(nameof(note), note); ThrowIfArgument.IsNull(nameof(time), time); ThrowIfArgument.IsNull(nameof(length), length); ThrowIfArgument.IsNull(nameof(tempoMap), tempoMap); note.Time = TimeConverter.ConvertFrom(time, tempoMap); note.Length = LengthConverter.ConvertFrom(length, note.Time, tempoMap); return(note); }
/// <summary> /// Sets time and length of the specified chord. /// </summary> /// <param name="chord">Chord to set time and length to.</param> /// <param name="time">Time to set to <paramref name="chord"/>.</param> /// <param name="length">Length to set to <paramref name="chord"/>.</param> /// <param name="tempoMap">Tempo map that will be used for time and length conversion.</param> /// <returns>An input <paramref name="chord"/> with new time and length.</returns> /// <exception cref="ArgumentNullException"> /// <para>One of the following errors occured:</para> /// <list type="bullet"> /// <item> /// <description><paramref name="chord"/> is <c>null</c>.</description> /// </item> /// <item> /// <description><paramref name="time"/> is <c>null</c>.</description> /// </item> /// <item> /// <description><paramref name="length"/> is <c>null</c>.</description> /// </item> /// <item> /// <description><paramref name="tempoMap"/> is <c>null</c>.</description> /// </item> /// </list> /// </exception> public static Chord SetTimeAndLength(this Chord chord, ITimeSpan time, ITimeSpan length, TempoMap tempoMap) { ThrowIfArgument.IsNull(nameof(chord), chord); ThrowIfArgument.IsNull(nameof(time), time); ThrowIfArgument.IsNull(nameof(length), length); ThrowIfArgument.IsNull(nameof(tempoMap), tempoMap); chord.Time = TimeConverter.ConvertFrom(time, tempoMap); chord.Length = LengthConverter.ConvertFrom(length, chord.Time, tempoMap); return(chord); }
/// <summary> /// Shifts playback position back by the specified step. /// </summary> /// <param name="step">Amount of time to shift playback position by.</param> /// <exception cref="ArgumentNullException"><paramref name="step"/> is null.</exception> /// <exception cref="ObjectDisposedException">The current <see cref="Playback"/> is disposed.</exception> /// <exception cref="MidiDeviceException">An error occurred on device.</exception> public void MoveBack(ITimeSpan step) { ThrowIfArgument.IsNull(nameof(step), step); EnsureIsNotDisposed(); var currentTime = (MetricTimeSpan)_clock.CurrentTime; MoveToTime(TimeConverter.ConvertTo <MetricTimeSpan>(step, TempoMap) > currentTime ? new MetricTimeSpan() : currentTime.Subtract(step, TimeSpanMode.TimeLength)); }
/// <summary> /// Subtracts a time span from the current one. /// </summary> /// <remarks> /// If <paramref name="timeSpan"/> and the current time span have the same type, /// the result time span will be of this type too; otherwise - of the <see cref="MathTimeSpan"/>. /// </remarks> /// <param name="timeSpan">Time span to subtract from the current one.</param> /// <param name="mode">Mode of the operation that defines meaning of time spans the /// operation will be performed on.</param> /// <returns>Time span that is a difference between the <paramref name="timeSpan"/> and the /// current time span.</returns> /// <exception cref="ArgumentNullException"><paramref name="timeSpan"/> is invalid.</exception> /// <exception cref="InvalidEnumArgumentException"><paramref name="mode"/> specified an invalid value.</exception> public ITimeSpan Subtract(ITimeSpan timeSpan, TimeSpanMode mode) { ThrowIfArgument.IsNull(nameof(timeSpan), timeSpan); ThrowIfArgument.IsInvalidEnumValue(nameof(mode), mode); var barBeatTicksTimeSpan = timeSpan as BarBeatTicksTimeSpan; return(barBeatTicksTimeSpan != null ? this - barBeatTicksTimeSpan : TimeSpanUtilities.Subtract(this, timeSpan, mode)); }
public static void Subtract_LengthLength(ITimeSpan timeSpan1, ITimeSpan timeSpan2, TempoMap tempoMap, long time) { var mathTimeSpan = CheckMathTimeSpan(timeSpan1, timeSpan2, MathOperation.Subtract, TimeSpanMode.LengthLength); AreEqual(timeSpan1, LengthConverter.ConvertTo(mathTimeSpan.Add(timeSpan2, TimeSpanMode.LengthLength), timeSpan1.GetType(), time, tempoMap), $"({timeSpan1} - {timeSpan2}) + {timeSpan2} != {timeSpan1}."); }
internal QuantizedTime(long newTime, long gridTime, ITimeSpan shift, long distanceToGridTime, ITimeSpan convertedDistanceToGridTime) { NewTime = newTime; GridTime = gridTime; Shift = shift; DistanceToGridTime = distanceToGridTime; ConvertedDistanceToGridTime = convertedDistanceToGridTime; }
/// <summary> /// Score for overlapping of two subtitles between 0 and 1. /// /// Corner cases: /// subtitles do not overlap -> 0 /// subtitles fully overlap -> 1 /// </summary> /// <returns>The score.</returns> /// <param name="a">The alpha component.</param> /// <param name="b">The blue component.</param> public static double OverlappingScore(ITimeSpan a, ITimeSpan b) { double overlappingSpan = UtilsCommon.OverlappingTimeSpan(a, b); double line1timeSpan = a.EndTime - a.StartTime; double line2timeSpan = b.EndTime - b.StartTime; // ignore matchings if there is next to no overlapping double line1score = (double)overlappingSpan / (double)line1timeSpan; double line2score = (double)overlappingSpan / (double)line2timeSpan; return((line1score + line2score) * 0.5f); }
private void SetStartTime(ITimeSpan time) { var convertedTime = (TimeSpan)TimeConverter.ConvertTo <MetricTimeSpan>(time, TempoMap); _clock.SetCurrentTime(convertedTime); _eventsEnumerator.Reset(); do { _eventsEnumerator.MoveNext(); }while (_eventsEnumerator.Current != null && _eventsEnumerator.Current.Time < convertedTime); }
public long ConvertFrom(ITimeSpan timeSpan, long time, TempoMap tempoMap) { var ticksPerQuarterNoteTimeDivision = tempoMap.TimeDivision as TicksPerQuarterNoteTimeDivision; if (ticksPerQuarterNoteTimeDivision == null) { throw new ArgumentException("Time division is not supported for time span conversion.", nameof(tempoMap)); } var musicalTimeSpan = (MusicalTimeSpan)timeSpan; return(4 * musicalTimeSpan.Numerator * ticksPerQuarterNoteTimeDivision.TicksPerQuarterNote / musicalTimeSpan.Denominator); }
public PrefetchMonitor(ArrayList outputLinks, TraceFile traceFile, ITimeSpan timeHorizon) { this.traceFile = traceFile; this.timeHorizon = timeHorizon; items = new Dictionary<string, LinkQuantityInfo>(); foreach (DataOutputLink link in outputLinks) { var linkId = getLinkId(link.link); var linkInfo = new LinkQuantityInfo(linkId); items[linkId] = linkInfo; } }
private static TimedMidiEvent[] ParseNote(Record record, MidiFileCsvConversionSettings settings) { if (record.TrackNumber == null) { CsvError.ThrowBadFormat(record.LineNumber, "Invalid track number."); } if (record.Time == null) { CsvError.ThrowBadFormat(record.LineNumber, "Invalid time."); } var parameters = record.Parameters; if (parameters.Length < 5) { CsvError.ThrowBadFormat(record.LineNumber, "Invalid number of parameters provided."); } var i = -1; try { var channel = (FourBitNumber)TypeParser.FourBitNumber(parameters[++i], settings); var noteNumber = (SevenBitNumber)TypeParser.NoteNumber(parameters[++i], settings); ITimeSpan length = null; TimeSpanUtilities.TryParse(parameters[++i], settings.NoteLengthType, out length); var velocity = (SevenBitNumber)TypeParser.SevenBitNumber(parameters[++i], settings); var offVelocity = (SevenBitNumber)TypeParser.SevenBitNumber(parameters[++i], settings); return(new[] { new TimedMidiEvent(record.Time, new NoteOnEvent(noteNumber, velocity) { Channel = channel }), new TimedMidiEvent(record.Time.Add(length, TimeSpanMode.TimeLength), new NoteOffEvent(noteNumber, offVelocity) { Channel = channel }), }); } catch { CsvError.ThrowBadFormat(record.LineNumber, $"Parameter ({i}) is invalid."); } return(null); }
public PrefetchManager(TraceFile traceFile, Statistics statistics, HazelcastClient hazelcastClient, string scenarioId, ArrayList outputLinks, ITimeSpan timeHorizon, bool isEnabled, WebServiceManager webServiceManager) { this.traceFile = traceFile; this.statistics = statistics; this.hazelcastClient = hazelcastClient; this.scenarioId = scenarioId; this.isEnabled = isEnabled; this.webServiceManager = webServiceManager; mapValueSet = hazelcastClient.getMap<string, ValueSetEntry>("valueSet"); queueValueSetRequest = hazelcastClient.getQueue<ValueSetRequestEntry>("valueSetRequest"); prefetchMonitor = new PrefetchMonitor(outputLinks, traceFile, timeHorizon); }
private static bool TryParse(string input, Parser parser, out ITimeSpan timeSpan) { timeSpan = null; var parsingResult = parser(input); if (parsingResult.Item1.Status == ParsingStatus.Parsed) { timeSpan = parsingResult.Item2; return(true); } return(false); }
public void MoveToTime(ITimeSpan time) { ThrowIfArgument.IsNull(nameof(time), time); var needStart = IsRunning; Stop(); SetStartTime(time); if (needStart) { Start(); } }
public NoteWithCustomTimeAndLength(byte noteNumber, byte channel, byte velocity, byte offVelocity, ITimeSpan time, ITimeSpan length) { NoteNumber = (SevenBitNumber)noteNumber; Channel = (FourBitNumber)channel; Velocity = (SevenBitNumber)velocity; OffVelocity = (SevenBitNumber)offVelocity; Time = time; Length = length; }
/// <summary> /// Converts the string representation of a time span to its <see cref="ITimeSpan"/> equivalent. /// A return value indicates whether the conversion succeeded. /// </summary> /// <param name="input">A string containing a time span to convert.</param> /// <param name="timeSpan">When this method returns, contains the <see cref="ITimeSpan"/> /// equivalent of the time span contained in <paramref name="input"/>, if the conversion succeeded, or /// null if the conversion failed. The conversion fails if the <paramref name="input"/> is null or /// <see cref="String.Empty"/>, or is not of the correct format. This parameter is passed uninitialized; /// any value originally supplied in result will be overwritten.</param> /// <returns>true if <paramref name="input"/> was converted successfully; otherwise, false.</returns> public static bool TryParse(string input, out ITimeSpan timeSpan) { timeSpan = null; foreach (var parser in Parsers.Values) { if (TryParse(input, parser, out timeSpan)) { return(true); } } return(false); }
public long ConvertFrom(ITimeSpan timeSpan, long time, TempoMap tempoMap) { var ticksPerQuarterNoteTimeDivision = tempoMap.TimeDivision as TicksPerQuarterNoteTimeDivision; if (ticksPerQuarterNoteTimeDivision == null) { throw new ArgumentException("Time division is not supported for time span conversion.", nameof(tempoMap)); } var startTimeSpan = TicksToMetricTimeSpan(time, ticksPerQuarterNoteTimeDivision.TicksPerQuarterNote, tempoMap); var endTimeSpan = startTimeSpan + (MetricTimeSpan)timeSpan; return(MetricTimeSpanToTicks(endTimeSpan, ticksPerQuarterNoteTimeDivision.TicksPerQuarterNote, tempoMap) - time); }
/// <summary> /// Resizes group of notes to the specified length treating all notes as single object. /// </summary> /// <param name="notes">Notes to resize.</param> /// <param name="length">New length of the notes collection.</param> /// <param name="distanceCalculationType">Type of distance calculations.</param> /// <param name="tempoMap"></param> /// <exception cref="ArgumentNullException"> /// <para>One of the following errors occured:</para> /// <list type="bullet"> /// <item> /// <description><paramref name="notes"/> is <c>null</c>.</description> /// </item> /// <item> /// <description><paramref name="length"/> is <c>null</c>.</description> /// </item> /// <item> /// <description><paramref name="tempoMap"/> is <c>null</c>.</description> /// </item> /// </list> /// </exception> /// <exception cref="ArgumentException"><see cref="TimeSpanType.BarBeatTicks"/> or <see cref="TimeSpanType.BarBeatFraction"/> /// is used for <paramref name="distanceCalculationType"/> which is unsupported.</exception> /// <exception cref="InvalidEnumArgumentException"><paramref name="distanceCalculationType"/> specified an /// invalid value.</exception> public static void ResizeNotes(this IEnumerable <Note> notes, ITimeSpan length, TimeSpanType distanceCalculationType, TempoMap tempoMap) { ThrowIfArgument.IsNull(nameof(notes), notes); ThrowIfArgument.IsNull(nameof(length), length); ThrowIfArgument.IsInvalidEnumValue(nameof(distanceCalculationType), distanceCalculationType); ThrowIfArgument.IsNull(nameof(tempoMap), tempoMap); // Unable to calculate ratio between two bar/beat time spans if (distanceCalculationType == TimeSpanType.BarBeatTicks || distanceCalculationType == TimeSpanType.BarBeatFraction) { throw new ArgumentException("Bar/beat distance calculation type is not supported.", nameof(distanceCalculationType)); } var notNullNotes = notes.Where(n => n != null); if (!notNullNotes.Any()) { return; } // var minStartTime = long.MaxValue; var maxEndTime = 0L; foreach (var note in notNullNotes) { var noteStartTime = note.Time; var noteEndTime = noteStartTime + note.Length; minStartTime = Math.Min(minStartTime, noteStartTime); maxEndTime = Math.Max(maxEndTime, noteEndTime); } var totalLength = maxEndTime - minStartTime; // var oldLength = LengthConverter.ConvertTo(totalLength, distanceCalculationType, minStartTime, tempoMap); var newLength = LengthConverter.ConvertTo(length, distanceCalculationType, minStartTime, tempoMap); var ratio = TimeSpanUtilities.Divide(newLength, oldLength); var startTime = TimeConverter.ConvertTo(minStartTime, distanceCalculationType, tempoMap); ResizeNotesByRatio(notNullNotes, ratio, distanceCalculationType, tempoMap, startTime); }
public long ConvertFrom(ITimeSpan timeSpan, long time, TempoMap tempoMap) { var mathTimeSpan = (MathTimeSpan)timeSpan; Func <MathTimeSpan, long, TempoMap, long> converter; if (Converters.TryGetValue(mathTimeSpan.Mode, out converter)) { return(converter(mathTimeSpan, time, tempoMap)); } else { throw new ArgumentException($"{mathTimeSpan.Mode} mode is not supported by the converter.", nameof(timeSpan)); } }
private static MathTimeSpan CheckMathTimeSpan(ITimeSpan timeSpan1, ITimeSpan timeSpan2, MathOperation operation, TimeSpanMode mode) { var mathTimeSpan = (operation == MathOperation.Add ? timeSpan1.Add(timeSpan2, mode) : timeSpan1.Subtract(timeSpan2, mode)) as MathTimeSpan; Assert.IsTrue(mathTimeSpan != null && mathTimeSpan.TimeSpan1.Equals(timeSpan1) && mathTimeSpan.TimeSpan2.Equals(timeSpan2) && mathTimeSpan.Operation == operation && mathTimeSpan.Mode == mode, "Result is not a math time span."); return(mathTimeSpan); }
/// <summary> /// Adds a snap point with the specified data at given time. /// </summary> /// <typeparam name="TData">Type of data that will be attached to a snap point.</typeparam> /// <param name="time">Time to add snap point at.</param> /// <param name="data">Data to attach to snap point.</param> /// <returns>An instance of the <see cref="SnapPoint{TData}"/> representing a snap point /// with <paramref name="data"/> at <paramref name="time"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="time"/> is <c>null</c>.</exception> public SnapPoint <TData> AddSnapPoint <TData>(ITimeSpan time, TData data) { ThrowIfArgument.IsNull(nameof(time), time); TimeSpan metricTime = TimeConverter.ConvertTo <MetricTimeSpan>(time, _tempoMap); if (metricTime == TimeSpan.Zero) { metricTime = new TimeSpan(1); } var snapPoint = new SnapPoint <TData>(metricTime, data); _snapPoints.Add(snapPoint); return(snapPoint); }
public static double GetMinTimeSpanDistance(ITimeSpan a, ITimeSpan b) { if (IsOverlapping(a, b)) { return(0); } if (a.EndTime <= b.StartTime) { return(b.StartTime - a.EndTime); } else { return(a.StartTime - b.EndTime); } }
public static void Parse(string input, ITimeSpan expectedTimeSpan) { TimeSpanUtilities.TryParse(input, out var actualTimeSpan); Assert.AreEqual(expectedTimeSpan, actualTimeSpan, "TryParse: incorrect result."); actualTimeSpan = TimeSpanUtilities.Parse(input); Assert.AreEqual(expectedTimeSpan, actualTimeSpan, "Parse: incorrect result."); Assert.AreEqual(expectedTimeSpan, TimeSpanUtilities.Parse(expectedTimeSpan.ToString()), "Parse: string representation was not parsed to the original time span."); }
/// <summary> /// Converts the string representation of a time span to its <see cref="ITimeSpan" /> equivalent. /// A return value indicates whether the conversion succeeded. /// </summary> /// <param name="input">A string containing a time span to convert.</param> /// <param name="timeSpan"> /// When this method returns, contains the <see cref="ITimeSpan" /> /// equivalent of the time span contained in <paramref name="input" />, if the conversion succeeded, or /// null if the conversion failed. The conversion fails if the <paramref name="input" /> is null or /// <see cref="String.Empty" />, or is not of the correct format. This parameter is passed uninitialized; /// any value originally supplied in result will be overwritten. /// </param> /// <returns>true if <paramref name="input" /> was converted successfully; otherwise, false.</returns> public static bool TryParse(string input, out ITimeSpan timeSpan) { timeSpan = null; foreach (var parser in Parsers) { var parsingResult = parser(input); if (parsingResult.Item1.Status == ParsingStatus.Parsed) { timeSpan = parsingResult.Item2; return(true); } } return(timeSpan != null); }
private void SplitByGrid_MultipleSteps(IEnumerable <TObject> inputObjects, ITimeSpan gridStart, IEnumerable <ITimeSpan> gridSteps, Dictionary <TObject, IEnumerable <TimeAndLength> > expectedParts, TempoMap tempoMap) { var expectedObjects = expectedParts .SelectMany(p => p.Value.Select(tl => CloneAndChangeTimeAndLength( p.Key, TimeConverter.ConvertFrom(tl.Time, tempoMap), LengthConverter.ConvertFrom(tl.Length, tl.Time, tempoMap)))) .ToArray(); var actualObjects = Splitter.SplitByGrid(inputObjects, new SteppedGrid(gridStart, gridSteps), tempoMap).ToArray(); ObjectMethods.AssertCollectionsAreEqual(expectedObjects, actualObjects); }
/// <summary> /// Shifts events forward inside <see cref="TrackChunk"/> by the specified distance. /// </summary> /// <param name="trackChunk"><see cref="TrackChunk"/> containing events to shift.</param> /// <param name="distance">Distance to shift events by.</param> /// <param name="tempoMap">Tempo map used for internal distance conversions.</param> /// <exception cref="ArgumentNullException"> /// <para>One of the following errors occured:</para> /// <list type="bullet"> /// <item> /// <description><paramref name="trackChunk"/> is <c>null</c>.</description> /// </item> /// <item> /// <description><paramref name="distance"/> is <c>null</c>.</description> /// </item> /// <item> /// <description><paramref name="tempoMap"/> is <c>null</c>.</description> /// </item> /// </list> /// </exception> public static void ShiftEvents(this TrackChunk trackChunk, ITimeSpan distance, TempoMap tempoMap) { ThrowIfArgument.IsNull(nameof(trackChunk), trackChunk); ThrowIfArgument.IsNull(nameof(distance), distance); ThrowIfArgument.IsNull(nameof(tempoMap), tempoMap); var convertedDistance = TimeConverter.ConvertFrom(distance, TempoMap.Create(tempoMap.TimeDivision)); var firstEvent = trackChunk.Events.FirstOrDefault(); if (firstEvent == null) { return; } firstEvent.DeltaTime += convertedDistance; }
/// <summary> /// Splits objects by the specified step so every object will be splitted at points /// equally distanced from each other starting from the object's start time. /// </summary> /// <remarks> /// Nulls, objects with zero length and objects with length smaller than <paramref name="step"/> /// will not be splitted and will be returned as clones of the input objects. /// </remarks> /// <param name="objects">Objects to split.</param> /// <param name="step">Step to split objects by.</param> /// <param name="tempoMap">Tempo map used to calculate times to split by.</param> /// <returns>Objects that are result of splitting <paramref name="objects"/> going in the same /// order as elements of <paramref name="objects"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="objects"/> is null. -or- /// <paramref name="step"/> is null. -or- <paramref name="tempoMap"/> is null.</exception> public IEnumerable <TObject> SplitByStep(IEnumerable <TObject> objects, ITimeSpan step, TempoMap tempoMap) { ThrowIfArgument.IsNull(nameof(objects), objects); ThrowIfArgument.IsNull(nameof(step), step); ThrowIfArgument.IsNull(nameof(tempoMap), tempoMap); foreach (var obj in objects) { if (obj == null) { yield return(default(TObject)); continue; } if (obj.Length == 0) { yield return(CloneObject(obj)); continue; } var startTime = obj.Time; var endTime = startTime + obj.Length; var time = startTime; var tail = CloneObject(obj); while (time < endTime && tail != null) { var convertedStep = LengthConverter.ConvertFrom(step, time, tempoMap); if (convertedStep == 0) { throw new InvalidOperationException("Step is too small."); } time += convertedStep; var parts = SplitObject(tail, time); yield return(parts.LeftPart); tail = parts.RightPart; } } }
public InternalLink(ILinkableComponent1 component1Target, IInputExchangeItem target1, ITimeSpan timeHorizon, IValueSetConverterTime convertor, bool isVector) { _component1Source = new DummyComponent1Source(timeHorizon, convertor, isVector); _component1Target = component1Target; _quantity1 = target1.Quantity; _elementSet1 = target1.ElementSet; }
public DummyComponent1Base(ITimeSpan timeHorizon) { _timeHorizon = timeHorizon; _earliestInputTime = _timeHorizon.Start; }
public DummyComponent1Source(ITimeSpan timeHorizon, IValueSetConverterTime convertor, bool isVector) : base(timeHorizon) { _convertor = convertor; _isVector = isVector; }
public DummyComponent1Target(ITimeSpan timeHorizon) : base(timeHorizon) { }
/// <summary> /// Initializes this listener to show progress of simulation using events. /// </summary> /// <param name="simulationTimeHorizon">Time horizon of whole simulation.</param> /// <param name="progressBar">Progress bar where simulation progress will be shown.</param> /// <remarks>Typically <c>simulationTimeHorizon</c> is defined as time from earliest model start /// to latest model end.</remarks> public void Initialize( ITimeSpan simulationTimeHorizon, ProgressBar progressBar ) { _progressBar = progressBar; _simulationTimeHorizon = simulationTimeHorizon; _maximumTime = simulationTimeHorizon.Start.ModifiedJulianDay; _progressBar.Minimum = 0; _progressBar.Maximum = ProgressBarMaximum; }
/// <summary> /// A ValueSet corresponding to a TimeSpan is calculated using interpolation or /// extrapolation in corresponding lists of ValueSets and TimeStamps. /// </summary> /// <param name="requestedTime">Time for which the ValueSet is requested</param> /// <returns>ValueSet that corresponds to requestedTime</returns> private IValueSet MapFromTimeStampsToTimeSpan(ITimeSpan requestedTime) { try { int m = ((IValueSet)_values[0]).Count; //int N = _times.Count; // Number of time steps in buffer double[][] xr = new double[m][]; // Values to return double trb = requestedTime.Start.ModifiedJulianDay; // Begin time in requester time interval double tre = requestedTime.End.ModifiedJulianDay; // End time in requester time interval int nk; // number of components (scalars has only 1 and vectors has 3 (3 axis)) if (_values[0] is IVectorSet) { nk = 3; } else { nk = 1; } for (int i = 0; i < m; i++) { xr[i] = new double[nk]; } for (int i = 0; i < m; i++) { for (int k = 0; k < nk; k++) { xr[i][k] = 0; } } for (int n = 0; n < _times.Count-1; n++) { double tbn = ((ITimeStamp) _times[n]).ModifiedJulianDay; double tbnp1 = ((ITimeStamp) _times[n+1]).ModifiedJulianDay; //--------------------------------------------------------------------------- // B: <--------------------------> // R: <-------------------------------------> // -------------------------------------------------------------------------- if (trb <= tbn && tre >= tbnp1 ) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) // for all values coorsponding to the same time interval { double sbin = Support.GetVal((IValueSet)_values[n], i, k); double sbinp1 = Support.GetVal((IValueSet)_values[n+1], i, k); xr[i][k-1] += 0.5 * (sbin + sbinp1) * (tbnp1 - tbn)/(tre - trb); } } } //--------------------------------------------------------------------------- // Times[i] Interval: t1|-----------------------|t2 // Requested Interval: rt1|--------------|rt2 // -------------------------------------------------------------------------- else if (tbn <= trb && tre <= tbnp1) //cover all { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) // for all values coorsponding to the same time interval { double sbin = Support.GetVal((IValueSet)_values[n], i, k); double sbinp1 = Support.GetVal((IValueSet)_values[n+1], i, k); xr[i][k-1] += sbin + ((sbinp1 - sbin)/(tbnp1 - tbn))*((tre + trb)/2 - tbn); } } } //--------------------------------------------------------------------------- // Times[i] Interval: t1|-----------------|t2 // Requested Interval: rt1|--------------|rt2 // -------------------------------------------------------------------------- else if (tbn < trb && trb < tbnp1 && tre > tbnp1) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) // for all values coorsponding to the same time interval { double sbin = Support.GetVal((IValueSet)_values[n], i, k); double sbinp1 = Support.GetVal((IValueSet)_values[n+1], i, k); xr[i][k-1] += (sbinp1 - (sbinp1 - sbin)/(tbnp1 - tbn)*((tbnp1 - trb)/2))* (tbnp1 - trb)/(tre - trb); } } } //--------------------------------------------------------------------------- // Times[i] Interval: t1|-----------------|t2 // Requested Interval: rt1|--------------|rt2 // -------------------------------------------------------------------------- else if (trb < tbn && tre > tbn && tre < tbnp1) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) // for all values coorsponding to the same time interval { double sbin = Support.GetVal((IValueSet)_values[n], i, k); double sbinp1 = Support.GetVal((IValueSet)_values[n+1], i, k); xr[i][k-1] += (sbin + (sbinp1 - sbin)/(tbnp1 - tbn)*((tre - tbn)/2)) * (tre - tbn)/(tre - trb); } } } } //-------------------------------------------------------------------------- // |--------|---------|--------| B // |----------------| R //--------------------------------------------------------------------------- double tb0 = ((ITimeStamp) _times[0]).ModifiedJulianDay; //double tb1 = ((ITimeStamp) _times[0]).ModifiedJulianDay; double tb1 = ((ITimeStamp) _times[1]).ModifiedJulianDay; // line above was corrected to this Gregersen Sep 15 2004 double tbN_1 = ((ITimeStamp) _times[_times.Count-1]).ModifiedJulianDay; double tbN_2 = ((ITimeStamp) _times[_times.Count-2]).ModifiedJulianDay; if (trb < tb0 && tre > tb0) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) { double sbi0 = Support.GetVal((IValueSet)_values[0], i, k); double sbi1 = Support.GetVal((IValueSet)_values[1], i, k); xr[i][k-1] += ((tb0 - trb)/(tre - trb)) * (sbi0 - (1 - _relaxationFactor) * 0.5 * ((tb0 - trb)*(sbi1 - sbi0)/(tb1 - tb0))); } } } //------------------------------------------------------------------------------------- // |--------|---------|--------| B // |----------------| R //------------------------------------------------------------------------------------- if (tre > tbN_1 && trb < tbN_1) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) { double sbiN_1 = Support.GetVal((IValueSet)_values[_times.Count-1], i, k); double sbiN_2 = Support.GetVal((IValueSet)_values[_times.Count-2], i, k); xr[i][k-1] += ((tre - tbN_1)/(tre - trb)) * (sbiN_1 + (1 - _relaxationFactor) * 0.5 * ((tre - tbN_1)*(sbiN_1 - sbiN_2)/(tbN_1 - tbN_2))); } } } //------------------------------------------------------------------------------------- // |--------|---------|--------| B // |----------------| R //------------------------------------------------------------------------------------- if (trb >= tbN_1) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) { double sbiN_1 = Support.GetVal((IValueSet)_values[_times.Count-1], i, k); double sbiN_2 = Support.GetVal((IValueSet)_values[_times.Count-2], i, k); xr[i][k-1] = sbiN_1 + (1 - _relaxationFactor) * ((sbiN_1 - sbiN_2)/(tbN_1 - tbN_2)) * ( 0.5 * (trb + tre) - tbN_1); } } } //------------------------------------------------------------------------------------- // |--------|---------|--------| B // |----------------| R //------------------------------------------------------------------------------------- if (tre <= tb0) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) { double sbi0 = Support.GetVal((IValueSet)_values[0], i, k); double sbi1 = Support.GetVal((IValueSet)_values[1], i, k); xr[i][k-1] = sbi0 - (1 - _relaxationFactor) * ((sbi1 - sbi0)/(tb1- tb0))*(tb0 - 0.5 * (trb + tre)); } } } //------------------------------------------------------------------------------------- if (_values[0] is IVectorSet) { Vector [] vectors = new Vector[m]; for (int i = 0; i < m; i++) { vectors[i] = new Vector(xr[i][0],xr[i][1],xr[i][2]); } VectorSet vectorSet = new VectorSet(vectors); return vectorSet; } else { double[] xx = new double[m]; for (int i = 0; i < m; i++) { xx[i] = xr[i][0]; } ScalarSet scalarSet = new ScalarSet(xx); return scalarSet; } } catch (Exception e) { throw new Exception("MapFromTimeStampsToTimeSpan Failed",e); } }
/// <summary> /// Creates a new instance of <see cref="ProgressBarListener">ProgressBarListener</see> class. /// </summary> /// <param name="simulationTimeHorizon">Time horizon of whole simulation.</param> /// <param name="progressBar">Progress bar.</param> /// <remarks>See <see cref="Initialize">Initialize</see> /// for more details.</remarks> public ProgressBarListener( ITimeSpan simulationTimeHorizon, ProgressBar progressBar ) { Initialize( simulationTimeHorizon, progressBar ); }
/// <summary> /// A ValueSet corresponding to a TimeSpan is calculated using interpolation or /// extrapolation in corresponding lists of ValueSets and TimeSpans. /// </summary> /// <param name="requestedTime">Time for which the ValueSet is requested</param> /// <returns>ValueSet that corresponds to requestedTime</returns> private IValueSet MapFromTimeSpansToTimeSpan(ITimeSpan requestedTime) { try { int m = ((IValueSet)_values[0]).Count; double[][] xr = new double[m][]; // Values to return double trb = requestedTime.Start.ModifiedJulianDay; // Begin time in requester time interval double tre = requestedTime.End.ModifiedJulianDay; // End time in requester time interval int nk; // number of components (scalars has only 1 and vectors has 3 (3 axis)) if (_values[0] is IVectorSet) { nk = 3; } else { nk = 1; } for (int i = 0; i < m; i++) { xr[i] = new double[nk]; } for (int i = 0; i < m; i++) { for (int k = 0; k < nk; k++) { xr[i][k] = 0; } } for (int n = 0; n < _times.Count; n++) { double tbbn = ((ITimeSpan) _times[n]).Start.ModifiedJulianDay; double tben = ((ITimeSpan) _times[n]).End.ModifiedJulianDay; //--------------------------------------------------------------------------- // B: <--------------------------> // R: <-------------------------------------> // -------------------------------------------------------------------------- if (trb <= tbbn && tre >= tben ) //Buffered TimeSpan fully included in requested TimeSpan { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) // for all values coorsponding to the same time interval { double sbin = Support.GetVal((IValueSet)_values[n], i, k); xr[i][k-1] += sbin * (tben - tbbn)/(tre - trb); } } } //--------------------------------------------------------------------------- // Times[i] Interval: t1|-----------------------|t2 // Requested Interval: rt1|--------------|rt2 // -------------------------------------------------------------------------- else if (tbbn <= trb && tre <= tben) //cover all { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) // for all values coorsponding to the same time interval { xr[i][k-1] += Support.GetVal((IValueSet)_values[n], i, k); } } } //--------------------------------------------------------------------------- // Times[i] Interval: t1|-----------------|t2 // Requested Interval: rt1|--------------|rt2 // -------------------------------------------------------------------------- else if (tbbn < trb && trb < tben && tre > tben) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) // for all values coorsponding to the same time interval { double sbin = Support.GetVal((IValueSet)_values[n], i, k); xr[i][k-1] += sbin * (tben - trb)/(tre - trb); } } } //--------------------------------------------------------------------------- // Times[i] Interval: t1|-----------------|t2 // Requested Interval: rt1|--------------|rt2 // -------------------------------------------------------------------------- else if (trb < tbbn && tre > tbbn && tre < tben) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) // for all values coorsponding to the same time interval { double sbin = Support.GetVal((IValueSet)_values[n], i, k); xr[i][k-1] += sbin * (tre - tbbn)/(tre - trb); } } } } //-------------------------------------------------------------------------- // |--------|---------|--------| B // |----------------| R //--------------------------------------------------------------------------- double tbb0 = ((ITimeSpan) _times[0]).Start.ModifiedJulianDay; double tbe0 = ((ITimeSpan) _times[0]).End.ModifiedJulianDay; //double tbb1 = ((ITimeSpan) _times[1]).Start.ModifiedJulianDay; double tbe1 = ((ITimeSpan) _times[1]).End.ModifiedJulianDay; if (trb < tbb0 && tre > tbb0) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) { double sbi0 = Support.GetVal((IValueSet)_values[0], i, k); double sbi1 = Support.GetVal((IValueSet)_values[1], i, k); xr[i][k-1] += ((tbb0 - trb)/(tre - trb)) * (sbi0 - (1 - _relaxationFactor) * ((tbb0 - trb)*(sbi1 - sbi0)/(tbe1 - tbe0))); } } } //------------------------------------------------------------------------------------- // |--------|---------|--------| B // |----------------| R //------------------------------------------------------------------------------------- double tbeN_1 = ((ITimeSpan) _times[_times.Count-1]).End.ModifiedJulianDay; double tbbN_2 = ((ITimeSpan) _times[_times.Count-2]).Start.ModifiedJulianDay; if (tre > tbeN_1 && trb < tbeN_1) { //double tbeN_2 = ((ITimeSpan) _times[_times.Count-2]).End.ModifiedJulianDay; double tbbN_1 = ((ITimeSpan) _times[_times.Count-1]).Start.ModifiedJulianDay; for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) { double sbiN_1 = Support.GetVal((IValueSet)_values[_times.Count-1], i, k); double sbiN_2 = Support.GetVal((IValueSet)_values[_times.Count-2], i,k); xr[i][k-1] += ((tre - tbeN_1)/(tre - trb)) * (sbiN_1 + (1 - _relaxationFactor) * ((tre - tbbN_1)*(sbiN_1 - sbiN_2)/(tbeN_1 - tbbN_2))); } } } //------------------------------------------------------------------------------------- // |--------|---------|--------| B // |----------------| R //------------------------------------------------------------------------------------- if (trb >= tbeN_1) { double tbeN_2 = ((ITimeSpan) _times[_times.Count-2]).End.ModifiedJulianDay; //double tbbN_1 = ((ITimeSpan) _times[_times.Count-1]).Start.ModifiedJulianDay; for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) { double sbiN_1 = Support.GetVal((IValueSet)_values[_times.Count-1], i, k); double sbiN_2 = Support.GetVal((IValueSet)_values[_times.Count-2], i, k); xr[i][k-1] = sbiN_1 + (1 - _relaxationFactor) * ((sbiN_1 - sbiN_2)/(tbeN_1 - tbbN_2)) * (trb + tre - tbeN_1 - tbeN_2); } } } //------------------------------------------------------------------------------------- // |--------|---------|--------| B // |----------------| R //------------------------------------------------------------------------------------- if (tre <= tbb0) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) { double sbi0 = Support.GetVal((IValueSet)_values[0], i, k); double sbi1 = Support.GetVal((IValueSet)_values[1], i, k); xr[i][k-1] = sbi0 - (1 - _relaxationFactor) * ((sbi1 - sbi0)/(tbe1- tbb0))*(tbe0 + tbb0 - tre - trb); } } } //------------------------------------------------------------------------------------- if (_values[0] is IVectorSet) { Vector [] vectors = new Vector[m]; for (int i = 0; i < m; i++) { vectors[i] = new Vector(xr[i][0],xr[i][1],xr[i][2]); } VectorSet vectorSet = new VectorSet(vectors); return vectorSet; } else { double[] xx = new double[m]; for (int i = 0; i < m; i++) { xx[i] = xr[i][0]; } ScalarSet scalarSet = new ScalarSet(xx); return scalarSet; } } catch (Exception e) { throw new Exception("MapFromTimeSpansToTimeSpan Failed",e); } }
/// <summary> /// Copy constructor /// </summary> /// <param name="source">The time span to copy</param> public TimeSpan(ITimeSpan source) { Start = new TimeStamp(source.Start); End = new TimeStamp(source.End); }
/// <summary> /// Clears the buffer between start- and end- time of the time (TimeSpan). /// </summary> public void Clear(ITimeSpan time) //TODO: This method may not be used anywhere. Check if this is true and then remove this method { if (_times.Count > 0) { if(_times[0] is ITimeStamp) { for (int i = 0; i < _times.Count; i++) { if (((ITimeStamp)_times[i]).ModifiedJulianDay > time.Start.ModifiedJulianDay && ((ITimeStamp)_times[i]).ModifiedJulianDay < time.End.ModifiedJulianDay) { _times.RemoveAt(i); _values.RemoveAt(i); } } } else if (_times[0] is ITimeSpan) { for (int i = 0; i < _times.Count; i++) { if (((ITimeSpan)_times[i]).Start.ModifiedJulianDay > time.Start.ModifiedJulianDay && ((ITimeSpan)_times[i]).End.ModifiedJulianDay < time.End.ModifiedJulianDay) { _times.RemoveAt(i); _values.RemoveAt(i); } } } } }
public InternalLink(ILinkableComponent1 component1Source, IOutputExchangeItem source1, ITimeSpan timeHorizon) { _component1Source = component1Source; _component1Target = new DummyComponent1Target(timeHorizon); _quantity1 = source1.Quantity; _elementSet1 = source1.ElementSet; }