Example #1
0
        /// <summary>
        /// gets distribution of the value arrays. When predefined ranges are available, this returns distribution by predefined ranges.
        /// </summary>
        /// <returns></returns>
        public virtual BigSegmentedArray GetCountDistribution()
        {
            BigSegmentedArray dist = null;

            if (m_predefinedRangeIndexes != null)
            {
                dist = new LazyBigInt32Array(m_predefinedRangeIndexes.Length);
                int n = 0;
                foreach (int[] range in m_predefinedRangeIndexes)
                {
                    int start = range[0];
                    int end   = range[1];

                    int sum = 0;
                    for (int i = start; i < end; ++i)
                    {
                        sum += m_count.Get(i);
                    }
                    dist.Add(n++, sum);
                }
            }
            else
            {
                dist = m_count;
            }

            return(dist);
        }
Example #2
0
        public virtual BigSegmentedArray GetCountDistribution()
        {
            BigSegmentedArray dist = null;

            if (m_predefinedRanges != null)
            {
                dist = new LazyBigInt32Array(m_predefinedRanges.Count);
                int distIdx = 0;
                for (int i = 0; i < m_count.Length; i++)
                {
                    int count = m_count.Get(i);
                    dist.Add(distIdx++, count);
                }
            }
            return(dist);
        }
Example #3
0
 public virtual FacetIterator GetIterator()
 {
     if (m_predefinedRanges != null)
     {
         BigSegmentedArray rangeCounts = new LazyBigInt32Array(m_predefinedRangeIndexes.Length);
         for (int k = 0; k < m_predefinedRangeIndexes.Length; ++k)
         {
             int count = 0;
             int idx   = m_predefinedRangeIndexes[k][0];
             int end   = m_predefinedRangeIndexes[k][1];
             while (idx <= end)
             {
                 count += m_count.Get(idx++);
             }
             rangeCounts.Add(k, rangeCounts.Get(k) + count);
         }
         return(new DefaultFacetIterator(m_predefinedRanges, rangeCounts, rangeCounts.Length, true));
     }
     return(null);
 }
        public virtual FacetIterator GetIterator()
        {
            // each range is of the form <lat, lon, radius>
            LazyBigInt32Array rangeCounts = new LazyBigInt32Array(m_latPredefinedRangeIndexes.Length);

            for (int i = 0; i < m_latCount.Length; ++i)
            {
                if (m_latCount[i] > 0)
                {
                    for (int k = 0; k < m_latPredefinedRangeIndexes.Length; ++k)
                    {
                        if (i >= m_latPredefinedRangeIndexes[k][0] && i <= m_latPredefinedRangeIndexes[k][1])
                        {
                            rangeCounts.Add(k, rangeCounts.Get(k) + m_latCount[i]);
                        }
                    }
                }
            }
            return(new DefaultFacetIterator(m_predefinedRanges, rangeCounts, rangeCounts.Length, true));
        }
Example #5
0
        public virtual List <BrowseFacet> GetFacetsNew()
        {
            if (m_ospec != null)
            {
                if (m_predefinedRangeIndexes != null)
                {
                    int minCount       = m_ospec.MinHitCount;
                    int maxNumOfFacets = m_ospec.MaxCount;
                    if (maxNumOfFacets <= 0 || maxNumOfFacets > m_predefinedRangeIndexes.Length)
                    {
                        maxNumOfFacets = m_predefinedRangeIndexes.Length;
                    }

                    BigSegmentedArray rangeCount = new LazyBigInt32Array(m_predefinedRangeIndexes.Length);

                    for (int k = 0; k < m_predefinedRangeIndexes.Length; ++k)
                    {
                        int count = 0;
                        int idx   = m_predefinedRangeIndexes[k][0];
                        int end   = m_predefinedRangeIndexes[k][1];
                        while (idx <= end)
                        {
                            count += m_count.Get(idx++);
                        }
                        rangeCount.Add(k, count);
                    }

                    List <BrowseFacet>      facetColl;
                    FacetSpec.FacetSortSpec sortspec = m_ospec.OrderBy;
                    if (sortspec == FacetSpec.FacetSortSpec.OrderValueAsc)
                    {
                        facetColl = new List <BrowseFacet>(maxNumOfFacets);
                        for (int k = 0; k < m_predefinedRangeIndexes.Length; ++k)
                        {
                            if (rangeCount.Get(k) >= minCount)
                            {
                                BrowseFacet choice = new BrowseFacet(m_predefinedRanges.Get(k), rangeCount.Get(k));
                                facetColl.Add(choice);
                            }
                            if (facetColl.Count >= maxNumOfFacets)
                            {
                                break;
                            }
                        }
                    }
                    else //if (sortspec == FacetSortSpec.OrderHitsDesc)
                    {
                        IComparerFactory comparerFactory;
                        if (sortspec == FacetSpec.FacetSortSpec.OrderHitsDesc)
                        {
                            comparerFactory = new FacetHitcountComparerFactory();
                        }
                        else
                        {
                            comparerFactory = m_ospec.CustomComparerFactory;
                        }

                        if (comparerFactory == null)
                        {
                            throw new ArgumentException("facet comparer factory not specified");
                        }

                        IComparer <int> comparer = comparerFactory.NewComparer(new RangeFacetCountCollectorFieldAccessor(m_predefinedRanges), rangeCount);

                        int forbidden = -1;
                        Int32BoundedPriorityQueue pq = new Int32BoundedPriorityQueue(comparer, maxNumOfFacets, forbidden);
                        for (int i = 0; i < m_predefinedRangeIndexes.Length; ++i)
                        {
                            if (rangeCount.Get(i) >= minCount)
                            {
                                pq.Offer(i);
                            }
                        }

                        int val;
                        facetColl = new List <BrowseFacet>();
                        while ((val = pq.Poll()) != forbidden)
                        {
                            BrowseFacet facet = new BrowseFacet(m_predefinedRanges.ElementAt(val), rangeCount.Get(val));
                            facetColl.Insert(0, facet);
                        }
                    }
                    return(facetColl);
                }
                else
                {
                    return(FacetCountCollector.EMPTY_FACET_LIST);
                }
            }
            else
            {
                return(FacetCountCollector.EMPTY_FACET_LIST);
            }
        }