/// <summary>
/// The not frequency characteristic.
/// </summary>
/// <param name="characteristicLinkId">
/// The characteristic type and link id.
/// </param>
/// <param name="sequenceId">
/// The sequence id.
/// </param>
/// <param name="chain">
/// The chain.
/// </param>
/// <param name="calculator">
/// The calculator.
/// </param>
/// <param name="link">
/// The link.
/// </param>
private void NotFrequencyCharacteristic(short characteristicLinkId, long sequenceId, Chain chain, IBinaryCalculator calculator, Link link)
{
var newCharacteristics = new List <BinaryCharacteristicValue>();
BinaryCharacteristicValue[] databaseCharacteristics = db.BinaryCharacteristicValue
.Where(b => b.SequenceId == sequenceId && b.CharacteristicLinkId == characteristicLinkId)
.ToArray();
int calculatedCount = databaseCharacteristics.Length;
int alphabetCardinality = chain.Alphabet.Cardinality;
if (calculatedCount < alphabetCardinality * alphabetCardinality)
{
long[] sequenceElements = db.GetAlphabetElementIds(sequenceId);
for (int i = 0; i < alphabetCardinality; i++)
{
for (int j = 0; j < alphabetCardinality; j++)
{
long firstElementId = sequenceElements[i];
long secondElementId = sequenceElements[j];
if (i != j && !databaseCharacteristics.Any(b => b.FirstElementId == firstElementId && b.SecondElementId == secondElementId))
{
double result = calculator.Calculate(chain.GetRelationIntervalsManager(i + 1, j + 1), link);
newCharacteristics.Add(characteristicTypeLinkRepository.CreateCharacteristic(sequenceId, characteristicLinkId, firstElementId, secondElementId, result));
}
}
}
}
db.BinaryCharacteristicValue.AddRange(newCharacteristics);
db.SaveChanges();
}
/// <summary>
/// The frequency characteristic.
/// </summary>
/// <param name="characteristicLinkId">
/// The characteristic type and link id.
/// </param>
/// <param name="frequencyCount">
/// The frequency count.
/// </param>
/// <param name="chain">
/// The chain.
/// </param>
/// <param name="sequenceId">
/// The sequence id.
/// </param>
/// <param name="calculator">
/// The calculator.
/// </param>
/// <param name="link">
/// The link.
/// </param>
private void FrequencyCharacteristic(short characteristicLinkId, int frequencyCount, Chain chain, long sequenceId, IBinaryCalculator calculator, Link link)
{
long[] sequenceElements = db.GetAlphabetElementIds(sequenceId);
var newCharacteristics = new List <BinaryCharacteristicValue>();
BinaryCharacteristicValue[] databaseCharacteristics = db.BinaryCharacteristicValue
.Where(b => b.SequenceId == sequenceId && b.CharacteristicLinkId == characteristicLinkId)
.ToArray();
// calculating frequencies of elements in alphabet
Alphabet alphabet = chain.Alphabet;
var frequencies = new (IBaseObject element, double frequency)[alphabet.Cardinality];
public ActionResult Index(
long matterId,
short characteristicLinkId,
Notation notation,
Language?language,
Translator?translator,
PauseTreatment?pauseTreatment,
bool?sequentialTransfer,
ImageOrderExtractor?trajectory,
int filterSize,
bool filter,
bool frequencyFilter,
int frequencyCount)
{
return(CreateTask(() =>
{
string characteristicName = characteristicTypeLinkRepository.GetCharacteristicName(characteristicLinkId, notation);
Matter matter = Cache.GetInstance().Matters.Single(m => m.Id == matterId);
long sequenceId = commonSequenceRepository.GetSequenceIds(new[] { matterId },
notation,
language,
translator,
pauseTreatment,
sequentialTransfer,
trajectory).Single();
Chain currentChain = commonSequenceRepository.GetLibiadaChain(sequenceId);
var sequence = db.CommonSequence.Single(m => m.Id == sequenceId);
var result = new Dictionary <string, object>
{
{ "isFilter", filter },
{ "matterName", sequence.Matter.Name },
{ "notationName", sequence.Notation.GetDisplayValue() },
{ "characteristicName", characteristicName }
};
BinaryCharacteristic binaryCharacteristic = characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkId);
IBinaryCalculator calculator = BinaryCalculatorsFactory.CreateCalculator(binaryCharacteristic);
Link link = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkId);
if (frequencyFilter)
{
FrequencyCharacteristic(characteristicLinkId, frequencyCount, currentChain, sequenceId, calculator, link);
}
else
{
NotFrequencyCharacteristic(characteristicLinkId, sequenceId, currentChain, calculator, link);
}
if (filter)
{
var filteredResult = db.BinaryCharacteristicValue
.Where(b => b.SequenceId == sequenceId && b.CharacteristicLinkId == characteristicLinkId)
.OrderByDescending(b => b.Value)
.Take(filterSize)
.Select(rc => new
{
FirstElementId = rc.FirstElementId,
SecondElementId = rc.SecondElementId,
Value = rc.Value
})
.ToArray();
var firstElements = new List <string>();
var secondElements = new List <string>();
for (int i = 0; i < filterSize; i++)
{
long firstElementId = filteredResult[i].FirstElementId;
var firstElement = db.Element.Single(e => e.Id == firstElementId);
firstElements.Add(firstElement.Name ?? firstElement.Value);
long secondElementId = filteredResult[i].SecondElementId;
var secondElement = db.Element.Single(e => e.Id == secondElementId);
secondElements.Add(secondElement.Name ?? secondElement.Value);
}
result.Add("filteredResult", filteredResult);
result.Add("filterSize", filterSize);
result.Add("firstElements", firstElements);
result.Add("secondElements", secondElements);
}
else
{
var characteristics = db.BinaryCharacteristicValue
.Where(b => b.SequenceId == sequenceId && b.CharacteristicLinkId == characteristicLinkId)
.GroupBy(b => b.FirstElementId)
.ToDictionary(b => b.Key, b => b.ToDictionary(bb => bb.SecondElementId, bb => bb.Value));
var elementsIds = db.GetAlphabetElementIds(sequenceId);
var elements = db.Element
.Where(e => elementsIds.Contains(e.Id))
.OrderBy(e => e.Id)
.Select(e => new { Name = e.Name ?? e.Value, e.Id })
.ToArray();
result.Add("characteristics", characteristics);
result.Add("elements", elements);
}
string json = JsonConvert.SerializeObject(result);
return new Dictionary <string, string> {
{ "data", json }
};
}));
}
public virtual void Initialization()
{
var testClassName = this.GetType().Name;
var calculatorName = testClassName.Substring(0, testClassName.Length - 5);
Calculator = CalculatorsFactory.CreateBinaryCalculator(calculatorName);
}
/// <summary>
/// The not frequency characteristic.
/// </summary>
/// <param name="characteristicTypeLinkId">
/// The characteristic type and link id.
/// </param>
/// <param name="sequenceId">
/// The sequence id.
/// </param>
/// <param name="chain">
/// The chain.
/// </param>
/// <param name="calculator">
/// The calculator.
/// </param>
/// <param name="link">
/// The link.
/// </param>
private void NotFrequencyCharacteristic(
int characteristicTypeLinkId,
long sequenceId,
Chain chain,
IBinaryCalculator calculator,
Link link)
{
var newCharacteristics = new List<BinaryCharacteristic>();
var databaseCharacteristics = db.BinaryCharacteristic.Where(b => b.SequenceId == sequenceId
&& b.CharacteristicTypeLinkId == characteristicTypeLinkId)
.ToArray();
int calculatedCount = databaseCharacteristics.Length;
if (calculatedCount < chain.Alphabet.Cardinality * chain.Alphabet.Cardinality)
{
List<long> sequenceElements = DbHelper.GetElementIds(db, sequenceId);
for (int i = 0; i < chain.Alphabet.Cardinality; i++)
{
for (int j = 0; j < chain.Alphabet.Cardinality; j++)
{
long firstElementId = sequenceElements[i];
long secondElementId = sequenceElements[i];
if (!databaseCharacteristics.Any(b => b.FirstElementId == firstElementId && b.SecondElementId == secondElementId))
{
double result = calculator.Calculate(chain.GetRelationIntervalsManager(i + 1, j + 1), link);
newCharacteristics.Add(binaryCharacteristicRepository.CreateBinaryCharacteristic(sequenceId, characteristicTypeLinkId, firstElementId, secondElementId, result));
}
}
}
}
db.BinaryCharacteristic.AddRange(newCharacteristics);
db.SaveChanges();
}
/// <summary>
/// The frequency characteristic.
/// </summary>
/// <param name="characteristicTypeLinkId">
/// The characteristic type and link id.
/// </param>
/// <param name="frequencyCount">
/// The frequency count.
/// </param>
/// <param name="chain">
/// The chain.
/// </param>
/// <param name="sequenceId">
/// The sequence id.
/// </param>
/// <param name="calculator">
/// The calculator.
/// </param>
/// <param name="link">
/// The link.
/// </param>
private void FrequencyCharacteristic(int characteristicTypeLinkId, int frequencyCount, Chain chain, long sequenceId, IBinaryCalculator calculator, Link link)
{
List<long> sequenceElements = DbHelper.GetElementIds(db, sequenceId);
var newCharacteristics = new List<BinaryCharacteristic>();
var databaseCharacteristics = db.BinaryCharacteristic.Where(b => b.SequenceId == sequenceId
&& b.CharacteristicTypeLinkId == characteristicTypeLinkId).ToArray();
// calculating frequencies of elements in alphabet
var frequencies = new List<KeyValuePair<IBaseObject, double>>();
for (int f = 0; f < chain.Alphabet.Cardinality; f++)
{
var probabilityCalculator = new Probability();
var result = probabilityCalculator.Calculate(chain.CongenericChain(f), Link.NotApplied);
frequencies.Add(new KeyValuePair<IBaseObject, double>(chain.Alphabet[f], result));
}
// ordering alphabet by frequencies
SortKeyValuePairList(frequencies);
// calculating relation characteristic only for elements with maximum frequency
for (int i = 0; i < frequencyCount; i++)
{
for (int j = 0; j < frequencyCount; j++)
{
int firstElementNumber = chain.Alphabet.IndexOf(frequencies[i].Key) + 1;
int secondElementNumber = chain.Alphabet.IndexOf(frequencies[j].Key) + 1;
long firstElementId = sequenceElements[firstElementNumber];
long secondElementId = sequenceElements[secondElementNumber];
// searching characteristic in database
if (!databaseCharacteristics.Any(b => b.FirstElementId == firstElementId && b.SecondElementId == secondElementId))
{
double result = calculator.Calculate(chain.GetRelationIntervalsManager(i + 1, j + 1), link);
newCharacteristics.Add(binaryCharacteristicRepository.CreateBinaryCharacteristic(sequenceId, characteristicTypeLinkId, firstElementId, secondElementId, result));
}
}
}
db.BinaryCharacteristic.AddRange(newCharacteristics);
db.SaveChanges();
}
public ActionResult Index(
long matterId,
short characteristicLinkId,
Notation notation,
Language?language,
Translator?translator,
PauseTreatment?pauseTreatment,
bool?sequentialTransfer,
int filterSize,
bool filter,
bool frequencyFilter,
int frequencyCount)
{
return(CreateTask(() =>
{
var characteristics = new Dictionary <long, Dictionary <long, double> >();
Element[] elements = null;
List <BinaryCharacteristicValue> filteredResult = null;
var firstElements = new List <Element>();
var secondElements = new List <Element>();
Matter matter = db.Matter.Single(m => m.Id == matterId);
long sequenceId;
switch (matter.Nature)
{
case Nature.Literature:
sequenceId = db.LiteratureSequence.Single(l => l.MatterId == matterId &&
l.Notation == notation &&
l.Language == language &&
l.Translator == translator).Id;
break;
case Nature.Music:
sequenceId = db.MusicSequence.Single(m => m.MatterId == matterId &&
m.Notation == notation &&
m.PauseTreatment == pauseTreatment &&
m.SequentialTransfer == sequentialTransfer).Id;
break;
default:
sequenceId = db.CommonSequence.Single(c => c.MatterId == matterId && c.Notation == notation).Id;
break;
}
Chain currentChain = commonSequenceRepository.GetLibiadaChain(sequenceId);
BinaryCharacteristic binaryCharacteristic = characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkId);
IBinaryCalculator calculator = BinaryCalculatorsFactory.CreateCalculator(binaryCharacteristic);
Link link = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkId);
if (frequencyFilter)
{
FrequencyCharacteristic(characteristicLinkId, frequencyCount, currentChain, sequenceId, calculator, link);
}
else
{
NotFrequencyCharacteristic(characteristicLinkId, sequenceId, currentChain, calculator, link);
}
if (filter)
{
filteredResult = db.BinaryCharacteristicValue.Where(b => b.SequenceId == sequenceId && b.CharacteristicLinkId == characteristicLinkId)
.OrderByDescending(b => b.Value)
.Take(filterSize).ToList();
for (int l = 0; l < filterSize; l++)
{
long firstElementId = filteredResult[l].FirstElementId;
firstElements.Add(db.Element.Single(e => e.Id == firstElementId));
}
for (int m = 0; m < filterSize; m++)
{
long secondElementId = filteredResult[m].SecondElementId;
secondElements.Add(db.Element.Single(e => e.Id == secondElementId));
}
}
else
{
characteristics = db.BinaryCharacteristicValue
.Where(b => b.SequenceId == sequenceId && b.CharacteristicLinkId == characteristicLinkId)
.GroupBy(b => b.FirstElementId)
.ToDictionary(b => b.Key, b => b.ToDictionary(bb => bb.SecondElementId, bb => bb.Value));
var elementsIds = db.GetAlphabetElementIds(sequenceId);
elements = db.Element.Where(e => elementsIds.Contains(e.Id)).OrderBy(e => e.Id).ToArray();
}
string characteristicName = characteristicTypeLinkRepository.GetCharacteristicName(characteristicLinkId, notation);
return new Dictionary <string, object>
{
{ "characteristics", characteristics },
{ "isFilter", filter },
{ "filteredResult", filteredResult },
{ "firstElements", firstElements },
{ "secondElements", secondElements },
{ "filterSize", filterSize },
{ "elements", elements },
{ "characteristicName", characteristicName },
{ "matterName", db.CommonSequence.Single(m => m.Id == sequenceId).Matter.Name },
{ "notationName", db.CommonSequence.Single(c => c.Id == sequenceId).Notation.GetDisplayValue() }
};
}));
}
