public void Equals_SameTuples_ReturnsTrue()
{
var tuple1 = UnorderedTuple.Create("A", "B", "C");
var tuple2 = UnorderedTuple.Create("A", "B", "C");
Assert.That(tuple1.Equals(tuple2), Is.True);
}
private void AddToLookupDictionary(int index, CognacyDecision item)
{
Dictionary <Meaning, int> lookup = _lookupDictionary.GetValue(UnorderedTuple.Create(item.Variety1, item.Variety2),
() => new Dictionary <Meaning, int>());
lookup[item.Meaning] = index;
}
public void GetHashCode_DifferentTuples_HashCodesNotEqual()
{
var tuple1 = UnorderedTuple.Create("A", "B", "D");
var tuple2 = UnorderedTuple.Create("A", "B", "C");
Assert.That(tuple1.GetHashCode(), Is.Not.EqualTo(tuple2.GetHashCode()));
}
public void GetHashCode_SameTuplesDifferentTypesInDifferentOrder_HashCodesEqual()
{
var tuple1 = UnorderedTuple.Create("A", "B", 0);
var tuple2 = UnorderedTuple.Create("B", "A", 0);
Assert.That(tuple1.GetHashCode(), Is.EqualTo(tuple2.GetHashCode()));
}
public void GetHashCode_SameTuples_HashCodesEqual()
{
var tuple1 = UnorderedTuple.Create("A", "B", "C");
var tuple2 = UnorderedTuple.Create("A", "B", "C");
Assert.That(tuple1.GetHashCode(), Is.EqualTo(tuple2.GetHashCode()));
}
public void Equals_SameTuplesDifferentTypesInDifferentOrder_ReturnsTrue()
{
var tuple1 = UnorderedTuple.Create("A", "B", 0);
var tuple2 = UnorderedTuple.Create("B", "A", 0);
Assert.That(tuple1.Equals(tuple2), Is.True);
}
public void Equals_DifferentTuples_ReturnsFalse()
{
var tuple1 = UnorderedTuple.Create("A", "B", "D");
var tuple2 = UnorderedTuple.Create("A", "B", "C");
Assert.That(tuple1.Equals(tuple2), Is.False);
}
private IEnumerable <UnorderedTuple <string, string> > ParseMappings(XElement elem)
{
foreach (XElement mappingElem in elem.Elements(ConfigManager.Cog + "Mapping"))
{
yield return(UnorderedTuple.Create((string)mappingElem.Attribute("segment1"), (string)mappingElem.Attribute("segment2")));
}
}
public void IsMapped_ImplicitComplexSegments()
{
var segmentPool = new SegmentPool();
var mappings = new ListSegmentMappings(_segmenter, new[]
{
UnorderedTuple.Create("m", "n"),
UnorderedTuple.Create("t", "-"),
UnorderedTuple.Create("h#", "-#"),
UnorderedTuple.Create("c", "#g"),
UnorderedTuple.Create("f", "@")
}, true);
Shape shape1 = _segmenter.Segment("s͡mat͡h");
Shape shape2 = _segmenter.Segment("k͡no");
Assert.That(mappings.IsMapped(shape1.First.Prev, segmentPool.Get(shape1.First), shape1.First.Next, shape2.First.Prev, segmentPool.Get(shape2.First), shape2.First.Next), Is.True);
Assert.That(mappings.IsMapped(shape1.Last.Prev, segmentPool.Get(shape1.Last), shape1.Last.Next, shape2.Last, new Ngram <Segment>(), shape2.Last.Next), Is.True);
Assert.That(mappings.IsMapped(shape1.First, segmentPool.Get(shape1.First.Next), shape1.Last, shape2.First, segmentPool.Get(shape2.Last), shape2.Last.Next), Is.False);
shape1 = _segmenter.Segment("got͡h");
shape2 = _segmenter.Segment("c͡lo");
Assert.That(mappings.IsMapped(shape1.First.Prev, segmentPool.Get(shape1.First), shape1.First.Next, shape2.First.Prev, segmentPool.Get(shape2.First), shape2.First.Next), Is.True);
Assert.That(mappings.IsMapped(shape1.Last.Prev, segmentPool.Get(shape1.Last), shape1.Last.Next, shape2.Last, new Ngram <Segment>(), shape2.Last.Next), Is.True);
shape1 = _segmenter.Segment("s͡hog");
shape2 = _segmenter.Segment("oc͡t");
Assert.That(mappings.IsMapped(shape1.First.Prev, segmentPool.Get(shape1.First), shape1.First.Next, shape2.First.Prev, new Ngram <Segment>(), shape2.First), Is.False);
Assert.That(mappings.IsMapped(shape1.Last.Prev, segmentPool.Get(shape1.Last), shape1.Last.Next, shape2.Last.Prev, segmentPool.Get(shape2.Last), shape2.Last.Next), Is.False);
}
public static IEnumerable <Cluster <Word> > GenerateCognateSets(this CogProject project, Meaning meaning)
{
var words = new HashSet <Word>();
var noise = new HashSet <Word>();
foreach (VarietyPair vp in project.VarietyPairs)
{
WordPair wp;
if (vp.WordPairs.TryGetValue(meaning, out wp))
{
if (wp.AreCognatePredicted)
{
words.Add(wp.Word1);
words.Add(wp.Word2);
noise.Remove(wp.Word1);
noise.Remove(wp.Word2);
}
else
{
if (!words.Contains(wp.Word1))
{
noise.Add(wp.Word1);
}
if (!words.Contains(wp.Word2))
{
noise.Add(wp.Word2);
}
}
}
}
double min = double.MaxValue, max = double.MinValue;
var distanceMatrix = new Dictionary <UnorderedTuple <Word, Word>, double>();
Word[] wordArray = words.ToArray();
for (int i = 0; i < wordArray.Length; i++)
{
for (int j = i + 1; j < wordArray.Length; j++)
{
Word w1 = wordArray[i];
Word w2 = wordArray[j];
double score = 0;
WordPair wp;
if (w1.Variety != w2.Variety && w1.Variety.VarietyPairs[w2.Variety].WordPairs.TryGetValue(meaning, out wp) && wp.AreCognatePredicted &&
wp.GetWord(w1.Variety) == w1 && wp.GetWord(w2.Variety) == w2)
{
score = wp.CognicityScore;
}
double distance = 1.0 - score;
min = Math.Min(min, distance);
max = Math.Max(max, distance);
distanceMatrix[UnorderedTuple.Create(w1, w2)] = distance;
}
}
var clusterer = new FlatUpgmaClusterer <Word>((w1, w2) => distanceMatrix[UnorderedTuple.Create(w1, w2)], (max + min) / 2);
return(clusterer.GenerateClusters(words).Concat(new Cluster <Word>(noise, true)));
}
protected override void MoveItem(int oldIndex, int newIndex)
{
CognacyDecision item = Items[oldIndex];
UnorderedTuple <Variety, Variety> key = UnorderedTuple.Create(item.Variety1, item.Variety2);
_lookupDictionary[key][item.Meaning] = newIndex;
base.MoveItem(oldIndex, newIndex);
}
private static int AddEdge(Dictionary <UnorderedTuple <object, object>, GlobalCorrespondencesGraphEdge> edges, SoundCorrespondence corr,
object key1, GlobalSegmentVertex vertex1, object key2, GlobalSegmentVertex vertex2)
{
GlobalCorrespondencesGraphEdge edge = edges.GetValue(UnorderedTuple.Create(key1, key2), () => new GlobalCorrespondencesGraphEdge(vertex1, vertex2));
edge.Frequency += corr.Frequency;
edge.DomainWordPairs.AddRange(corr.WordPairs);
return(edge.Frequency);
}
private void RemoveFromLookupDictionary(int index)
{
CognacyDecision item = Items[index];
UnorderedTuple <Variety, Variety> key = UnorderedTuple.Create(item.Variety1, item.Variety2);
Dictionary <Meaning, int> decisions = _lookupDictionary[key];
if (decisions.Remove(item.Meaning) && decisions.Count == 0)
{
_lookupDictionary.Remove(key);
}
}
public bool Remove(WordPair wordPair)
{
Dictionary <Meaning, CognacyDecision> decisions;
UnorderedTuple <Variety, Variety> key = UnorderedTuple.Create(wordPair.VarietyPair.Variety1, wordPair.VarietyPair.Variety2);
if (_lookupDictionary.TryGetValue(key, out decisions))
{
CognacyDecision decision;
if (decisions.TryGetValue(wordPair.Meaning, out decision))
{
return(Remove(decision));
}
}
return(false);
}
public bool?GetCognacy(VarietyPair varietyPair, Meaning meaning)
{
Dictionary <Meaning, CognacyDecision> decisions;
if (_lookupDictionary.TryGetValue(UnorderedTuple.Create(varietyPair.Variety1, varietyPair.Variety2),
out decisions))
{
CognacyDecision decision;
if (decisions.TryGetValue(meaning, out decision))
{
return(decision.Cognacy);
}
}
return(null);
}
public bool?GetCognacy(VarietyPair varietyPair, Meaning meaning)
{
Dictionary <Meaning, int> decisions;
if (_lookupDictionary.TryGetValue(UnorderedTuple.Create(varietyPair.Variety1, varietyPair.Variety2),
out decisions))
{
int index;
if (decisions.TryGetValue(meaning, out index))
{
return(Items[index].Cognacy);
}
}
return(null);
}
public void IsMapped()
{
var segmentPool = new SegmentPool();
var mappings = new ListSegmentMappings(_segmenter, new[]
{
UnorderedTuple.Create("m", "n"),
UnorderedTuple.Create("t", "-"),
UnorderedTuple.Create("h#", "-#"),
UnorderedTuple.Create("c", "#g"),
UnorderedTuple.Create("f", "@"),
UnorderedTuple.Create("a", "o"),
UnorderedTuple.Create("Cw", "-V")
}, false);
Shape shape1 = _segmenter.Segment("ma͡et");
Shape shape2 = _segmenter.Segment("no");
Assert.That(mappings.IsMapped(shape1.First.Prev, segmentPool.Get(shape1.First), shape1.First.Next, shape2.First.Prev, segmentPool.Get(shape2.First), shape2.First.Next), Is.True);
Assert.That(mappings.IsMapped(shape1.Last.Prev, segmentPool.Get(shape1.Last), shape1.Last.Next, shape2.Last, new Ngram <Segment>(), shape2.Last.Next), Is.True);
Assert.That(mappings.IsMapped(shape1.First, segmentPool.Get(shape1.First.Next), shape1.Last, shape2.First, segmentPool.Get(shape2.Last), shape2.Last.Next), Is.False);
shape1 = _segmenter.Segment("goh");
shape2 = _segmenter.Segment("co");
Assert.That(mappings.IsMapped(shape1.First.Prev, segmentPool.Get(shape1.First), shape1.First.Next, shape2.First.Prev, segmentPool.Get(shape2.First), shape2.First.Next), Is.True);
Assert.That(mappings.IsMapped(shape1.Last.Prev, segmentPool.Get(shape1.Last), shape1.Last.Next, shape2.Last, new Ngram <Segment>(), shape2.Last.Next), Is.True);
shape1 = _segmenter.Segment("hog");
shape2 = _segmenter.Segment("oc");
Assert.That(mappings.IsMapped(shape1.First.Prev, segmentPool.Get(shape1.First), shape1.First.Next, shape2.First.Prev, new Ngram <Segment>(), shape2.First), Is.False);
Assert.That(mappings.IsMapped(shape1.Last.Prev, segmentPool.Get(shape1.Last), shape1.Last.Next, shape2.Last.Prev, segmentPool.Get(shape2.Last), shape2.Last.Next), Is.False);
shape1 = _segmenter.Segment("swat");
shape2 = _segmenter.Segment("sat");
Assert.That(mappings.IsMapped(shape1.ElementAt(0), segmentPool.Get(shape1.ElementAt(1)), shape1.ElementAt(2), shape2.ElementAt(0), new Ngram <Segment>(), shape2.ElementAt(1)), Is.True);
shape1 = _segmenter.Segment("sawat");
shape2 = _segmenter.Segment("saat");
Assert.That(mappings.IsMapped(shape1.ElementAt(1), segmentPool.Get(shape1.ElementAt(2)), shape1.ElementAt(3), shape2.ElementAt(1), new Ngram <Segment>(), shape2.ElementAt(2)), Is.False);
}
public bool Remove(WordPair wordPair)
{
Dictionary <Meaning, int> decisions;
UnorderedTuple <Variety, Variety> key = UnorderedTuple.Create(wordPair.VarietyPair.Variety1, wordPair.VarietyPair.Variety2);
if (_lookupDictionary.TryGetValue(key, out decisions))
{
int index;
if (decisions.TryGetValue(wordPair.Meaning, out index))
{
decisions.Remove(wordPair.Meaning);
if (decisions.Count == 0)
{
_lookupDictionary.Remove(key);
}
base.RemoveItem(index);
return(true);
}
}
return(false);
}
private void AddToLookupDictionary(CognacyDecision item)
{
Dictionary <Meaning, CognacyDecision> lookup = _lookupDictionary.GetOrCreate(UnorderedTuple.Create(item.Variety1, item.Variety2),
() => new Dictionary <Meaning, CognacyDecision>());
lookup[item.Meaning] = item;
}
public SegmentMappingsTableViewModel(IProjectService projectService, SegmentMappingsTableSegmentPairViewModel.Factory segmentPairFactory, SegmentMappingViewModel.Factory mappingFactory,
IEnumerable <SegmentMappingViewModel> mappings, SoundType soundType, int threshold)
{
_threshold = threshold;
_soundType = soundType;
FeatureSymbol segmentType;
switch (_soundType)
{
case SoundType.Consonant:
segmentType = CogFeatureSystem.ConsonantType;
break;
case SoundType.Vowel:
segmentType = CogFeatureSystem.VowelType;
break;
default:
throw new InvalidEnumArgumentException();
}
var segmentComparer = new SegmentComparer();
var categoryComparer = new SegmentCategoryComparer();
_segments = new ReadOnlyList <SegmentMappingsTableSegmentViewModel>(projectService.Project.Varieties.SelectMany(v => v.SegmentFrequencyDistribution.ObservedSamples)
.Where(s => s.Type == segmentType).Distinct().OrderBy(s => s.Category(), categoryComparer).ThenBy(s => s, segmentComparer)
.Select(s => new SegmentMappingsTableSegmentViewModel(s, _soundType)).Concat(new SegmentMappingsTableSegmentViewModel(null, _soundType)).ToArray());
_categories = new ReadOnlyList <SegmentCategoryViewModel>(_segments.GroupBy(s => s.DomainSegment == null ? string.Empty : s.DomainSegment.Category())
.OrderBy(g => g.Key, categoryComparer).Select(g => new SegmentCategoryViewModel(g.Key, g)).ToArray());
var mappingLookup = new Dictionary <UnorderedTuple <string, string>, HashSet <UnorderedTuple <string, string> > >();
foreach (SegmentMappingViewModel mapping in mappings)
{
string seg1, seg2;
FeatureSymbol leftEnv1, rightEnv1, leftEnv2, rightEnv2;
if (ListSegmentMappings.Normalize(projectService.Project.Segmenter, mapping.Segment1, out seg1, out leftEnv1, out rightEnv1) &&
ListSegmentMappings.Normalize(projectService.Project.Segmenter, mapping.Segment2, out seg2, out leftEnv2, out rightEnv2))
{
UnorderedTuple <string, string> key = UnorderedTuple.Create(seg1, seg2);
HashSet <UnorderedTuple <string, string> > m = mappingLookup.GetOrCreate(key, () => new HashSet <UnorderedTuple <string, string> >());
m.Add(UnorderedTuple.Create(mapping.Segment1, mapping.Segment2));
}
}
IWordAligner aligner = projectService.Project.WordAligners[ComponentIdentifiers.PrimaryWordAligner];
foreach (SegmentMappingsTableSegmentViewModel segment1 in _segments)
{
bool isEnabled = true;
foreach (SegmentMappingsTableSegmentViewModel segment2 in _segments)
{
if (EqualityComparer <Segment> .Default.Equals(segment1.DomainSegment, segment2.DomainSegment))
{
isEnabled = false;
}
int delta = segment1.DomainSegment == null || segment2.DomainSegment == null ? -1
: aligner.Delta(segment1.DomainSegment.FeatureStruct, segment2.DomainSegment.FeatureStruct);
SegmentMappingsTableSegmentPairViewModel segmentPair = segmentPairFactory(segment1, segment2, delta, isEnabled);
segmentPair.MeetsThreshold = delta != -1 && delta <= _threshold;
HashSet <UnorderedTuple <string, string> > pairMappings;
if (mappingLookup.TryGetValue(UnorderedTuple.Create(segment1.StrRep, segment2.StrRep), out pairMappings))
{
segmentPair.Mappings.Mappings.AddRange(pairMappings.Select(m => mappingFactory(m.Item1, m.Item2)));
}
segment1.SegmentPairs.Add(segmentPair);
}
}
}
protected override UnorderedTuple<Segment, Segment> GetKeyForItem(SoundCorrespondence item)
{
return UnorderedTuple.Create(item.Segment1, item.Segment2);
}
public bool Remove(Segment seg1, Segment seg2)
{
return Remove(UnorderedTuple.Create(seg1, seg2));
}
public bool Contains(Segment seg1, Segment seg2)
{
return Contains(UnorderedTuple.Create(seg1, seg2));
}
public bool TryGet(Segment seg1, Segment seg2, out SoundCorrespondence value)
{
return TryGet(UnorderedTuple.Create(seg1, seg2), out value);
}
public void UpdateComponent()
{
var thresholdSegmentMappings = new ThresholdSegmentMappings(_projectService.Project, _threshold, ComponentIdentifiers.PrimaryWordAligner);
var listSegmentMappings = new ListSegmentMappings(_projectService.Project.Segmenter, _mappings.Mappings.Select(m => UnorderedTuple.Create(m.Segment1, m.Segment2)), _implicitComplexSegments);
SegmentMappings = new UnionSegmentMappings(new ISegmentMappings[] { thresholdSegmentMappings, listSegmentMappings });
}
public IBidirectionalGraph <Cluster <T>, ClusterEdge <T> > GenerateClusters(IEnumerable <T> dataObjects)
{
var tree = new BidirectionalGraph <Cluster <T>, ClusterEdge <T> >(false);
var clusters = new List <Cluster <T> >();
foreach (T dataObject in dataObjects)
{
var cluster = new Cluster <T>(dataObject)
{
Description = dataObject.ToString()
};
clusters.Add(cluster);
tree.AddVertex(cluster);
}
var distances = new Dictionary <UnorderedTuple <Cluster <T>, Cluster <T> >, double>();
var heights = new Dictionary <Cluster <T>, double>();
for (int i = 0; i < clusters.Count; i++)
{
for (int j = i + 1; j < clusters.Count; j++)
{
double distance = _getDistance(clusters[i].DataObjects.First(), clusters[j].DataObjects.First());
if (double.IsNaN(distance) || double.IsInfinity(distance) || distance < 0)
{
throw new ArgumentException("Invalid distance between data objects.", "dataObjects");
}
distances[UnorderedTuple.Create(clusters[i], clusters[j])] = distance;
}
heights[clusters[i]] = 0;
}
while (clusters.Count >= 2)
{
int minI = 0, minJ = 0;
double minDist = double.MaxValue;
for (int i = 0; i < clusters.Count; i++)
{
for (int j = i + 1; j < clusters.Count; j++)
{
double dist = distances[UnorderedTuple.Create(clusters[i], clusters[j])];
if (dist < minDist)
{
minDist = dist;
minI = i;
minJ = j;
}
}
}
Cluster <T> iCluster = clusters[minI];
Cluster <T> jCluster = clusters[minJ];
distances.Remove(UnorderedTuple.Create(iCluster, jCluster));
var uCluster = new Cluster <T>();
tree.AddVertex(uCluster);
double height = minDist / 2;
heights[uCluster] = height;
int iCount = tree.GetAllDataObjects(iCluster).Count();
double iLen = height - heights[iCluster];
if (iLen <= 0 && !tree.IsOutEdgesEmpty(iCluster))
{
foreach (ClusterEdge <T> edge in tree.OutEdges(iCluster))
{
tree.AddEdge(new ClusterEdge <T>(uCluster, edge.Target, edge.Length));
}
tree.RemoveVertex(iCluster);
}
else
{
tree.RemoveInEdgeIf(iCluster, edge => true);
tree.AddEdge(new ClusterEdge <T>(uCluster, iCluster, Math.Max(iLen, 0)));
}
int jCount = tree.GetAllDataObjects(jCluster).Count();
double jLen = height - heights[jCluster];
if (jLen <= 0 && !tree.IsOutEdgesEmpty(jCluster))
{
foreach (ClusterEdge <T> edge in tree.OutEdges(jCluster))
{
tree.AddEdge(new ClusterEdge <T>(uCluster, edge.Target, edge.Length));
}
tree.RemoveVertex(jCluster);
}
else
{
tree.RemoveInEdgeIf(jCluster, edge => true);
tree.AddEdge(new ClusterEdge <T>(uCluster, jCluster, Math.Max(jLen, 0)));
}
double iWeight = (double)iCount / (iCount + jCount);
double jWeight = (double)jCount / (iCount + jCount);
foreach (Cluster <T> kCluster in clusters.Where(c => c != iCluster && c != jCluster))
{
UnorderedTuple <Cluster <T>, Cluster <T> > kiKey = UnorderedTuple.Create(kCluster, iCluster);
UnorderedTuple <Cluster <T>, Cluster <T> > kjKey = UnorderedTuple.Create(kCluster, jCluster);
distances[UnorderedTuple.Create(uCluster, kCluster)] = (iWeight * distances[kiKey]) + (jWeight * distances[kjKey]);
distances.Remove(kiKey);
distances.Remove(kjKey);
}
clusters.RemoveAt(minJ);
clusters.RemoveAt(minI);
clusters.Add(uCluster);
}
return(tree);
}
public IUndirectedGraph <Cluster <T>, ClusterEdge <T> > GenerateClusters(IEnumerable <T> dataObjects)
{
var tree = new BidirectionalGraph <Cluster <T>, ClusterEdge <T> >(false);
var clusters = new List <Cluster <T> >();
foreach (T dataObject in dataObjects)
{
var cluster = new Cluster <T>(dataObject)
{
Description = dataObject.ToString()
};
clusters.Add(cluster);
tree.AddVertex(cluster);
}
var distances = new Dictionary <UnorderedTuple <Cluster <T>, Cluster <T> >, double>();
for (int i = 0; i < clusters.Count; i++)
{
for (int j = i + 1; j < clusters.Count; j++)
{
double distance = _getDistance(clusters[i].DataObjects.First(), clusters[j].DataObjects.First());
if (double.IsNaN(distance) || double.IsInfinity(distance) || distance < 0)
{
throw new ArgumentException("Invalid distance between data objects.", "dataObjects");
}
distances[UnorderedTuple.Create(clusters[i], clusters[j])] = distance;
}
}
while (clusters.Count > 2)
{
Dictionary <Cluster <T>, double> r = clusters.ToDictionary(c => c, c => clusters.Where(oc => oc != c).Sum(oc => distances[UnorderedTuple.Create(c, oc)] / (clusters.Count - 2)));
int minI = 0, minJ = 0;
double minDist = 0, minQ = double.MaxValue;
for (int i = 0; i < clusters.Count; i++)
{
for (int j = i + 1; j < clusters.Count; j++)
{
double dist = distances[UnorderedTuple.Create(clusters[i], clusters[j])];
double q = dist - r[clusters[i]] - r[clusters[j]];
if (q < minQ)
{
minQ = q;
minDist = dist;
minI = i;
minJ = j;
}
}
}
Cluster <T> iCluster = clusters[minI];
Cluster <T> jCluster = clusters[minJ];
distances.Remove(UnorderedTuple.Create(iCluster, jCluster));
var uCluster = new Cluster <T>();
tree.AddVertex(uCluster);
double iLen = (minDist / 2) + ((r[iCluster] - r[jCluster]) / 2);
if (iLen <= 0 && !tree.IsOutEdgesEmpty(iCluster))
{
foreach (ClusterEdge <T> edge in tree.OutEdges(iCluster))
{
tree.AddEdge(new ClusterEdge <T>(uCluster, edge.Target, edge.Length));
}
tree.RemoveVertex(iCluster);
}
else
{
tree.RemoveInEdgeIf(iCluster, edge => true);
tree.AddEdge(new ClusterEdge <T>(uCluster, iCluster, Math.Max(iLen, 0)));
}
double jLen = minDist - iLen;
if (jLen <= 0 && !tree.IsOutEdgesEmpty(jCluster))
{
foreach (ClusterEdge <T> edge in tree.OutEdges(jCluster))
{
tree.AddEdge(new ClusterEdge <T>(uCluster, edge.Target, edge.Length));
}
tree.RemoveVertex(jCluster);
}
else
{
tree.RemoveInEdgeIf(jCluster, edge => true);
tree.AddEdge(new ClusterEdge <T>(uCluster, jCluster, Math.Max(jLen, 0)));
}
foreach (Cluster <T> kCluster in clusters.Where(c => c != iCluster && c != jCluster))
{
UnorderedTuple <Cluster <T>, Cluster <T> > kiKey = UnorderedTuple.Create(kCluster, iCluster);
UnorderedTuple <Cluster <T>, Cluster <T> > kjKey = UnorderedTuple.Create(kCluster, jCluster);
distances[UnorderedTuple.Create(kCluster, uCluster)] = (distances[kiKey] + distances[kjKey] - minDist) / 2;
distances.Remove(kiKey);
distances.Remove(kjKey);
}
clusters.RemoveAt(minJ);
clusters.RemoveAt(minI);
clusters.Add(uCluster);
}
if (clusters.Count == 2)
{
tree.AddEdge(new ClusterEdge <T>(clusters[1], clusters[0], distances[UnorderedTuple.Create(clusters[0], clusters[1])]));
clusters.RemoveAt(0);
}
var unrootedTree = new UndirectedGraph <Cluster <T>, ClusterEdge <T> >(false);
unrootedTree.AddVertexRange(tree.Vertices);
unrootedTree.AddEdgeRange(tree.Edges);
return(unrootedTree);
}
public override object UpdateComponent()
{
_similarVowels.UpdateComponent();
_similarConsonants.UpdateComponent();
var cognateIdentifier = new BlairCognateIdentifier(_segmentPool, _ignoreRegularInsertionDeletion, _regularConsEqual,
_automaticRegularCorrespondenceThreshold, _defaultRegularCorrepondenceThreshold,
new ListSegmentMappings(_projectService.Project.Segmenter, _ignoredMappings.Mappings.Select(m => UnorderedTuple.Create(m.Segment1, m.Segment2)), false),
new TypeSegmentMappings(_similarVowels.SegmentMappings, _similarConsonants.SegmentMappings));
_projectService.Project.CognateIdentifiers[ComponentIdentifiers.PrimaryCognateIdentifier] = cognateIdentifier;
return(cognateIdentifier);
}
