public override IWordAligner Load(SpanFactory <ShapeNode> spanFactory, SegmentPool segmentPool, CogProject project, XElement elem)
{
WordPairAlignerSettings settings = LoadSettings(project.Segmenter, project.FeatureSystem, elem);
XElement relevantFeaturesElem = elem.Element(ConfigManager.Cog + "RelevantFeatures");
Debug.Assert(relevantFeaturesElem != null);
var relevantVowelFeatures = new List <SymbolicFeature>();
var relevantConsFeatures = new List <SymbolicFeature>();
var featureWeights = new Dictionary <SymbolicFeature, int>();
var valueMetrics = new Dictionary <FeatureSymbol, int>();
foreach (XElement featureElem in relevantFeaturesElem.Elements(ConfigManager.Cog + "RelevantFeature"))
{
var feature = project.FeatureSystem.GetFeature <SymbolicFeature>((string)featureElem.Attribute("ref"));
if ((bool?)featureElem.Attribute("vowel") ?? false)
{
relevantVowelFeatures.Add(feature);
}
if ((bool?)featureElem.Attribute("consonant") ?? false)
{
relevantConsFeatures.Add(feature);
}
featureWeights[feature] = (int)featureElem.Attribute("weight");
foreach (XElement valueElem in featureElem.Elements(ConfigManager.Cog + "RelevantValue"))
{
FeatureSymbol symbol = feature.PossibleSymbols[(string)valueElem.Attribute("ref")];
valueMetrics[symbol] = (int)valueElem.Attribute("metric");
}
}
return(new Aline(segmentPool, relevantVowelFeatures, relevantConsFeatures, featureWeights, valueMetrics, settings));
}
public CognateIdentifierOptionsViewModel(SegmentPool segmentPool, IProjectService projectService, BlairCognateIdentifierViewModel blairCognateIdentifier,
ThresholdCognateIdentifierViewModel thresholdCognateIdentifier, DolgopolskyCognateIdentifierViewModel dolgopolskyCognateIdentifier)
: base("Likely cognate identification", "Method", blairCognateIdentifier, thresholdCognateIdentifier, dolgopolskyCognateIdentifier)
{
_segmentPool = segmentPool;
_projectService = projectService;
}
public EMSoundChangeInducer(SegmentPool segmentPool, CogProject project, string alignerId, string cognateIdentifierId)
{
_segmentPool = segmentPool;
_project = project;
AlignerId = alignerId;
CognateIdentifierId = cognateIdentifierId;
}
public static CogProject Load(SegmentPool segmentPool, Stream configFileStream)
{
CogProject project;
Load(segmentPool, configFileStream, out project);
return(project);
}
internal void SetupProject() // Should this be protected? But the unit test needs to call it.
{
if (ConfigData != null && ConfigFilename != null)
{
Warnings.Add("WARNING: options --config-data and --config-file were both specified. Ignoring --config-file.");
ConfigFilename = null;
}
if (ConfigData == null && ConfigFilename == null)
{
ConfigFilename = FindConfigFilename();
// If ConfigFilename is STILL null at this point, it's because no config files were found at all,
// so we'll use the default one from the resource.
}
SpanFactory = new ShapeSpanFactory();
SegmentPool = new SegmentPool();
if (ConfigData == null && ConfigFilename == null)
{
Project = GetProjectFromResource(SpanFactory, SegmentPool);
}
else if (ConfigData != null)
{
Project = GetProjectFromXmlString(SpanFactory, SegmentPool, ConfigData);
}
else if (ConfigFilename != null)
{
Project = GetProjectFromFilename(SpanFactory, SegmentPool, ConfigFilename);
}
else // Should never get here given checks above, but let's be safe and write the check anyway
{
Project = GetProjectFromResource(SpanFactory, SegmentPool);
}
}
public static CogProject LoadFromXmlString(SegmentPool segmentPool, string xmlString)
{
CogProject project;
LoadFromXmlString(segmentPool, xmlString, out project);
return(project);
}
public IProcessor <Variety> Load(SpanFactory <ShapeNode> spanFactory, SegmentPool segmentPool, CogProject project, XElement elem)
{
var stemThreshold = (double)elem.Element(ConfigManager.Cog + "AffixThreshold");
var maxAffixLen = (int)elem.Element(ConfigManager.Cog + "MaxAffixLength");
return(new PoorMansAffixIdentifier(spanFactory, segmentPool, stemThreshold, maxAffixLen));
}
public SimpleWordPairGenerator(SegmentPool segmentPool, CogProject project, double initialAlignmentThreshold, string alignerID)
{
_segmentPool = segmentPool;
_project = project;
_alignerID = alignerID;
_thresholdCognateIdentifier = new ThresholdCognateIdentifier(initialAlignmentThreshold);
}
public ISegmentMappings Load(SegmentPool segmentPool, CogProject project, XElement elem)
{
XElement mappingsElem = elem.Element(ConfigManager.Cog + "Mappings");
var implicitComplexSegments = (bool?)elem.Element(ConfigManager.Cog + "ImplicitComplexSegments") ?? false;
return(new ListSegmentMappings(project.Segmenter, ParseMappings(mappingsElem), implicitComplexSegments));
}
public static CogProject Load(SegmentPool segmentPool, string configFilePath)
{
CogProject project;
Load(segmentPool, configFilePath, out project);
return(project);
}
public ISegmentMappings Load(SpanFactory <ShapeNode> spanFactory, SegmentPool segmentPool, CogProject project, XElement elem)
{
var vowelMappings = ConfigManager.LoadComponent <ISegmentMappings>(spanFactory, segmentPool, project, elem.Element(ConfigManager.Cog + "VowelMappings"));
var consonantMappings = ConfigManager.LoadComponent <ISegmentMappings>(spanFactory, segmentPool, project, elem.Element(ConfigManager.Cog + "ConsonantMappings"));
return(new TypeSegmentMappings(vowelMappings, consonantMappings));
}
private bool disposedValue = false; // To detect redundant calls
void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
_dataType = null;
_serializerMimeType = null;
}
if (_canCollect)
{
//Collect arrays
var lstArrays = _data.ListOfArrays;
if (lstArrays != null)
{
foreach (var arr in lstArrays)
{
SegmentPool.Return(arr);
}
if (lstArrays is List <byte[]> lBytes)
{
SegmentPool.ReturnContainer(lBytes);
}
else
{
lstArrays.Clear();
}
}
_data = MultiArray <byte> .Empty;
_canCollect = false;
}
disposedValue = true;
}
}
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 TestEnvironment(string word1, string word2, bool ignoreRegularInsertionDeletion = false, bool regularConsEqual = false, bool automaticRegularCorrThreshold = false)
{
_segmentPool = new SegmentPool();
_project = TestHelpers.GetTestProject(_segmentPool);
_project.Meanings.Add(new Meaning("gloss1", "cat1"));
_project.Varieties.AddRange(new[] { new Variety("variety1"), new Variety("variety2") });
_project.Varieties[0].Words.Add(new Word(word1, _project.Meanings[0]));
_project.Varieties[1].Words.Add(new Word(word2, _project.Meanings[0]));
var varSegementer = new VarietySegmenter(_project.Segmenter);
foreach (Variety variety in _project.Varieties)
{
varSegementer.Process(variety);
}
var vp = new VarietyPair(_project.Varieties[0], _project.Varieties[1]);
_project.VarietyPairs.Add(vp);
var wordPairGenerator = new SimpleWordPairGenerator(_segmentPool, _project, 0.3, "primary");
wordPairGenerator.Process(vp);
vp.CognateSoundCorrespondenceFrequencyDistribution = new ConditionalFrequencyDistribution <SoundContext, Ngram <Segment> >();
var ignoredMappings = Substitute.For <ISegmentMappings>();
var similarSegmentsMappings = Substitute.For <ISegmentMappings>();
_cognateIdentifier = new BlairCognateIdentifier(_segmentPool, ignoreRegularInsertionDeletion, regularConsEqual, automaticRegularCorrThreshold,
3, ignoredMappings, similarSegmentsMappings);
_aligner = new TestWordAligner(_segmentPool);
}
public SimpleWordPairGenerator(SegmentPool segmentPool, CogProject project, double initialAlignmentThreshold, string alignerID)
{
_segmentPool = segmentPool;
_project = project;
_alignerID = alignerID;
_initialAlignmentThreshold = initialAlignmentThreshold;
}
public override IWordAligner Load(SpanFactory<ShapeNode> spanFactory, SegmentPool segmentPool, CogProject project, XElement elem)
{
var settings = new AlineSettings();
LoadSettings(project.Segmenter, project.FeatureSystem, elem, settings);
XElement relevantFeaturesElem = elem.Element(ConfigManager.Cog + "RelevantFeatures");
Debug.Assert(relevantFeaturesElem != null);
var relevantVowelFeatures = new List<SymbolicFeature>();
var relevantConsFeatures = new List<SymbolicFeature>();
var featureWeights = new Dictionary<SymbolicFeature, int>();
var valueMetrics = new Dictionary<FeatureSymbol, int>();
foreach (XElement featureElem in relevantFeaturesElem.Elements(ConfigManager.Cog + "RelevantFeature"))
{
var feature = project.FeatureSystem.GetFeature<SymbolicFeature>((string) featureElem.Attribute("ref"));
if ((bool?) featureElem.Attribute("vowel") ?? false)
relevantVowelFeatures.Add(feature);
if ((bool?) featureElem.Attribute("consonant") ?? false)
relevantConsFeatures.Add(feature);
featureWeights[feature] = (int) featureElem.Attribute("weight");
foreach (XElement valueElem in featureElem.Elements(ConfigManager.Cog + "RelevantValue"))
{
FeatureSymbol symbol = feature.PossibleSymbols[(string) valueElem.Attribute("ref")];
valueMetrics[symbol] = (int) valueElem.Attribute("metric");
}
}
settings.SoundChangeScoringEnabled = (bool?) elem.Element(ConfigManager.Cog + "SoundChangeScoringEnabled") ?? true;
settings.SyllablePositionCostEnabled = (bool?) elem.Element(ConfigManager.Cog + "SyllablePositionCostEnabled") ?? true;
return new Aline(segmentPool, relevantVowelFeatures, relevantConsFeatures, featureWeights, valueMetrics, settings);
}
public PoorMansAffixIdentifierViewModel(SpanFactory <ShapeNode> spanFactory, SegmentPool segmentPool, IProjectService projectService)
: base("Automatic stemmer", "Input-Settings#automatic-stemmer")
{
_spanFactory = spanFactory;
_segmentPool = segmentPool;
_projectService = projectService;
}
public IProcessor <Variety> Load(SpanFactory <ShapeNode> spanFactory, SegmentPool segmentPool, CogProject project, XElement elem)
{
var combineVowels = (bool?)elem.Element(ConfigManager.Cog + "CombineVowels") ?? true;
var combineCons = (bool?)elem.Element(ConfigManager.Cog + "CombineConsonants") ?? true;
return(new SimpleSyllabifier(combineVowels, combineCons));
}
public AnalysisService(SegmentPool segmentPool, IProjectService projectService, IDialogService dialogService, IBusyService busyService)
{
_segmentPool = segmentPool;
_projectService = projectService;
_dialogService = dialogService;
_busyService = busyService;
}
public EMSoundChangeInducer(SegmentPool segmentPool, CogProject project, string alignerID, string cognateIdentifierID)
{
_segmentPool = segmentPool;
_project = project;
_alignerID = alignerID;
_cognateIdentifierID = cognateIdentifierID;
}
public void SetUp()
{
_featSys = new FeatureSystem
{
new SymbolicFeature("place",
new FeatureSymbol("bilabial"),
new FeatureSymbol("labiodental"),
new FeatureSymbol("dental"),
new FeatureSymbol("alveolar"),
new FeatureSymbol("retroflex"),
new FeatureSymbol("palato-alveolar"),
new FeatureSymbol("alveolo-palatal"),
new FeatureSymbol("palatal"),
new FeatureSymbol("velar"),
new FeatureSymbol("uvular"),
new FeatureSymbol("pharyngeal"),
new FeatureSymbol("epiglottal"),
new FeatureSymbol("glottal"))
};
_project = new CogProject(_spanFactory)
{
FeatureSystem = _featSys
};
_segmentPool = new SegmentPool();
}
public CogProject GetDefaultProject()
{
var spanFactory = new ShapeSpanFactory();
var segmentPool = new SegmentPool();
return(VerbBase.GetProjectFromResource(spanFactory, segmentPool));
}
public void Graph()
{
DispatcherHelper.Initialize();
var segmentPool = new SegmentPool();
var projectService = Substitute.For <IProjectService>();
var dialogService = Substitute.For <IDialogService>();
var busyService = Substitute.For <IBusyService>();
var graphService = new GraphService(projectService);
var imageExportService = Substitute.For <IImageExportService>();
var analysisService = new AnalysisService(_spanFactory, segmentPool, projectService, dialogService, busyService);
WordPairsViewModel.Factory wordPairsFactory = () => new WordPairsViewModel(busyService);
var globalCorrespondences = new GlobalCorrespondencesViewModel(projectService, busyService, dialogService, imageExportService, graphService, wordPairsFactory);
CogProject project = TestHelpers.GetTestProject(_spanFactory, segmentPool);
project.Meanings.AddRange(new[] { new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3") });
project.Varieties.AddRange(new[] { new Variety("variety1"), new Variety("variety2"), new Variety("variety3") });
project.Varieties[0].Words.AddRange(new[] { new Word("hɛ.loʊ", project.Meanings[0]), new Word("gʊd", project.Meanings[1]), new Word("bæd", project.Meanings[2]) });
project.Varieties[1].Words.AddRange(new[] { new Word("hɛlp", project.Meanings[0]), new Word("gu.gəl", project.Meanings[1]), new Word("gu.fi", project.Meanings[2]) });
project.Varieties[2].Words.AddRange(new[] { new Word("wɜrd", project.Meanings[0]), new Word("kɑr", project.Meanings[1]), new Word("fʊt.bɔl", project.Meanings[2]) });
projectService.Project.Returns(project);
analysisService.SegmentAll();
projectService.ProjectOpened += Raise.Event();
Assert.That(globalCorrespondences.Graph, Is.Null);
Messenger.Default.Send(new PerformingComparisonMessage());
var varietyPairGenerator = new VarietyPairGenerator();
varietyPairGenerator.Process(project);
var wordPairGenerator = new SimpleWordPairGenerator(segmentPool, project, 0.3, ComponentIdentifiers.PrimaryWordAligner);
var globalCorrIdentifier = new SoundCorrespondenceIdentifier(segmentPool, project, ComponentIdentifiers.PrimaryWordAligner);
foreach (VarietyPair vp in project.VarietyPairs)
{
wordPairGenerator.Process(vp);
foreach (WordPair wp in vp.WordPairs)
{
wp.AreCognatePredicted = true;
}
vp.SoundChangeFrequencyDistribution = new ConditionalFrequencyDistribution <SoundContext, Ngram <Segment> >();
vp.SoundChangeProbabilityDistribution = new ConditionalProbabilityDistribution <SoundContext, Ngram <Segment> >(vp.SoundChangeFrequencyDistribution, (sc, fd) => new MaxLikelihoodProbabilityDistribution <Ngram <Segment> >(fd));
globalCorrIdentifier.Process(vp);
}
Messenger.Default.Send(new ComparisonPerformedMessage());
Assert.That(globalCorrespondences.Graph, Is.Not.Null);
globalCorrespondences.SyllablePosition = SyllablePosition.Nucleus;
Assert.That(globalCorrespondences.Graph, Is.Not.Null);
Messenger.Default.Send(new DomainModelChangedMessage(true));
Assert.That(globalCorrespondences.Graph, Is.Null);
globalCorrespondences.SyllablePosition = SyllablePosition.Coda;
Assert.That(globalCorrespondences.Graph, Is.Null);
}
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 CogProject Load(SpanFactory <ShapeNode> spanFactory, SegmentPool segmentPool, string configFilePath)
{
CogProject project;
Load(spanFactory, segmentPool, configFilePath, out project);
return(project);
}
public static CogProject Load(SpanFactory <ShapeNode> spanFactory, SegmentPool segmentPool, Stream configFileStream)
{
CogProject project;
Load(spanFactory, segmentPool, configFileStream, out project);
return(project);
}
public SspSyllabifier(bool combineVowels, bool combineConsonants, bool vowelsSameSonorityTautosyllabic, SegmentPool segmentPool, IEnumerable <SonorityClass> sonorityScale)
: base(combineVowels, combineConsonants)
{
_vowelsSameSonorityTautosyllabic = vowelsSameSonorityTautosyllabic;
_segmentPool = segmentPool;
_sonorityScale = sonorityScale.ToList();
_initialOnsets = new ThreadLocal <HashSet <string> >();
}
public AnalysisService(SpanFactory <ShapeNode> spanFactory, SegmentPool segmentPool, IProjectService projectService, IDialogService dialogService, IBusyService busyService)
{
_spanFactory = spanFactory;
_segmentPool = segmentPool;
_projectService = projectService;
_dialogService = dialogService;
_busyService = busyService;
}
public SoundContext ToSoundContext(CogProject project, SegmentPool segmentPool)
{
IWordAligner aligner = project.WordAligners[ComponentIdentifiers.PrimaryWordAligner];
SoundClass leftEnv = LeftEnvironment == null ? null : aligner.ContextualSoundClasses.First(sc => sc.Name == LeftEnvironment);
SoundClass rightEnv = RightEnvironment == null ? null : aligner.ContextualSoundClasses.First(sc => sc.Name == RightEnvironment);
return(new SoundContext(leftEnv, new Ngram <Segment>(_target.Select(segmentPool.GetExisting)), rightEnv));
}
public Aline(SegmentPool segmentPool, IEnumerable <SymbolicFeature> relevantVowelFeatures, IEnumerable <SymbolicFeature> relevantConsFeatures,
IDictionary <SymbolicFeature, int> featureWeights, IDictionary <FeatureSymbol, int> valueMetrics, AlineSettings settings)
: base(settings)
{
_settings = settings;
_scorer = new AlineScorer(segmentPool, relevantVowelFeatures, relevantConsFeatures, featureWeights, valueMetrics,
settings.ContextualSoundClasses, settings.SoundChangeScoringEnabled, settings.SyllablePositionCostEnabled);
}
public Aline(SegmentPool segmentPool, IEnumerable<SymbolicFeature> relevantVowelFeatures, IEnumerable<SymbolicFeature> relevantConsFeatures,
IDictionary<SymbolicFeature, int> featureWeights, IDictionary<FeatureSymbol, int> valueMetrics, AlineSettings settings)
: base(settings)
{
_settings = settings;
_scorer = new AlineScorer(segmentPool, relevantVowelFeatures, relevantConsFeatures, featureWeights, valueMetrics,
settings.ContextualSoundClasses, settings.SoundChangeScoringEnabled, settings.SyllablePositionCostEnabled);
}
public DolgopolskyCognateIdentifierViewModel(SegmentPool segmentPool, IProjectService projectService, SoundClassesViewModel soundClassesViewModel)
: base("Dolgopolsky", "Dolgopolsky-Method-Settings")
{
_segmentPool = segmentPool;
_projectService = projectService;
_soundClasses = soundClassesViewModel;
_soundClasses.PropertyChanged += ChildPropertyChanged;
}
public SspSyllabifier(bool combineVowels, bool combineConsonants, bool vowelsSameSonorityTautosyllabic, SegmentPool segmentPool, IEnumerable<SonorityClass> sonorityScale)
: base(combineVowels, combineConsonants)
{
_vowelsSameSonorityTautosyllabic = vowelsSameSonorityTautosyllabic;
_segmentPool = segmentPool;
_sonorityScale = sonorityScale.ToList();
_initialOnsets = new ThreadLocal<HashSet<string>>();
}
public AlineViewModel(SegmentPool segmentPool, IProjectService projectService, SoundClassesViewModel soundClasses)
: base("Alignment", "Comparison-Settings#alignment")
{
_segmentPool = segmentPool;
_projectService = projectService;
_soundClasses = soundClasses;
_soundClasses.PropertyChanged += ChildPropertyChanged;
}
public SCAAlign(SegmentPool segmentPool, IEnumerable<SymbolicFeature> relevantVowelFeatures, IEnumerable<SymbolicFeature> relevantConsFeatures,
IDictionary<SymbolicFeature, int> featureWeights, IDictionary<FeatureSymbol, int> valueMetrics, SCAAlignSettings settings)
: base(settings)
{
_settings = settings;
_scorer = new SCAAlignScorer(segmentPool, relevantVowelFeatures, relevantConsFeatures, featureWeights, valueMetrics,
settings.ContextualSoundClasses);
}
public BlairCognateIdentifier(SegmentPool segmentPool, bool ignoreRegularInsertionDeletion, bool regularConsEqual,
ISegmentMappings ignoredMappings, ISegmentMappings similarSegments)
{
_segmentPool = segmentPool;
_ignoreRegularInsertionDeletion = ignoreRegularInsertionDeletion;
_regularConsEqual = regularConsEqual;
_ignoredMappings = ignoredMappings;
_similarSegments = similarSegments;
}
public BlairCognateIdentifier(SegmentPool segmentPool, bool ignoreRegularInsertionDeletion, bool regularConsEqual,
bool automaticRegularCorrespondenceThreshold, int defaultRegularCorrepondenceThreshold, ISegmentMappings ignoredMappings, ISegmentMappings similarSegments)
{
_segmentPool = segmentPool;
_ignoreRegularInsertionDeletion = ignoreRegularInsertionDeletion;
_regularConsEqual = regularConsEqual;
_ignoredMappings = ignoredMappings;
_similarSegments = similarSegments;
_automaticRegularCorrespondenceThreshold = automaticRegularCorrespondenceThreshold;
_defaultRegularCorrepondenceThreshold = defaultRegularCorrepondenceThreshold;
if (_automaticRegularCorrespondenceThreshold)
_regularCorrespondenceThresholdTable = new RegularSoundCorrespondenceThresholdTable();
}
public void Process()
{
var segmentPool = new SegmentPool();
CogProject project = TestHelpers.GetTestProject(_spanFactory, segmentPool);
project.Meanings.AddRange(new[] {new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3")});
project.Varieties.AddRange(new[] {new Variety("variety1"), new Variety("variety2")});
project.Varieties[0].Words.AddRange(new[] {new Word("hɛ.loʊ", project.Meanings[0]), new Word("gan", project.Meanings[0]), new Word("gʊd", project.Meanings[1]), new Word("bæ", project.Meanings[2]), new Word("ban", project.Meanings[2])});
project.Varieties[1].Words.AddRange(new[] {new Word("hɛ.ɬa", project.Meanings[0]), new Word("gud", project.Meanings[1]), new Word("tan", project.Meanings[1]), new Word("pæ", project.Meanings[2])});
project.WordAligners["primary"] = new TestWordAligner(segmentPool);
var cognateIdentifier = Substitute.For<ICognateIdentifier>();
cognateIdentifier.When(ci => ci.UpdateCognacy(Arg.Any<WordPair>(), Arg.Any<IWordAlignerResult>())).Do(ci =>
{
var wordPair = ci.Arg<WordPair>();
if ((wordPair.Word1.StrRep == "hɛ.loʊ" && wordPair.Word2.StrRep == "hɛ.ɬa")
|| (wordPair.Word1.StrRep == "gʊd" && wordPair.Word2.StrRep == "tan")
|| (wordPair.Word1.StrRep == "bæ" && wordPair.Word2.StrRep == "pæ")
|| (wordPair.Word1.StrRep == "ban" && wordPair.Word2.StrRep == "pæ"))
{
wordPair.AreCognatePredicted = true;
wordPair.CognacyScore = 1.0;
}
});
project.CognateIdentifiers["primary"] = cognateIdentifier;
var varSegementer = new VarietySegmenter(project.Segmenter);
foreach (Variety variety in project.Varieties)
varSegementer.Process(variety);
var vp = new VarietyPair(project.Varieties[0], project.Varieties[1]);
project.VarietyPairs.Add(vp);
var wordPairGenerator = new CognacyWordPairGenerator(segmentPool, project, 0.3, "primary", "primary");
wordPairGenerator.Process(vp);
WordPair wp = vp.WordPairs[0];
Assert.That(wp.Word1.StrRep, Is.EqualTo("hɛ.loʊ"));
Assert.That(wp.Word2.StrRep, Is.EqualTo("hɛ.ɬa"));
wp = vp.WordPairs[1];
Assert.That(wp.Word1.StrRep, Is.EqualTo("gʊd"));
Assert.That(wp.Word2.StrRep, Is.EqualTo("tan"));
wp = vp.WordPairs[2];
Assert.That(wp.Word1.StrRep, Is.EqualTo("bæ"));
Assert.That(wp.Word2.StrRep, Is.EqualTo("pæ"));
}
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 void UpdateCognacy_RegularCorrespondences()
{
var segmentPool = new SegmentPool();
CogProject project = TestHelpers.GetTestProject(_spanFactory, segmentPool);
project.Meanings.AddRange(new[] {new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3")});
project.Varieties.AddRange(new[] {new Variety("variety1"), new Variety("variety2")});
project.Varieties[0].Words.AddRange(new[] {new Word("hɛ.lo", project.Meanings[0]), new Word("gʊd", project.Meanings[1]), new Word("bæ", project.Meanings[2])});
project.Varieties[1].Words.AddRange(new[] {new Word("hɛ.ɬa", project.Meanings[0]), new Word("gud", project.Meanings[1]), new Word("pæ", project.Meanings[2])});
var varSegementer = new VarietySegmenter(project.Segmenter);
foreach (Variety variety in project.Varieties)
varSegementer.Process(variety);
var vp = new VarietyPair(project.Varieties[0], project.Varieties[1]);
project.VarietyPairs.Add(vp);
var wordPairGenerator = new SimpleWordPairGenerator(segmentPool, project, 0.3, "primary");
wordPairGenerator.Process(vp);
vp.SoundChangeFrequencyDistribution[new SoundContext(segmentPool.GetExisting("l"))].Increment(segmentPool.GetExisting("ɬ"), 3);
vp.SoundChangeFrequencyDistribution[new SoundContext(segmentPool.GetExisting("b"))].Increment(segmentPool.GetExisting("p"), 3);
var aligner = new TestWordAligner(segmentPool);
var ignoredMappings = Substitute.For<ISegmentMappings>();
ignoredMappings.IsMapped(Arg.Any<ShapeNode>(), Arg.Any<Ngram<Segment>>(), Arg.Any<ShapeNode>(), Arg.Any<ShapeNode>(), Arg.Any<Ngram<Segment>>(), Arg.Any<ShapeNode>()).Returns(false);
var similarSegmentsMappings = Substitute.For<ISegmentMappings>();
similarSegmentsMappings.IsMapped(Arg.Any<ShapeNode>(), segmentPool.GetExisting("b"), Arg.Any<ShapeNode>(), Arg.Any<ShapeNode>(), segmentPool.GetExisting("p"), Arg.Any<ShapeNode>()).Returns(true);
var cognateIdentifier = new BlairCognateIdentifier(segmentPool, false, false, ignoredMappings, similarSegmentsMappings);
var wp = vp.WordPairs[0];
cognateIdentifier.UpdateCognacy(wp, aligner.Compute(wp));
Assert.That(wp.AreCognatePredicted, Is.True);
wp = vp.WordPairs[1];
cognateIdentifier.UpdateCognacy(wp, aligner.Compute(wp));
Assert.That(wp.AreCognatePredicted, Is.True);
wp = vp.WordPairs[2];
cognateIdentifier.UpdateCognacy(wp, aligner.Compute(wp));
Assert.That(wp.AreCognatePredicted, Is.True);
}
public void UpdateCognacy_NoSimilarSegments()
{
var segmentPool = new SegmentPool();
CogProject project = TestHelpers.GetTestProject(_spanFactory, segmentPool);
project.Meanings.AddRange(new[] {new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3")});
project.Varieties.AddRange(new[] {new Variety("variety1"), new Variety("variety2")});
project.Varieties[0].Words.AddRange(new[] {new Word("hɛ.loʊ", project.Meanings[0]), new Word("gʊd", project.Meanings[1]), new Word("bæ", project.Meanings[2])});
project.Varieties[1].Words.AddRange(new[] {new Word("hɛ.ɬa", project.Meanings[0]), new Word("gud", project.Meanings[1]), new Word("pæ", project.Meanings[2])});
var varSegementer = new VarietySegmenter(project.Segmenter);
foreach (Variety variety in project.Varieties)
varSegementer.Process(variety);
var vp = new VarietyPair(project.Varieties[0], project.Varieties[1]);
project.VarietyPairs.Add(vp);
var wordPairGenerator = new SimpleWordPairGenerator(segmentPool, project, 0.3, "primary");
wordPairGenerator.Process(vp);
var aligner = new TestWordAligner(segmentPool);
var ignoredMappings = Substitute.For<ISegmentMappings>();
var similarSegmentsMappings = Substitute.For<ISegmentMappings>();
var cognateIdentifier = new BlairCognateIdentifier(segmentPool, false, false, ignoredMappings, similarSegmentsMappings);
var wp = vp.WordPairs[0];
cognateIdentifier.UpdateCognacy(wp, aligner.Compute(wp));
Assert.That(wp.AreCognatePredicted, Is.False);
wp = vp.WordPairs[1];
cognateIdentifier.UpdateCognacy(wp, aligner.Compute(wp));
Assert.That(wp.AreCognatePredicted, Is.True);
wp = vp.WordPairs[2];
cognateIdentifier.UpdateCognacy(wp, aligner.Compute(wp));
Assert.That(wp.AreCognatePredicted, Is.False);
}
public SCAAlign(SegmentPool segmentPool, IEnumerable<SymbolicFeature> relevantVowelFeatures, IEnumerable<SymbolicFeature> relevantConsFeatures,
IDictionary<SymbolicFeature, int> featureWeights, IDictionary<FeatureSymbol, int> valueMetrics)
: this(segmentPool, relevantVowelFeatures, relevantConsFeatures, featureWeights, valueMetrics, new SCAAlignSettings())
{
}
public DolgopolskyCognateIdentifier(SegmentPool segmentPool, IEnumerable<SoundClass> soundClasses, int initialEquivalenceThreshold)
{
_segmentPool = segmentPool;
_soundClasses = soundClasses.ToList();
_initialEquivalenceThreshold = initialEquivalenceThreshold;
}
public void NoMappings()
{
var segmentPool = new SegmentPool();
var mappings = new ListSegmentMappings(_segmenter, new UnorderedTuple<string, string>[0], false);
Shape shape1 = _segmenter.Segment("mat");
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.False);
Assert.That(mappings.IsMapped(shape1.Last.Prev, segmentPool.Get(shape1.Last), shape1.Last.Next, shape2.Last, new Ngram<Segment>(), shape2.Last.Next), Is.False);
}
public void SetUp()
{
_featSys = new FeatureSystem
{
new SymbolicFeature("place",
new FeatureSymbol("bilabial"),
new FeatureSymbol("labiodental"),
new FeatureSymbol("dental"),
new FeatureSymbol("alveolar"),
new FeatureSymbol("retroflex"),
new FeatureSymbol("palato-alveolar"),
new FeatureSymbol("palatal"),
new FeatureSymbol("velar"),
new FeatureSymbol("uvular"),
new FeatureSymbol("pharyngeal"),
new FeatureSymbol("glottal")),
new SymbolicFeature("manner",
new FeatureSymbol("stop"),
new FeatureSymbol("affricate"),
new FeatureSymbol("fricative"),
new FeatureSymbol("approximant"),
new FeatureSymbol("trill"),
new FeatureSymbol("flap"),
new FeatureSymbol("close-vowel"),
new FeatureSymbol("mid-vowel"),
new FeatureSymbol("open-vowel")),
new SymbolicFeature("voice",
new FeatureSymbol("voice+"),
new FeatureSymbol("voice-")),
new SymbolicFeature("height",
new FeatureSymbol("close"),
new FeatureSymbol("near-close"),
new FeatureSymbol("close-mid"),
new FeatureSymbol("mid"),
new FeatureSymbol("open-mid"),
new FeatureSymbol("near-open"),
new FeatureSymbol("open")),
new SymbolicFeature("backness",
new FeatureSymbol("front"),
new FeatureSymbol("near-front"),
new FeatureSymbol("central"),
new FeatureSymbol("near-back"),
new FeatureSymbol("back")),
new SymbolicFeature("round",
new FeatureSymbol("round+"),
new FeatureSymbol("round-"))
};
_segmentPool = new SegmentPool();
_segmenter = new Segmenter(_spanFactory)
{
Consonants =
{
{"c", FeatureStruct.New(_featSys).Symbol("palatal").Symbol("stop").Symbol("voice-").Value},
{"b", FeatureStruct.New(_featSys).Symbol("bilabial").Symbol("stop").Symbol("voice+").Value},
{"r", FeatureStruct.New(_featSys).Symbol("alveolar").Symbol("trill").Symbol("voice+").Value}
},
Vowels =
{
{"a", FeatureStruct.New(_featSys).Symbol("open").Symbol("front").Symbol("round-").Symbol("open-vowel").Symbol("voice+").Value}
},
Boundaries = {"-"},
Modifiers = {"\u0303", "\u0308"},
Joiners = {"\u0361"}
};
var syllabifier = new SimpleSyllabifier(false, false);
var meaning = new Meaning("test", null);
var v1 = new Variety("variety1");
_word1 = new Word("car", meaning);
_segmenter.Segment(_word1);
v1.Words.Add(_word1);
syllabifier.Process(v1);
var v2 = new Variety("variety2");
_word2 = new Word("bar", meaning);
_segmenter.Segment(_word2);
v2.Words.Add(_word2);
syllabifier.Process(v2);
var vp = new VarietyPair(v1, v2);
vp.SoundChangeFrequencyDistribution = new ConditionalFrequencyDistribution<SoundContext, Ngram<Segment>>();
vp.SoundChangeFrequencyDistribution[_word1.Shape.First.ToSoundContext(_segmentPool, Enumerable.Empty<SoundClass>())].Increment(_segmentPool.Get(_word2.Shape.First));
vp.SoundChangeProbabilityDistribution = new ConditionalProbabilityDistribution<SoundContext, Ngram<Segment>>(vp.SoundChangeFrequencyDistribution,
(sc, fd) => new MaxLikelihoodProbabilityDistribution<Ngram<Segment>>(fd));
v1.VarietyPairs.VarietyPairAdded(vp);
v2.VarietyPairs.VarietyPairAdded(vp);
}
public TestEnvironment(string word1, string word2, bool ignoreRegularInsertionDeletion = false, bool regularConsEqual = false, bool automaticRegularCorrThreshold = false)
{
_segmentPool = new SegmentPool();
_project = TestHelpers.GetTestProject(_spanFactory, _segmentPool);
_project.Meanings.Add(new Meaning("gloss1", "cat1"));
_project.Varieties.AddRange(new[] {new Variety("variety1"), new Variety("variety2")});
_project.Varieties[0].Words.Add(new Word(word1, _project.Meanings[0]));
_project.Varieties[1].Words.Add(new Word(word2, _project.Meanings[0]));
var varSegementer = new VarietySegmenter(_project.Segmenter);
foreach (Variety variety in _project.Varieties)
varSegementer.Process(variety);
var vp = new VarietyPair(_project.Varieties[0], _project.Varieties[1]);
_project.VarietyPairs.Add(vp);
var wordPairGenerator = new SimpleWordPairGenerator(_segmentPool, _project, 0.3, "primary");
wordPairGenerator.Process(vp);
vp.CognateSoundCorrespondenceFrequencyDistribution = new ConditionalFrequencyDistribution<SoundContext, Ngram<Segment>>();
var ignoredMappings = Substitute.For<ISegmentMappings>();
var similarSegmentsMappings = Substitute.For<ISegmentMappings>();
_cognateIdentifier = new BlairCognateIdentifier(_segmentPool, ignoreRegularInsertionDeletion, regularConsEqual, automaticRegularCorrThreshold,
3, ignoredMappings, similarSegmentsMappings);
_aligner = new TestWordAligner(_segmentPool);
}
