Example #1
0
        public static void demo1()
        {
            // Gamma distribution

            // define distribution parameters
            double mean     = 5;
            double variance = 1.5;
            double alpha    = mean * mean / variance;
            double lambda   = 1 / (variance / mean);

            // for tests and debugging use a random engine with CONSTANT seed --> deterministic and reproducible results
            RandomEngine engine = new MersenneTwister();

            // your favourite distribution goes here
            AbstractDistribution dist = new Gamma(alpha, lambda, engine);

            // collect random numbers and print statistics
            int size    = 100000;
            var numbers = new DoubleArrayList(size);

            for (int i = 0; i < size; i++)
            {
                numbers.Add(dist.NextDouble());
            }

            DynamicBin1D bin = new DynamicBin1D();

            bin.AddAllOf(numbers);
            Console.WriteLine(bin);
        }
 public virtual void AddAllOfFromTo(DoubleArrayList list, int from, int to)
 {
     for (int i = from; i <= to; i++)
     {
         Add(list[i]);
     }
 }
Example #3
0
        /// <summary>
        /// Adds the part of the specified list between indexes <i>from</i> (inclusive) and <i>to</i> (inclusive) to the receiver.
        /// </summary>
        /// <param name="values">the list of which elements shall be added.</param>
        /// <param name="from">the index of the first element to be added (inclusive).</param>
        /// <param name="to">the index of the last element to be added (inclusive).</param>
        public void AddAllOfFromTo(DoubleArrayList values, int from, int to)
        {
            //buffer.AddAllOfFromTo(values, from, to);
            buffer.AddAllOfFromTo(values, from, to);

            this.isSorted = false;
        }
        /// <summary>
        /// Finds the first and last indexes of a specific element within a sorted list.
        /// <summary>
        /// <returns>int[]</returns>
        /// <param name="list">cern.colt.list.DoubleArrayList</param>
        /// <param name="element">the element to search for</param>
        protected static IntArrayList BinaryMultiSearch(DoubleArrayList list, double element)
        {
            int index = list.BinarySearch(element);

            if (index < 0)
            {
                return(null);           //not found
            }
            int from = index - 1;

            while (from >= 0 && list[from] == element)
            {
                from--;
            }
            from++;

            int to = index + 1;

            while (to < list.Count && list[to] == element)
            {
                to++;
            }
            to--;

            return(new IntArrayList(new int[] { from, to }));
        }
        public virtual double Moment(int k, double c)
        {
            if (k < 0)
            {
                throw new ArgumentException(Cern.LocalizedResources.Instance().Exception_KMustBePositive);
            }
            //checkOrder(k);
            if (!HasSumOfPowers(k))
            {
                return(Double.NaN);
            }

            int             maxOrder  = System.Math.Min(k, GetMaxOrderForSumOfPowers());
            DoubleArrayList sumOfPows = new DoubleArrayList(maxOrder + 1);

            sumOfPows.Add(Size);
            sumOfPows.Add(Sum);
            sumOfPows.Add(SumOfSquares);
            for (int i = 3; i <= maxOrder; i++)
            {
                sumOfPows.Add(GetSumOfPowers(i));
            }

            return(Descriptive.Moment(k, c, Size, sumOfPows.ToArray()));
        }
        /// <summary>
        /// Computes the specified quantile elements over the values previously added.
        /// </summary>
        /// <param name="phis">the quantiles for which elements are to be computed. Each phi must be in the interval (0.0,1.0]. <tt>phis</tt> must be sorted ascending.</param>
        /// <returns>the approximate quantile elements.</returns>
        public override DoubleArrayList QuantileElements(DoubleArrayList phis)
        {
            if (precomputeEpsilon <= 0.0)
            {
                return(base.QuantileElements(phis));
            }

            int quantilesToPrecompute = (int)Utils.EpsilonCeiling(1.0 / precomputeEpsilon);

            /*
             * if (phis.Count > quantilesToPrecompute) {
             *  // illegal use case!
             *  // we compute results, but loose explicit approximation guarantees.
             *  return base.QuantileElements(phis);
             * }
             */

            //select that quantile from the precomputed set that corresponds to a position closest to phi.
            phis = phis.Copy();
            double e = precomputeEpsilon;

            for (int index = phis.Size; --index >= 0;)
            {
                double phi = phis[index];
                int    i   = (int)System.Math.Round(((2.0 * phi / e) - 1.0) / 2.0); // finds closest
                i = System.Math.Min(quantilesToPrecompute - 1, System.Math.Max(0, i));
                double augmentedPhi = (e / 2.0) * (1 + 2 * i);
                phis[index] = augmentedPhi;
            }

            return(base.QuantileElements(phis));
        }
Example #7
0
        public void Trim(int s, int l)
        {
            DoubleArrayList elems = SortedElements;

            Clear();
            AddAllOfFromTo(elems, s, elems.Size - 1 - l);
        }
        /// <summary>
        /// Computes the specified quantile elements over the values previously added.
        /// </summary>
        /// <param name="phis">the quantiles for which elements are to be computed. Each phi must be in the interval [0.0,1.0]. <tt>phis</tt> must be sorted ascending.</param>
        /// <returns>the approximate quantile elements.</returns>
        public virtual DoubleArrayList QuantileElements(DoubleArrayList phis)
        {
            /*
             * //check parameter
             */
            List <Double> sortedPhiList = phis.Copy().ToList();

            sortedPhiList.Sort();
            if (!phis.Equals(sortedPhiList))
            {
                throw new ArgumentException(Cern.LocalizedResources.Instance().Exception_PhisMustBeAscending);
            }

            //System.out.println("starting to augment missing values, if necessary...");

            phis = PreProcessPhis(phis);

            long[] triggerPositions = new long[phis.Size];
            long   totalSize        = this.bufferSet.TotalSize;

            for (int i = phis.Size; --i >= 0;)
            {
                triggerPositions[i] = Utils.EpsilonCeiling(phis[i] * totalSize) - 1;
            }

            //System.out.println("triggerPositions="+cern.colt.Arrays.ToString(triggerPositions));
            //System.out.println("starting to determine quantiles...");
            //System.out.println(bufferSet);

            DoubleBuffer[] fullBuffers      = bufferSet.GetFullOrPartialBuffers();
            double[]       quantileElements = new double[phis.Size];

            //do the main work: determine values at given positions in sorted sequence
            return(new DoubleArrayList(bufferSet.GetValuesAtPositions(fullBuffers, triggerPositions)));
        }
Example #9
0
 /// <summary>
 /// Fills the specified array of doubles with random numbers in the interval [0,1).
 /// </summary>
 /// <param name="array">An array of double-precision floating point numbers.</param>
 public void Fill(DoubleArrayList array)
 {
     for (int i = 0; i < array.Count; i++)
     {
         array[i] = NextDouble();
     }
 }
Example #10
0
        /// <summary>
        /// Initializes a new instance of the <see cref="Vector2D"/> class with the specified coordinates.
        /// </summary>
        /// <param name="coordinates">An array containing the coordinate parameters.</param>
        public Vector2D(DoubleArrayList coordinates)
        {
            Debug.Assert(coordinates != null);
            Debug.Assert(coordinates.Count >= 2);

            _x = coordinates[0];
            _y = coordinates[1];
        }
Example #11
0
 /// <summary>
 /// Constructs and returns a new buffer with the given target.
 /// </summary>
 /// <param name="target">the target to flush to.</param>
 /// <param name="capacity">the number of points the buffer shall be capable of holding before overflowing and flushing to the target.</param>
 public DoubleBuffer(IDoubleBufferConsumer target, int capacity)
 {
     this.target   = target;
     this.capacity = capacity;
     this.elements = new double[capacity];
     this.list     = new DoubleArrayList(elements);
     this.size     = 0;
 }
Example #12
0
        /// <summary>
        /// Initializes a new instance of the <see cref="Matrix2D"/> structure with the specified values.
        /// </summary>
        /// <param name="elements">An array containing the matrix values in row-major order.</param>
        public Matrix2D(DoubleArrayList elements)
        {
            Debug.Assert(elements != null);
            Debug.Assert(elements.Count >= 4);

            _m11 = elements[0]; _m12 = elements[1];
            _m21 = elements[2]; _m22 = elements[3];
        }
Example #13
0
 /// <summary>
 /// Initializes a new instance of the <see cref="Vector3"/> class with the specified coordinates.
 /// </summary>
 /// <param name="coordinates">An array containing the coordinate parameters.</param>
 public Vector3(DoubleArrayList coordinates)
     : base()
 {
     Debug.Assert(coordinates != null);
     Debug.Assert(coordinates.Count >= 3);
     m_X = coordinates[0];
     m_Y = coordinates[1];
     m_Z = coordinates[2];
 }
Example #14
0
        /// <summary>
        /// Initializes a new instance of the <see cref="Matrix3F"/> structure with the specified values.
        /// </summary>
        /// <param name="elements">An array containing the matrix values in row-major order.</param>
        public Matrix3D(DoubleArrayList elements)
        {
            Debug.Assert(elements != null);
            Debug.Assert(elements.Count >= 9);

            _m11 = elements[0]; _m12 = elements[1]; _m13 = elements[2];
            _m21 = elements[3]; _m22 = elements[4]; _m23 = elements[5];
            _m31 = elements[6]; _m32 = elements[7]; _m33 = elements[8];
        }
Example #15
0
 /// <summary>
 /// Adds a value to the receiver.
 /// </summary>
 /// <param name="elements"></param>
 /// <param name="from"></param>
 /// <param name="to"></param>
 public void AddAllOfFromTo(DoubleArrayList elements, int from, int to)
 {
     if (!isAllocated)
     {
         Allocate();               // lazy buffer allocation can safe memory.
     }
     values.AddAllOfFromTo(elements, from, to);
     this.isSorted = false;
 }
Example #16
0
 /// <summary>
 /// Constructs and returns an empty bin; implicitly calls {@link #setFixedOrder(Boolean) setFixedOrder(false)}.
 /// </summary>
 public DynamicBin1D() : base()
 {
     this.Clear();
     this._elements          = new DoubleArrayList();
     this._sortedElements    = new DoubleArrayList(0);
     this.FixedOrder         = false;
     this.HasSumOfLogarithms = true;
     this.HasSumOfInversions = true;
 }
Example #17
0
        /// <summary>
        /// Initializes a new instance of the <see cref="Vector4"/> class with the specified coordinates.
        /// </summary>
        /// <param name="coordinates">An array containing the coordinate parameters.</param>
        public Vector4(DoubleArrayList coordinates)
        {
            Debug.Assert(coordinates != null);
            Debug.Assert(coordinates.Count >= 4);

            _x = coordinates[0];
            _y = coordinates[1];
            _z = coordinates[2];
            _w = coordinates[3];
        }
Example #18
0
        /// <summary>
        /// Adds all elements of the specified list to the receiver.
        /// </summary>
        /// <param name="list">the list of which all elements shall be added.</param>
        public void AddAllOf(DoubleArrayList list)
        {
            int listSize = list.Size;

            if (this.size + listSize >= this.capacity)
            {
                Flush();
            }
            this.target.AddAllOf(list);
        }
Example #19
0
        /// <summary>
        /// Initializes a new instance of the <see cref="Matrix4F"/> structure with the specified values.
        /// </summary>
        /// <param name="elements">An array containing the matrix values in row-major order.</param>
        public Matrix4D(DoubleArrayList elements)
        {
            Debug.Assert(elements != null);
            Debug.Assert(elements.Count >= 16);

            _m11 = elements[0]; _m12 = elements[1]; _m13 = elements[2]; _m14 = elements[3];
            _m21 = elements[4]; _m22 = elements[5]; _m23 = elements[6]; _m24 = elements[7];
            _m31 = elements[8]; _m32 = elements[9]; _m33 = elements[10]; _m34 = elements[11];
            _m41 = elements[12]; _m42 = elements[13]; _m43 = elements[14]; _m44 = elements[15];
        }
        /// <summary>
        /// Adds the part of the specified list between indexes <tt>from</tt> (inclusive) and <tt>to</tt> (inclusive) to the receiver.
        /// </summary>
        /// <param name="values">the list of which elements shall be added.</param>
        /// <param name="from">the index of the first element to be added (inclusive).</param>
        /// <param name="to">the index of the last element to be added (inclusive).</param>
        public void AddAllOfFromTo(DoubleArrayList values, int from, int to)
        {
            /*
             * // the obvious version, but we can do quicker...
             * double[] theValues = values.ToArray();
             * int theSize=values.Count;
             * for (int i=0; i<theSize; ) add(theValues[i++]);
             */

            double[] valuesToAdd = values.Elements;
            int      k           = this.bufferSet.NumberOfElements;
            int      bufferSize  = k;

            double[] bufferValues = null;
            if (currentBufferToFill != null)
            {
                bufferValues = currentBufferToFill.Values.Elements;
                bufferSize   = currentBufferToFill.Size;
            }

            for (int i = from - 1; ++i <= to;)
            {
                if (SampleNextElement())
                {
                    if (bufferSize == k)
                    { // full
                        if (bufferSet.GetFirstEmptyBuffer() == null)
                        {
                            Collapse();
                        }
                        NewBuffer();
                        if (!currentBufferToFill.IsAllocated)
                        {
                            currentBufferToFill.Allocate();
                        }
                        currentBufferToFill.IsSorted = false;
                        bufferValues = currentBufferToFill.Values.Elements;
                        bufferSize   = 0;
                    }

                    bufferValues[bufferSize++] = valuesToAdd[i];
                    if (bufferSize == k)
                    { // full
                        currentBufferToFill.Values.SetSize(bufferSize);
                        currentBufferToFill = null;
                    }
                }
            }
            if (this.currentBufferToFill != null)
            {
                this.currentBufferToFill.Values.SetSize(bufferSize);
            }

            this.totalElementsFilled += to - from + 1;
        }
        public void assignLabels( LingoProcessingContext context, DoubleMatrix2D stemCos, IntIntOpenHashMap filteredRowToStemIndex, DoubleMatrix2D phraseCos )
        {
            PreprocessingContext preprocessingContext = context.preprocessingContext;
            int firstPhraseIndex = preprocessingContext.allLabels.firstPhraseIndex;
            int [] labelsFeatureIndex = preprocessingContext.allLabels.featureIndex;
            int [] mostFrequentOriginalWordIndex = preprocessingContext.allStems.mostFrequentOriginalWordIndex;
            int desiredClusterCount = stemCos.columns();

            IntArrayList clusterLabelFeatureIndex = new IntArrayList(
                desiredClusterCount);
            DoubleArrayList clusterLabelScore = new DoubleArrayList(desiredClusterCount);
            for (int label = 0; label < desiredClusterCount; label++)
            {
                Pair<int, int> stemMax = max(stemCos);
                Pair<int, int> phraseMax = max(phraseCos);

                if (stemMax == null && phraseMax == null)
                {
                    break;
                }

                double stemScore = stemMax != null ? stemCos.getQuick(stemMax.objectA,
                    stemMax.objectB) : -1;
                double phraseScore = phraseMax != null ? phraseCos.getQuick(
                    phraseMax.objectA, phraseMax.objectB) : -1;

                if (phraseScore > stemScore)
                {
                    phraseCos.viewRow(phraseMax.objectA).assign(0);
                    phraseCos.viewColumn(phraseMax.objectB).assign(0);
                    stemCos.viewColumn(phraseMax.objectB).assign(0);

                    clusterLabelFeatureIndex.add(labelsFeatureIndex[phraseMax.objectA
                        + firstPhraseIndex]);
                    clusterLabelScore.add(phraseScore);
                }
                else
                {
                    stemCos.viewRow(stemMax.objectA).assign(0);
                    stemCos.viewColumn(stemMax.objectB).assign(0);
                    if (phraseCos != null)
                    {
                        phraseCos.viewColumn(stemMax.objectB).assign(0);
                    }

                    clusterLabelFeatureIndex
                        .add(mostFrequentOriginalWordIndex[filteredRowToStemIndex
                            .get(stemMax.objectA)]);
                    clusterLabelScore.add(stemScore);
                }
            }

            context.clusterLabelFeatureIndex = clusterLabelFeatureIndex.toArray();
            context.clusterLabelScore = clusterLabelScore.toArray();
        }
 protected new DoubleArrayList PreProcessPhis(DoubleArrayList phis)
 {
     if (beta > 1.0)
     {
         phis = phis.Copy();
         for (int i = phis.Size; --i >= 0;)
         {
             phis[i] = (2 * phis[i] + beta - 1) / (2 * beta);
         }
     }
     return(phis);
 }
Example #23
0
        /// <summary>
        /// This method was created in VisualAge.
        /// <summary>
        /// <returns>double[]</returns>
        /// <param name="values">cern.it.hepodbms.primitivearray.DoubleArrayList</param>
        /// <param name="phis">double[]</param>
        public static DoubleArrayList ObservedEpsilonsAtPhis(DoubleArrayList phis, ExactDoubleQuantileFinder exactFinder, IDoubleQuantileFinder approxFinder, double desiredEpsilon)
        {
            DoubleArrayList epsilons = new DoubleArrayList(phis.Count);

            for (int i = phis.Count; --i >= 0;)
            {
                double epsilon = ObservedEpsilonAtPhi(phis[i], exactFinder, approxFinder);
                epsilons.Add(epsilon);
                if (epsilon > desiredEpsilon) Console.WriteLine("Real epsilon = " + epsilon + " is larger than desired by " + (epsilon - desiredEpsilon));
            }
            return epsilons;
        }
Example #24
0
        /// <summary>
        /// 3-d OLAP cube operator; Fills all cells of the given vectors into the given histogram.
        /// If you use Hep.Aida.Ref.Converter.ToString(histo) on the result, the OLAP cube of x-"column" vsd y-"column" vsd z-"column", summing the weights "column" will be printed.
        /// For example, aggregate sales by product by region by time.
        /// <p>
        /// Computes the distinct values of x and y and z, yielding histogram axes that capture one distinct value per bin.
        /// Then fills the histogram.
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="z"></param>
        /// <param name="weights"></param>
        /// <returns>the histogram containing the cube.</returns>
        /// <excption cref="ArgumentException">if <i>x.Count != y.Count || x.Count != z.Count || x.Count != weights.Count</i>.</excption>
        public static Hep.Aida.IHistogram3D cube(DoubleMatrix1D x, DoubleMatrix1D y, DoubleMatrix1D z, DoubleMatrix1D weights)
        {
            if (x.Size != y.Size || x.Size != z.Size || x.Size != weights.Size)
            {
                throw new ArgumentException("vectors must have same size");
            }

            var epsilon  = 1.0E-9;
            var distinct = new DoubleArrayList();
            var vals     = new double[x.Size];
            var sorted   = new DoubleArrayList(vals);

            // compute distinct values of x
            vals = x.ToArray(); // copy x into vals
            sorted.Sort();
            Cern.Jet.Stat.Descriptive.Frequencies(sorted, distinct, null);
            // since bins are right-open [from,to) we need an additional dummy bin so that the last distinct value does not fall into the overflow bin
            if (distinct.Count > 0)
            {
                distinct.Add(distinct[distinct.Count - 1] + epsilon);
            }
            distinct.TrimToSize();
            Hep.Aida.IAxis xaxis = new Hep.Aida.Ref.VariableAxis(distinct.ToArray());

            // compute distinct values of y
            vals = y.ToArray();
            sorted.Sort();
            Cern.Jet.Stat.Descriptive.Frequencies(sorted, distinct, null);
            // since bins are right-open [from,to) we need an additional dummy bin so that the last distinct value does not fall into the overflow bin
            if (distinct.Count > 0)
            {
                distinct.Add(distinct[distinct.Count - 1] + epsilon);
            }
            distinct.TrimToSize();
            Hep.Aida.IAxis yaxis = new Hep.Aida.Ref.VariableAxis(distinct.ToArray());

            // compute distinct values of z
            vals = z.ToArray();
            sorted.Sort();
            Cern.Jet.Stat.Descriptive.Frequencies(sorted, distinct, null);
            // since bins are right-open [from,to) we need an additional dummy bin so that the last distinct value does not fall into the overflow bin
            if (distinct.Count > 0)
            {
                distinct.Add(distinct[distinct.Count - 1] + epsilon);
            }
            distinct.TrimToSize();
            Hep.Aida.IAxis zaxis = new Hep.Aida.Ref.VariableAxis(distinct.ToArray());

            Hep.Aida.IHistogram3D histo = new Hep.Aida.Ref.Histogram3D("Cube", xaxis, yaxis, zaxis);
            return(Histogram(histo, x, y, z, weights));
        }
Example #25
0
        /// <summary>
        /// Computes the specified quantile elements over the values previously added.
        /// </summary>
        /// <param name="phis">the quantiles for which elements are to be computedd Each phi must be in the interval [0.0,1.0]d <i>phis</i> must be sorted ascending.</param>
        /// <returns>the exact quantile elements.</returns>
        public DoubleArrayList QuantileElements(DoubleArrayList phis)
        {
            this.Sort();
            return(Cern.Jet.Stat.Descriptive.Quantiles(this.buffer, phis));

            /*
             * int bufferSize = (int) this.Count;
             * double[] quantileElements = new double[phis.Count];
             * for (int i=phis.Count; --i >=0;) {
             *  int rank=(int)Utils.epsilonCeiling(phis.Get(i)*bufferSize) -1;
             *  quantileElements[i]=buffer.Get(rank);
             * }
             * return new DoubleArrayList(quantileElements);
             */
        }
        public override DoubleArrayList QuantileElements(DoubleArrayList phis)
        {
            /*
             * The KNOWN quantile finder reads off quantiles from FULL buffers only.
             * Since there might be a partially full buffer, this method first satisfies this constraint by temporarily filling a few +infinity, -infinity elements to make up a full block.
             * This is in full conformance with the explicit approximation guarantees.
             *
             * For those of you working on online apps:
             * The approximation guarantees are given for computing quantiles AFTER N elements have been filled, not for intermediate displays.
             * If you have one thread filling and another thread displaying concurrently, you will note that in the very beginning the infinities will dominate the display.
             * This could confuse users, because, of course, they don't expect any infinities, even if they "disappear" after a short while.
             * To prevent panic exclude phi's close to zero or one in the early phases of processing.
             */
            DoubleBuffer partial       = this.BufferSet.GetPartialBuffer();
            int          missingValues = 0;

            if (partial != null)
            { // any auxiliary infinities needed?
                missingValues = BufferSet.BufferSize - partial.Size;
                if (missingValues <= 0)
                {
                    throw new InvalidOperationException("Oops! illegal missing values.");
                }

                //System.out.println("adding "+missingValues+" infinity elements...");
                this.AddInfinities(missingValues, partial);

                //determine beta (N + Infinity values = beta * N)
                this.beta = (this.TotalElementsFilled + missingValues) / (double)this.TotalElementsFilled;
            }
            else
            {
                this.beta = 1.0;
            }

            DoubleArrayList quantileElements = base.QuantileElements(phis);

            // restore state we were in before.
            // remove the temporarily added infinities.
            if (partial != null)
            {
                RemoveInfinitiesFrom(missingValues, partial);
            }

            // now you can continue filling the remaining values, if any.
            return(quantileElements);
        }
Example #27
0
        public Boolean RemoveAllOf(DoubleArrayList list)
        {
            Boolean changed = this.Elements.RemoveAll(list);

            if (changed)
            {
                ClearAllMeasures();
                InvalidateAll();
                //this.Size() = 0;
                if (FixedOrder)
                {
                    this.SortedElements.RemoveAll(list);
                    this.isSorted = true;
                }
            }
            return(changed);
        }
 /// <summary>
 /// Constructs a matrix with a given number of rows and columns.
 /// All entries are initially <i>0</i>.
 /// </summary>
 /// <param name="rows">the number of rows the matrix shall have.</param>
 /// <param name="columns">the number of columns the matrix shall have.</param>
 /// <exception cref="ArgumentException">if <i>rows &lt; 0 || columns &lt; 0 || (double)columns * rows > int.MaxValue</i>.</exception>
 public RCDoubleMatrix2D(int rows, int columns) : base(null)
 {
     try
     {
         Setup(rows, columns);
     }
     catch (ArgumentException exc)
     { // we can hold rows*columns>int.MaxValue cells !
         if (!"matrix too large".Equals(exc.Message))
         {
             throw exc;
         }
     }
     Indexes = new IntArrayList();
     Values  = new DoubleArrayList();
     Starts  = new int[rows + 1];
 }
Example #29
0
        public override String ToString()
        {
            StringBuilder   buf = new StringBuilder(base.ToString());
            DoubleArrayList distinctElements = new DoubleArrayList();
            IntArrayList    freq             = new IntArrayList();

            Frequencies(distinctElements, freq);
            if (distinctElements.Size < 100)
            { // don't cause unintended floods
                buf.Append("Distinct elements: " + distinctElements + "\n");
                buf.Append("Frequencies: " + freq + "\n");
            }
            else
            {
                buf.Append("Distinct elements & frequencies not printed (too many).");
            }
            return(buf.ToString());
        }
        public override void AddAllOfFromTo(DoubleArrayList list, int from, int to)
        {
            base.AddAllOfFromTo(list, from, to);

            if (_sumOfPowers != null)
            {
                //int max_k = this.min_k + this.SumOfPowers.Length-1;
                Descriptive.IncrementalUpdateSumsOfPowers(list, from, to, 3, GetMaxOrderForSumOfPowers(), ref _sumOfPowers);
            }

            if (this.HasSumOfInversions)
            {
                this.SumOfInversions += Descriptive.SumOfInversions(list, from, to);
            }

            if (this.HasSumOfLogarithms)
            {
                this.SumOfLogarithms += Descriptive.SumOfLogarithms(list, from, to);
            }
        }
Example #31
0
        public override void AddAllOfFromTo(DoubleArrayList list, int from, int to)
        {
            //if (this.arguments == null) setUpCache();
            lock (arguments) {
                // prepare arguments
                arguments[0] = this.min;
                arguments[1] = this.max;
                arguments[2] = this.sum;
                arguments[3] = this.sum_xx;

                Descriptive.IncrementalUpdate(list, from, to, ref arguments);

                // store the new parameters back
                this.min    = arguments[0];
                this.max    = arguments[1];
                this.sum    = arguments[2];
                this.sum_xx = arguments[3];

                this.size += to - from + 1;
            }
        }