public void ToStringDelimiterTest()
{
var source = "abcabccc";
var chain = new Chain(source);
var baseChain = new BaseChain(source);
var expected = "a b c a b c c c";
Assert.AreEqual(expected, chain.ToString(" "));
Assert.AreEqual(expected, baseChain.ToString(" "));
expected = "acbcccacbcccccc";
Assert.AreEqual(expected, chain.ToString("c"));
Assert.AreEqual(expected, baseChain.ToString("c"));
}
public void ToStringLongDelimiterTest()
{
var source = "abcabccc";
var chain = new Chain(source);
var baseChain = new BaseChain(source);
var expected = "a - b - c - a - b - c - c - c";
Assert.AreEqual(expected, chain.ToString(" - "));
Assert.AreEqual(expected, baseChain.ToString(" - "));
expected = "a, b, c, a, b, c, c, c";
Assert.AreEqual(expected, chain.ToString(", "));
Assert.AreEqual(expected, baseChain.ToString(", "));
}
public void ToStringTest()
{
var stringExpected = "abcabccc";
var chain = new Chain(stringExpected);
Assert.AreEqual(stringExpected, chain.ToString());
var baseChain = new BaseChain(stringExpected);
Assert.AreEqual(stringExpected, baseChain.ToString());
}
public ActionResult Index(
long[] matterIds,
int[] characteristicTypeLinkIds,
int? languageId,
int? translatorId,
int notationId,
int length,
int step,
bool delta,
bool fourier,
bool growingWindow,
bool autocorrelation)
{
return Action(() =>
{
var characteristicNames = new string[characteristicTypeLinkIds.Length];
var partNames = new List<string>[matterIds.Length];
var starts = new List<int>[matterIds.Length];
var lengthes = new List<int>[matterIds.Length];
var chains = new Chain[matterIds.Length];
var mattersCharacteristics = new object[matterIds.Length];
var calculators = new List<IFullCalculator>();
var links = new List<Link>();
matterIds = matterIds.OrderBy(m => m).ToArray();
var matters = db.Matter.Where(m => matterIds.Contains(m.Id)).ToDictionary(m => m.Id);
for (int k = 0; k < matterIds.Length; k++)
{
long matterId = matterIds[k];
Nature nature = db.Matter.Single(m => m.Id == matterId).Nature;
long sequenceId;
switch (nature)
{
case Nature.Literature:
sequenceId = db.LiteratureSequence.Single(l => l.MatterId == matterId
&& l.NotationId == notationId
&& l.LanguageId == languageId
&& l.TranslatorId == translatorId).Id;
break;
default:
var id = notationId;
sequenceId = db.CommonSequence.Single(c => c.MatterId == matterId
&& c.NotationId == id).Id;
break;
}
chains[k] = commonSequenceRepository.ToLibiadaChain(sequenceId);
}
foreach (int characteristicTypeLinkId in characteristicTypeLinkIds)
{
string className = characteristicTypeLinkRepository.GetCharacteristicType(characteristicTypeLinkId).ClassName;
calculators.Add(CalculatorsFactory.CreateFullCalculator(className));
links.Add(characteristicTypeLinkRepository.GetLibiadaLink(characteristicTypeLinkId));
}
for (int i = 0; i < chains.Length; i++)
{
CutRule cutRule = growingWindow
? (CutRule)new CutRuleWithFixedStart(chains[i].GetLength(), step)
: new SimpleCutRule(chains[i].GetLength(), step, length);
CutRuleIterator iter = cutRule.GetIterator();
List<Chain> fragments = new List<Chain>();
partNames[i] = new List<string>();
starts[i] = new List<int>();
lengthes[i] = new List<int>();
while (iter.Next())
{
var fragment = new Chain(iter.GetEndPosition() - iter.GetStartPosition());
for (int k = 0; iter.GetStartPosition() + k < iter.GetEndPosition(); k++)
{
fragment.Set(chains[i][iter.GetStartPosition() + k], k);
}
fragments.Add(fragment);
partNames[i].Add(fragment.ToString());
starts[i].Add(iter.GetStartPosition());
lengthes[i].Add(fragment.GetLength());
}
var fragmentsData = new FragmentData[fragments.Count];
for (int k = 0; k < fragments.Count; k++)
{
var characteristics = new double[calculators.Count];
for (int j = 0; j < calculators.Count; j++)
{
characteristics[j] = calculators[j].Calculate(fragments[k], links[j]);
}
fragmentsData[k] = new FragmentData(characteristics, fragments[k].ToString(), starts[i][k], fragments[k].GetLength());
}
double[][] differenceData = null;
double[][] fourierData = null;
double[][] autocorrelationData = null;
if (delta)
{
differenceData = CalculateDifference(fragmentsData.Select(f => f.Characteristics).ToArray());
}
if (fourier)
{
fourierData = FastFourierTransform.CalculateFastFourierTransform(fragmentsData.Select(f => f.Characteristics).ToArray());
}
if (autocorrelation)
{
autocorrelationData = AutoCorrelation.CalculateAutocorrelation(fragmentsData.Select(f => f.Characteristics).ToArray());
}
mattersCharacteristics[i] = new { matterName = matters[matterIds[i]].Name, fragmentsData, differenceData, fourierData, autocorrelationData };
}
for (int l = 0; l < characteristicTypeLinkIds.Length; l++)
{
characteristicNames[l] = characteristicTypeLinkRepository.GetCharacteristicType(characteristicTypeLinkIds[l]).Name;
}
var characteristicsList = new SelectListItem[characteristicTypeLinkIds.Length];
for (int k = 0; k < characteristicTypeLinkIds.Length; k++)
{
characteristicNames[k] = characteristicTypeLinkRepository.GetCharacteristicName(characteristicTypeLinkIds[k], notationId);
characteristicsList[k] = new SelectListItem
{
Value = k.ToString(),
Text = characteristicNames[k],
Selected = false
};
}
string notationName = db.Notation.Single(n => n.Id == notationId).Name;
var result = new Dictionary<string, object>
{
{ "characteristics", mattersCharacteristics },
{ "notationName", notationName },
{ "starts", starts },
{ "partNames", partNames },
{ "lengthes", lengthes },
{ "characteristicNames", characteristicNames },
{ "matterIds", matterIds },
{ "characteristicsList", characteristicsList }
};
return new Dictionary<string, object> { { "data", JsonConvert.SerializeObject(result) } };
});
}
