/// <summary> /// Computes a set of outgoing transitions from a given state of the determinization result. /// </summary> /// <param name="sourceStateSet">The source state of the determinized automaton represented as /// a set of (stateId, weight) pairs, where state ids correspond to states of the original automaton.</param> /// <returns> /// A collection of (element distribution, weight, weighted state set) triples corresponding to outgoing /// transitions from <paramref name="sourceStateSet"/>. /// The first two elements of a tuple define the element distribution and the weight of a transition. /// The third element defines the outgoing state. /// </returns> protected override IEnumerable <Determinization.OutgoingTransition> GetOutgoingTransitionsForDeterminization( Determinization.WeightedStateSet sourceStateSet) { // Build a list of numbered non-zero probability character segment bounds (they are numbered here due to perf. reasons) var segmentBounds = new List <TransitionCharSegmentBound>(); for (var i = 0; i < sourceStateSet.Count; ++i) { var sourceState = sourceStateSet[i]; var state = this.States[sourceState.Index]; foreach (var transition in state.Transitions) { AddTransitionCharSegmentBounds(transition, sourceState.Weight, segmentBounds); } } segmentBounds.Sort(); // Produce an outgoing transition for each unique subset of overlapping segments var currentSegmentTotal = WeightSum.Zero(); var currentSegmentStateWeights = new Dictionary <int, WeightSum>(); var currentSegmentStart = (int)char.MinValue; var destinationStateSetBuilder = Determinization.WeightedStateSetBuilder.Create(); foreach (var segmentBound in segmentBounds) { if (currentSegmentTotal.Count != 0 && currentSegmentStart < segmentBound.Bound) { // Flush previous segment var segmentEnd = (char)(segmentBound.Bound - 1); var segmentLength = segmentEnd - currentSegmentStart + 1; var elementDist = DiscreteChar.InRange((char)currentSegmentStart, segmentEnd); var invTotalWeight = Weight.Inverse(currentSegmentTotal.Sum); destinationStateSetBuilder.Reset(); foreach (var stateIdWithWeight in currentSegmentStateWeights) { var stateWeight = stateIdWithWeight.Value.Sum * invTotalWeight; destinationStateSetBuilder.Add(stateIdWithWeight.Key, stateWeight); } var(destinationStateSet, destinationStateSetWeight) = destinationStateSetBuilder.Get(); var transitionWeight = Weight.Product( Weight.FromValue(segmentLength), currentSegmentTotal.Sum, destinationStateSetWeight); yield return(new Determinization.OutgoingTransition( elementDist, transitionWeight, destinationStateSet)); } // Update current segment currentSegmentStart = segmentBound.Bound; if (segmentBound.IsStart) { currentSegmentTotal += segmentBound.Weight; if (currentSegmentStateWeights.TryGetValue(segmentBound.DestinationStateId, out var stateWeight)) { currentSegmentStateWeights[segmentBound.DestinationStateId] = stateWeight + segmentBound.Weight; } else { currentSegmentStateWeights[segmentBound.DestinationStateId] = new WeightSum(segmentBound.Weight); } } else { Debug.Assert(currentSegmentStateWeights.ContainsKey(segmentBound.DestinationStateId), "We shouldn't exit a state we didn't enter."); Debug.Assert(!segmentBound.Weight.IsInfinity); currentSegmentTotal -= segmentBound.Weight; var prevStateWeight = currentSegmentStateWeights[segmentBound.DestinationStateId]; var newStateWeight = prevStateWeight - segmentBound.Weight; if (newStateWeight.Count == 0) { currentSegmentStateWeights.Remove(segmentBound.DestinationStateId); } else { currentSegmentStateWeights[segmentBound.DestinationStateId] = newStateWeight; } } } }
/// <summary> /// Computes a set of outgoing transitions from a given state of the determinization result. /// </summary> /// <param name="sourceState">The source state of the determinized automaton represented as /// a set of (stateId, weight) pairs, where state ids correspond to states of the original automaton.</param> /// <returns> /// A collection of (element distribution, weight, weighted state set) triples corresponding to outgoing transitions from <paramref name="sourceState"/>. /// The first two elements of a tuple define the element distribution and the weight of a transition. /// The third element defines the outgoing state. /// </returns> protected override List <(DiscreteChar, Weight, Determinization.WeightedStateSet)> GetOutgoingTransitionsForDeterminization( Determinization.WeightedStateSet sourceState) { const double LogEps = -35; // Don't add transitions with log-weight less than this as they have been produced by numerical inaccuracies // Build a list of numbered non-zero probability character segment bounds (they are numbered here due to perf. reasons) var segmentBounds = new List <ValueTuple <int, TransitionCharSegmentBound> >(); int transitionsProcessed = 0; foreach (KeyValuePair <int, Weight> stateIdWeight in sourceState) { var state = this.States[stateIdWeight.Key]; foreach (var transition in state.Transitions) { AddTransitionCharSegmentBounds(transition, stateIdWeight.Value, segmentBounds); } transitionsProcessed += state.Transitions.Count; } // Sort segment bounds left-to-right, start-to-end var sortedIndexedSegmentBounds = segmentBounds.ToArray(); if (transitionsProcessed > 1) { Array.Sort(sortedIndexedSegmentBounds, CompareSegmentBounds); int CompareSegmentBounds((int, TransitionCharSegmentBound) a, (int, TransitionCharSegmentBound) b) => a.Item2.CompareTo(b.Item2); } // Produce an outgoing transition for each unique subset of overlapping segments var result = new List <(DiscreteChar, Weight, Determinization.WeightedStateSet)>(); Weight currentSegmentStateWeightSum = Weight.Zero; var currentSegmentStateWeights = new Dictionary <int, Weight>(); foreach (var sb in segmentBounds) { currentSegmentStateWeights[sb.Item2.DestinationStateId] = Weight.Zero; } var activeSegments = new HashSet <TransitionCharSegmentBound>(); int currentSegmentStart = char.MinValue; foreach (var tup in sortedIndexedSegmentBounds) { TransitionCharSegmentBound segmentBound = tup.Item2; if (currentSegmentStateWeightSum.LogValue > LogEps && currentSegmentStart < segmentBound.Bound) { // Flush previous segment char segmentEnd = (char)(segmentBound.Bound - 1); int segmentLength = segmentEnd - currentSegmentStart + 1; DiscreteChar elementDist = DiscreteChar.InRange((char)currentSegmentStart, segmentEnd); var destinationState = new Determinization.WeightedStateSet(); foreach (KeyValuePair <int, Weight> stateIdWithWeight in currentSegmentStateWeights) { if (stateIdWithWeight.Value.LogValue > LogEps) { Weight stateWeight = Weight.Product(stateIdWithWeight.Value, Weight.Inverse(currentSegmentStateWeightSum)); destinationState.Add(stateIdWithWeight.Key, stateWeight); } } Weight transitionWeight = Weight.Product(Weight.FromValue(segmentLength), currentSegmentStateWeightSum); result.Add((elementDist, transitionWeight, destinationState)); } // Update current segment currentSegmentStart = segmentBound.Bound; if (segmentBound.IsStart) { activeSegments.Add(segmentBound); currentSegmentStateWeightSum = Weight.Sum(currentSegmentStateWeightSum, segmentBound.Weight); currentSegmentStateWeights[segmentBound.DestinationStateId] = Weight.Sum(currentSegmentStateWeights[segmentBound.DestinationStateId], segmentBound.Weight); } else { Debug.Assert(currentSegmentStateWeights.ContainsKey(segmentBound.DestinationStateId), "We shouldn't exit a state we didn't enter."); activeSegments.Remove(segmentBounds[tup.Item1 - 1].Item2); // End follows start in original. if (double.IsInfinity(segmentBound.Weight.Value)) { // Cannot subtract because of the infinities involved. currentSegmentStateWeightSum = activeSegments.Select(sb => sb.Weight).Aggregate(Weight.Zero, (acc, w) => Weight.Sum(acc, w)); currentSegmentStateWeights[segmentBound.DestinationStateId] = activeSegments.Where(sb => sb.DestinationStateId == segmentBound.DestinationStateId).Select(sb => sb.Weight).Aggregate(Weight.Zero, (acc, w) => Weight.Sum(acc, w)); } else { currentSegmentStateWeightSum = activeSegments.Count == 0 ? Weight.Zero : Weight.AbsoluteDifference(currentSegmentStateWeightSum, segmentBound.Weight); Weight prevStateWeight = currentSegmentStateWeights[segmentBound.DestinationStateId]; currentSegmentStateWeights[segmentBound.DestinationStateId] = Weight.AbsoluteDifference( prevStateWeight, segmentBound.Weight); } } } return(result); }
/// <summary> /// Creates a sequence to weight dictionary using the supplied <paramref name="sequenceWeightPairs"/>. /// If the supplied collection is expected to not contain multiple entries for the same sequence. /// </summary> /// <param name="sequenceWeightPairs">The collection of pairs of a sequence and the weight on that sequence.</param> public static TThis FromDistinctValues(IEnumerable <KeyValuePair <TSequence, double> > sequenceWeightPairs) => FromDistinctWeights(sequenceWeightPairs.Select(kvp => new KeyValuePair <TSequence, Weight>(kvp.Key, Weight.FromValue(kvp.Value))));