/// <summary>
        /// Calculation method.
        /// </summary>
        /// <param name="chain">
        /// Source sequence.
        /// </param>
        /// <param name="link">
        /// Redundant parameter, not used in calculations.
        /// </param>
        /// <returns>
        /// Frequency of element in congeneric chain as <see cref="double"/>.
        /// </returns>
        public double Calculate(CongenericChain chain, Link link)
        {
            var count = new ElementsCount();
            var length = new Length();

            return count.Calculate(chain, link) / length.Calculate(chain, link);
        }
        /// <summary>
        /// Calculation method.
        /// </summary>
        /// <param name="chain">
        /// Source sequence.
        /// </param>
        /// <param name="link">
        /// Link of intervals in chain.
        /// </param>
        /// <returns>
        /// Average remoteness <see cref="double"/> value.
        /// </returns>
        public double Calculate(CongenericChain chain, Link link)
        {
            double depth = depthCalculator.Calculate(chain, link);
            int nj = (int)intervalsCount.Calculate(chain, link);

            return nj == 0 ? 0 : depth / nj;
        }
 /// <summary>
 /// Calculation method.
 /// </summary>
 /// <param name="firstChain">
 /// The first chain.
 /// </param>
 /// <param name="secondChain">
 /// The second chain.
 /// </param>
 /// <param name="link">
 /// The link.
 /// </param>
 /// <returns>
 /// The <see cref="double"/>.
 /// </returns>
 public double Calculate(CongenericChain firstChain, CongenericChain secondChain, Link link)
 {
     var partialAccordanceCalculator = new PartialComplianceDegree();
     var firstResult = partialAccordanceCalculator.Calculate(firstChain, secondChain, link);
     var secondResult = partialAccordanceCalculator.Calculate(secondChain, firstChain, link);
     return Math.Sqrt(firstResult * secondResult);
 }
        /// <summary>
        /// Initializes a new instance of the <see cref="AccordanceIntervalsManager"/> class.
        /// </summary>
        /// <param name="firstChain">
        /// The first chain.
        /// </param>
        /// <param name="secondChain">
        /// The second chain.
        /// </param>
        public AccordanceIntervalsManager(CongenericChain firstChain, CongenericChain secondChain)
        {
            this.firstChain = firstChain;
            this.secondChain = secondChain;
            Length = firstChain.GetLength();
            FirstOccurrencesCount = firstChain.OccurrencesCount;
            SecondOccurrencesCount = secondChain.OccurrencesCount;

            FillAccordanceIntervals();
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="BinaryIntervalsManager"/> class.
        /// </summary>
        /// <param name="firstChain">
        /// The first chain.
        /// </param>
        /// <param name="secondChain">
        /// The second chain.
        /// </param>
        public BinaryIntervalsManager(CongenericChain firstChain, CongenericChain secondChain)
        {
            FirstElement = firstChain.Element;
            SecondElement = secondChain.Element;
            FirstChain = firstChain;
            SecondChain = secondChain;
            Length = firstChain.GetLength();

            PairsCount = FillPairsCount();
            relationIntervals = new int[PairsCount];
            FillIntervals();
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="CongenericIntervalsManager"/> class.
        /// </summary>
        /// <param name="chain">
        /// The chain.
        /// </param>
        public CongenericIntervalsManager(CongenericChain chain)
        {
            var positions = chain.Positions;
            int count = positions.Length;

            // if sequence is empty
            if (count == 0)
            {
                throw new ArgumentException("Sequence should not be empty", "chain");
            }

            intervals = new int[count - 1];
            FillIntervals(positions, chain.GetLength());
        }
        /// <summary>
        /// Calculation method.
        /// </summary>
        /// <param name="chain">
        /// Source sequence.
        /// </param>
        /// <param name="link">
        /// Link of intervals in chain.
        /// </param>
        /// <returns>
        /// Variations count as <see cref="double"/>.
        /// </returns>
        public double Calculate(CongenericChain chain, Link link)
        {
            int count = 1;
            for (int i = 0; i < chain.GetLength(); i++)
            {
                var j = chain[i] as ValuePhantom;
                if (j != null)
                {
                    count *= ((ValuePhantom)chain[i]).Cardinality;
                }
            }

            return count;
        }
        /// <summary>
        /// Calculation methods.
        /// </summary>
        /// <param name="firstChain">
        /// The first chain.
        /// </param>
        /// <param name="secondChain">
        /// The second chain.
        /// </param>
        /// <param name="link">
        /// The link.
        /// </param>
        /// <returns>
        /// The <see cref="double"/>.
        /// </returns>
        public double Calculate(CongenericChain firstChain, CongenericChain secondChain, Link link)
        {
            var manager = new AccordanceIntervalsManager(firstChain, secondChain);
            if (manager.FilteredFirstIntervals.Count == 0)
            {
                return 0;
            }

            double result = 1;

            for (int i = 0; i < manager.FilteredFirstIntervals.Count; i++)
            {
                result *= LocalCompliance(manager.FilteredFirstIntervals[i], manager.FilteredSecondIntervals[i]);
            }

            double firstAndSecondOccurrences = manager.FirstOccurrencesCount + manager.SecondOccurrencesCount;

            double occurrencesCoefficient = 2.0 * manager.FilteredFirstIntervals.Count / firstAndSecondOccurrences;

            result = occurrencesCoefficient * Math.Pow(result, 1.0 / manager.FilteredFirstIntervals.Count);
            return result;
        }
 /// <summary>
 /// Calculation method.
 /// </summary>
 /// <param name="chain">
 /// Source sequence.
 /// </param>
 /// <param name="link">
 /// Redundant parameter, not used in calculations.
 /// </param>
 /// <returns>
 /// Cut length as <see cref="double"/>.
 /// </returns>
 public double Calculate(CongenericChain chain, Link link)
 {
     return CutCommon(chain);
 }
 /// <summary>
 /// Calculation method.
 /// </summary>
 /// <param name="chain">
 /// Source sequence.
 /// </param>
 /// <param name="link">
 /// Link of intervals in chain.
 /// </param>
 /// <returns>
 /// Regularity as <see cref="double"/>.
 /// </returns>
 public double Calculate(CongenericChain chain, Link link)
 {
     return geometricMean.Calculate(chain, link) / descriptiveInformation.Calculate(chain, link);
 }
        /// <summary>
        /// Calculated as product of all intervals in sequence.
        /// </summary>
        /// <param name="chain">
        /// Source sequence.
        /// </param>
        /// <param name="link">
        /// Redundant parameter, not used in calculations.
        /// </param>
        /// <returns>
        /// Volume characteristic of chain as <see cref="double"/>.
        /// </returns>
        public double Calculate(CongenericChain chain, Link link)
        {
            var intervals = chain.GetIntervals(link);

            return intervals.Length == 0 ? 1 : intervals.Aggregate((result, interval) => result * interval);
        }
 /// <summary>
 /// Calculation method.
 /// </summary>
 /// <param name="chain">
 /// Source sequence.
 /// </param>
 /// <param name="link">
 /// Link of intervals in chain.
 /// </param>
 /// <returns>
 /// Descriptive informations count as <see cref="double"/>.
 /// </returns>
 public double Calculate(CongenericChain chain, Link link)
 {
     var calculator = new ArithmeticMean();
     double arithmeticMean = calculator.Calculate(chain, link);
     return arithmeticMean == 0 ? 1 : Math.Pow(arithmeticMean, 1 / arithmeticMean);
 }
        /// <summary>
        /// Logarithm of all intervals multiplied.
        /// </summary>
        /// <param name="chain">
        /// Source sequence.
        /// </param>
        /// <param name="link">
        /// Link of intervals in chain.
        /// </param>
        /// <returns>
        /// <see cref="double"/> value of alphabetic average remoteness.
        /// </returns>
        /// <exception cref="InvalidOperationException">
        /// Thrown if method is called not from <see cref="Calculate(Chain,Link)"/> and alphabet cardinality is unknown.
        /// </exception>
        /// <exception cref="ArgumentException">
        /// Thrown if link is unknown.
        /// </exception>
        private double Calculate(CongenericChain chain, Link link)
        {
            int[] intervals = chain.GetIntervals(link);

            return intervals.Length == 0 ? 0 : intervals.Sum(interval => Math.Log(interval, alphabetCardinality));
        }
        /// <summary>
        /// Calculation method.
        /// </summary>
        /// <param name="chain">
        /// Source sequence.
        /// </param>
        /// <param name="link">
        /// Link of intervals in chain.
        /// </param>
        /// <returns>
        /// Average geometric of intervals lengths as <see cref="double"/>.
        /// </returns>
        public double Calculate(CongenericChain chain, Link link)
        {
            double remoteness = averageRemoteness.Calculate(chain, link);

            return Math.Pow(2, remoteness);
        }
        /// <summary>
        /// Calculation method.
        /// </summary>
        /// <param name="chain">
        /// Source sequence.
        /// </param>
        /// <param name="link">
        /// Link of intervals in chain.
        /// </param>
        /// <returns>
        /// Identification informations count as <see cref="double"/>.
        /// </returns>
        public double Calculate(CongenericChain chain, Link link)
        {
            double mean = arithmeticMean.Calculate(chain, link);

            return mean == 0 ? 0 : (-1 / mean) * Math.Log(1 / mean, 2);
        }
 /// <summary>
 /// Calculation method.
 /// </summary>
 /// <param name="chain">
 /// Source sequence.
 /// </param>
 /// <param name="link">
 /// Redundant parameter, not used in calculations.
 /// </param>
 /// <returns>
 /// Chain length as <see cref="double"/>.
 /// </returns>
 public double Calculate(CongenericChain chain, Link link)
 {
     return chain.GetLength();
 }
 /// <summary>
 /// Calculation method.
 /// </summary>
 /// <param name="chain">
 /// Source sequence.
 /// </param>
 /// <param name="link">
 /// Redundant parameter, not used in calculations.
 /// </param>
 /// <returns>
 /// Cut length vocabulary entropy as <see cref="double"/>.
 /// </returns>
 public double Calculate(CongenericChain chain, Link link)
 {
     return Math.Log(chain.GetLength() - cutLength.Calculate(chain, link) + 1, 2);
 }
 /// <summary>
 /// Calculation method for congeneric sequences.
 /// </summary>
 /// <param name="chain">
 /// The congeneric chain.
 /// </param>
 /// <param name="link">
 /// The link.
 /// </param>
 /// <returns>
 /// The <see cref="double"/>.
 /// </returns>
 public double Calculate(CongenericChain chain, Link link)
 {
     return entropyCalculator.Calculate(chain, link) - remotenessCalculator.Calculate(chain, link);
 }
        public ActionResult Index(
            long[] matterIds,
            int characteristicLinkId,
            Notation notation,
            Language?language,
            Translator?translator,
            PauseTreatment?pauseTreatment,
            bool?sequentialTransfer,
            string calculationType)
        {
            return(CreateTask(() =>
            {
                if (matterIds.Length != 2)
                {
                    throw new ArgumentException("Number of selected matters must be 2.", nameof(matterIds));
                }

                var characteristics = new List <List <double> >();
                string characteristicName = characteristicTypeLinkRepository.GetCharacteristicName(characteristicLinkId, notation);
                var result = new Dictionary <string, object>
                {
                    { "characteristics", characteristics },
                    { "matterNames", db.Matter.Where(m => matterIds.Contains(m.Id)).Select(m => m.Name).ToList() },
                    { "characteristicName", characteristicName },
                    { "calculationType", calculationType }
                };

                long firstMatterId = matterIds[0];
                long secondMatterId = matterIds[1];
                long firstSequenceId;
                long secondSequenceId;
                switch (notation.GetNature())
                {
                case Nature.Literature:
                    firstSequenceId = db.LiteratureSequence.Single(l => l.MatterId == firstMatterId &&
                                                                   l.Notation == notation &&
                                                                   l.Language == language &&
                                                                   l.Translator == translator).Id;
                    secondSequenceId = db.LiteratureSequence.Single(l => l.MatterId == secondMatterId &&
                                                                    l.Notation == notation &&
                                                                    l.Language == language &&
                                                                    l.Translator == translator).Id;
                    break;

                case Nature.Music:
                    firstSequenceId = db.MusicSequence.Single(m => m.MatterId == firstMatterId &&
                                                              m.Notation == notation &&
                                                              m.PauseTreatment == pauseTreatment &&
                                                              m.SequentialTransfer == sequentialTransfer).Id;
                    secondSequenceId = db.MusicSequence.Single(m => m.MatterId == secondMatterId &&
                                                               m.Notation == notation &&
                                                               m.PauseTreatment == pauseTreatment &&
                                                               m.SequentialTransfer == sequentialTransfer).Id;
                    break;

                default:
                    firstSequenceId = db.CommonSequence.Single(c => c.MatterId == firstMatterId && c.Notation == notation).Id;
                    secondSequenceId = db.CommonSequence.Single(c => c.MatterId == secondMatterId && c.Notation == notation).Id;
                    break;
                }

                Chain firstChain = commonSequenceRepository.GetLibiadaChain(firstSequenceId);
                Chain secondChain = commonSequenceRepository.GetLibiadaChain(secondSequenceId);

                AccordanceCharacteristic accordanceCharacteristic = characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkId);
                IAccordanceCalculator calculator = AccordanceCalculatorsFactory.CreateCalculator(accordanceCharacteristic);
                Link link = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkId);
                Alphabet firstChainAlphabet = firstChain.Alphabet;
                Alphabet secondChainAlphabet = secondChain.Alphabet;

                switch (calculationType)
                {
                case "Equality":
                    if (!firstChainAlphabet.SetEquals(secondChainAlphabet))
                    {
                        throw new Exception("Alphabets of sequences are not equal.");
                    }

                    characteristics.Add(new List <double>());
                    characteristics.Add(new List <double>());
                    var alphabet = new List <string>();

                    for (int i = 0; i < firstChainAlphabet.Cardinality; i++)
                    {
                        IBaseObject element = firstChainAlphabet[i];
                        alphabet.Add(element.ToString());

                        CongenericChain firstCongenericChain = firstChain.CongenericChain(element);
                        CongenericChain secondCongenericChain = secondChain.CongenericChain(element);

                        double characteristicValue = calculator.Calculate(firstCongenericChain, secondCongenericChain, link);
                        characteristics[0].Add(characteristicValue);

                        characteristicValue = calculator.Calculate(secondCongenericChain, firstCongenericChain, link);
                        characteristics[1].Add(characteristicValue);
                    }

                    result.Add("alphabet", alphabet);
                    break;

                case "All":
                    var firstAlphabet = new List <string>();
                    for (int i = 0; i < firstChain.Alphabet.Cardinality; i++)
                    {
                        characteristics.Add(new List <double>());
                        IBaseObject firstElement = firstChainAlphabet[i];
                        firstAlphabet.Add(firstElement.ToString());
                        for (int j = 0; j < secondChainAlphabet.Cardinality; j++)
                        {
                            var secondElement = secondChainAlphabet[j];

                            var firstCongenericChain = firstChain.CongenericChain(firstElement);
                            var secondCongenericChain = secondChain.CongenericChain(secondElement);

                            var characteristicValue = calculator.Calculate(firstCongenericChain, secondCongenericChain, link);
                            characteristics[i].Add(characteristicValue);
                        }
                    }

                    var secondAlphabet = new List <string>();
                    for (int j = 0; j < secondChainAlphabet.Cardinality; j++)
                    {
                        secondAlphabet.Add(secondChainAlphabet[j].ToString());
                    }

                    result.Add("firstAlphabet", firstAlphabet);
                    result.Add("secondAlphabet", secondAlphabet);
                    break;

                case "Specified":
                    throw new NotImplementedException();

                default:
                    throw new ArgumentException("Calculation type is not implemented", nameof(calculationType));
                }

                return result;
            }));
        }
 /// <summary>
 /// Amount of not empty positions, 
 /// in other words elements count.
 /// </summary>
 /// <param name="chain">
 /// Source sequence.
 /// </param>
 /// <param name="link">
 /// Redundant parameter, not used in calculations.
 /// </param>
 /// <returns>
 /// Elements count in chain as <see cref="double"/>.
 /// </returns>
 public double Calculate(CongenericChain chain, Link link)
 {
     return chain.OccurrencesCount;
 }
 /// <summary>
 /// Calculation method.
 /// </summary>
 /// <param name="chain">
 /// Source sequence.
 /// </param>
 /// <param name="link">
 /// Link of intervals in chain.
 /// </param>
 /// <returns>
 /// Periodicity as <see cref="double"/>.
 /// </returns>
 public double Calculate(CongenericChain chain, Link link)
 {
     return geometricMean.Calculate(chain, link) / arithmeticMean.Calculate(chain, link);
 }
Example #22
0
        public ActionResult Index(
            long[] matterIds,
            int characteristicLinkId,
            Notation notation,
            Language?language,
            Translator?translator,
            PauseTreatment?pauseTreatment,
            bool?sequentialTransfer,
            ImageOrderExtractor?trajectory,
            string calculationType)
        {
            return(CreateTask(() =>
            {
                if (matterIds.Length != 2)
                {
                    throw new ArgumentException("Number of selected matters must be 2.", nameof(matterIds));
                }

                var characteristics = new Dictionary <int, Dictionary <int, double> >();
                string characteristicName = characteristicTypeLinkRepository.GetCharacteristicName(characteristicLinkId, notation);
                var result = new Dictionary <string, object>
                {
                    { "characteristics", characteristics },
                    { "matterNames", Cache.GetInstance().Matters.Where(m => matterIds.Contains(m.Id)).Select(m => m.Name).ToList() },
                    { "characteristicName", characteristicName },
                    { "calculationType", calculationType }
                };

                var sequenceIds = commonSequenceRepository.GetSequenceIds(matterIds,
                                                                          notation,
                                                                          language,
                                                                          translator,
                                                                          pauseTreatment,
                                                                          sequentialTransfer,
                                                                          trajectory);

                Chain firstChain = commonSequenceRepository.GetLibiadaChain(sequenceIds[0]);
                Chain secondChain = commonSequenceRepository.GetLibiadaChain(sequenceIds[1]);

                AccordanceCharacteristic accordanceCharacteristic = characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkId);
                IAccordanceCalculator calculator = AccordanceCalculatorsFactory.CreateCalculator(accordanceCharacteristic);
                Link link = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkId);
                Alphabet firstChainAlphabet = firstChain.Alphabet;
                Alphabet secondChainAlphabet = secondChain.Alphabet;

                switch (calculationType)
                {
                case "Equality":
                    if (!firstChainAlphabet.SetEquals(secondChainAlphabet))
                    {
                        throw new Exception("Alphabets of sequences are not equal.");
                    }

                    characteristics.Add(0, new Dictionary <int, double>());
                    characteristics.Add(1, new Dictionary <int, double>());
                    var alphabet = new List <string>();

                    for (int i = 0; i < firstChainAlphabet.Cardinality; i++)
                    {
                        IBaseObject element = firstChainAlphabet[i];
                        alphabet.Add(element.ToString());

                        CongenericChain firstCongenericChain = firstChain.CongenericChain(element);
                        CongenericChain secondCongenericChain = secondChain.CongenericChain(element);

                        double characteristicValue = calculator.Calculate(firstCongenericChain, secondCongenericChain, link);
                        characteristics[0].Add(i, characteristicValue);

                        characteristicValue = calculator.Calculate(secondCongenericChain, firstCongenericChain, link);
                        characteristics[1].Add(i, characteristicValue);
                    }

                    result.Add("alphabet", alphabet);
                    break;

                case "All":
                    var firstAlphabet = new List <string>();
                    for (int i = 0; i < firstChain.Alphabet.Cardinality; i++)
                    {
                        characteristics.Add(i, new Dictionary <int, double>());
                        IBaseObject firstElement = firstChainAlphabet[i];
                        firstAlphabet.Add(firstElement.ToString());
                        for (int j = 0; j < secondChainAlphabet.Cardinality; j++)
                        {
                            var secondElement = secondChainAlphabet[j];

                            var firstCongenericChain = firstChain.CongenericChain(firstElement);
                            var secondCongenericChain = secondChain.CongenericChain(secondElement);

                            var characteristicValue = calculator.Calculate(firstCongenericChain, secondCongenericChain, link);
                            characteristics[i].Add(j, characteristicValue);
                        }
                    }

                    var secondAlphabet = new List <string>();
                    for (int j = 0; j < secondChainAlphabet.Cardinality; j++)
                    {
                        secondAlphabet.Add(secondChainAlphabet[j].ToString());
                    }

                    result.Add("firstAlphabet", firstAlphabet);
                    result.Add("secondAlphabet", secondAlphabet);
                    break;

                case "Specified":
                    throw new NotImplementedException();

                default:
                    throw new ArgumentException("Calculation type is not implemented", nameof(calculationType));
                }

                return new Dictionary <string, string> {
                    { "data", JsonConvert.SerializeObject(result) }
                };
            }));
        }
        /// <summary>
        /// Calculated as base 2 logarithm of multiplication 
        /// of intervals between nearest elements 
        /// in congeneric sequence.
        /// </summary>
        /// <param name="chain">
        /// Congeneric sequence.
        /// </param>
        /// <param name="link">
        /// Link of intervals in chain.
        /// </param>
        /// <returns>
        /// <see cref="double"/> value of depth.
        /// </returns>
        public double Calculate(CongenericChain chain, Link link)
        {
            var intervals = chain.GetIntervals(link);

            return intervals.Length == 0 ? 0 : intervals.Sum(interval => Math.Log(interval, 2));
        }
 /// <summary>
 /// Calculates multiplication of all intervals 
 /// between nearest elements in congeneric sequence
 /// divided by number of intervals.
 /// </summary>
 /// <param name="chain">
 /// Source sequence.
 /// </param>
 /// <param name="link">
 /// Link of intervals in chain.
 /// </param>
 /// <returns>
 /// <see cref="double"/> value of average arithmetic of intervals lengths.
 /// </returns>
 public double Calculate(CongenericChain chain, Link link)
 {
     double sum = adder.Calculate(chain, link);
     int intervalsCount = (int)counter.Calculate(chain, link);
     return intervalsCount == 0 ? 0 : sum / intervalsCount;
 }
 /// <summary>
 /// If link is to start, to end or cycle then intervals count equals elements count.
 /// If link is to start and end then intervals count equals elements count + 1.
 /// If link is none then intervals count equals elements count - 1.
 /// </summary>
 /// <param name="chain">
 /// Source sequence.
 /// </param>
 /// <param name="link">
 /// Link of intervals in chain.
 /// </param>
 /// <returns>
 /// Intervals count in chain as <see cref="double"/>.
 /// </returns>
 public double Calculate(CongenericChain chain, Link link)
 {
     return chain.GetIntervals(link).Length;
 }