/// <summary>
/// The create.
/// </summary>
/// <param name="source">
/// The source.
/// </param>
/// <param name="link">
/// The link.
/// </param>
/// <returns>
/// The <see cref="Chain"/>.
/// </returns>
/// <exception cref="ArgumentException">
/// Thrown if link is unacceptable.
/// </exception>
public static Chain Create(Chain source, Link link)
{
if (link != Link.Start && link != Link.End && link != Link.CycleEnd && link != Link.CycleStart)
{
throw new ArgumentException("Unknown link", "link");
}
var result = new Chain(source.GetLength());
Alphabet sourceAlphabet = source.Alphabet;
var entries = new int[sourceAlphabet.Cardinality];
var intervals = new int[sourceAlphabet.Cardinality][];
for (int j = 0; j < sourceAlphabet.Cardinality; j++)
{
var intervalsManager = new CongenericIntervalsManager(source.CongenericChain(j));
intervals[j] = intervalsManager.GetIntervals(link);
}
for (int i = 0; i < source.GetLength(); i++)
{
var elementIndex = sourceAlphabet.IndexOf(source[i]);
int entry = entries[elementIndex]++;
var interval = intervals[elementIndex][entry];
result.Set(new ValueInt(interval), i);
}
return result;
}
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) } };
});
}
