Exemplo n.º 1
0
        /// <summary>
        /// Fold the strata estimator data.
        /// </summary>
        /// <typeparam name="TEntity">The entity type</typeparam>
        /// <typeparam name="TId">The identifier type</typeparam>
        /// <typeparam name="TCount">The count type</typeparam>
        /// <param name="estimatorData"></param>
        /// <param name="configuration"></param>
        /// <param name="factor">The factor to fold by</param>
        /// <returns>The <paramref name="estimatorData"/> folded by <paramref name="factor"/>.</returns>
        internal static HybridEstimatorFullData <int, TCount> Fold <TEntity, TId, TCount>(
            this IHybridEstimatorFullData <int, TCount> estimatorData,
            IInvertibleBloomFilterConfiguration <TEntity, TId, int, TCount> configuration,
            uint factor)
            where TCount : struct
            where TId : struct
        {
            if (estimatorData == null)
            {
                return(null);
            }
            var minWiseFold = Math.Max(
                1L,
                configuration
                .FoldingStrategy?
                .GetAllFoldFactors(estimatorData.BitMinwiseEstimator?.Capacity ?? 1L)
                .OrderBy(f => f)
                .FirstOrDefault(f => f > factor) ?? 1L);

            return(new HybridEstimatorFullData <int, TCount>
            {
                ItemCount = estimatorData.ItemCount,
                BitMinwiseEstimator = estimatorData.BitMinwiseEstimator?.Fold((uint)minWiseFold),
                StrataEstimator =
                    estimatorData.StrataEstimator?.Fold(configuration.ConvertToEstimatorConfiguration(), factor)
            });
        }
        /// <summary>
        /// Intersect with the estimator.
        /// </summary>
        /// <param name="estimator"></param>
        public void Intersect(IHybridEstimatorFullData <int, TCount> estimator)
        {
            IHybridEstimator <TEntity, int, TCount> self = this;

            Rehydrate(self
                      .FullExtract()
                      .Intersect(_configuration, estimator));
        }
 /// <summary>
 /// Rehydrate the hybrid estimator from full data.
 /// </summary>
 /// <param name="data">The data to restore</param>
 public void Rehydrate(IHybridEstimatorFullData <int, TCount> data)
 {
     if (data == null)
     {
         return;
     }
     _minwiseEstimator?.Rehydrate(data.BitMinwiseEstimator);
     _strataEstimator.Rehydrate(data.StrataEstimator);
     _minwiseReplacementCount = Math.Max(0, data.ItemCount - (_strataEstimator.ItemCount + (_minwiseEstimator?.ItemCount ?? 0L)));
 }
Exemplo n.º 4
0
        /// <summary>
        /// Intersect two hybrid estimators
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <typeparam name="TId"></typeparam>
        /// <typeparam name="TCount"></typeparam>
        /// <param name="estimatorData"></param>
        /// <param name="configuration"></param>
        /// <returns></returns>
        internal static IHybridEstimatorFullData <int, TCount> Intersect <TEntity, TId, TCount>(
            this IHybridEstimatorFullData <int, TCount> estimatorData,
            IInvertibleBloomFilterConfiguration <TEntity, TId, int, TCount> configuration,
            IHybridEstimatorFullData <int, TCount> otherEstimatorData)
            where TId : struct
            where TCount : struct
        {
            if (estimatorData == null && otherEstimatorData == null)
            {
                return(null);
            }
            var res = new HybridEstimatorFullData <int, TCount>();

            res.BitMinwiseEstimator = estimatorData?.BitMinwiseEstimator.Intersect(otherEstimatorData?.BitMinwiseEstimator, configuration.FoldingStrategy);
            res.StrataEstimator     = estimatorData?.StrataEstimator.Intersect(otherEstimatorData?.StrataEstimator, configuration);
            res.ItemCount           = (res.BitMinwiseEstimator?.ItemCount ?? 0L) + (res.StrataEstimator?.ItemCount ?? 0L);
            return(res);
        }
Exemplo n.º 5
0
        /// <summary>
        /// Compress the hybrid estimator.
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <typeparam name="TId"></typeparam>
        /// <typeparam name="TCount"></typeparam>
        /// <param name="estimatorData"></param>
        /// <param name="configuration"></param>
        /// <returns></returns>
        internal static HybridEstimatorFullData <int, TCount> Compress <TEntity, TId, TCount>(
            this IHybridEstimatorFullData <int, TCount> estimatorData,
            IInvertibleBloomFilterConfiguration <TEntity, TId, int, TCount> configuration)
            where TCount : struct
            where TId : struct
        {
            if (configuration?.FoldingStrategy == null || estimatorData == null)
            {
                return(null);
            }
            var fold = configuration.FoldingStrategy.FindCompressionFactor(
                configuration,
                estimatorData.StrataEstimator.BlockSize,
                estimatorData.StrataEstimator.BlockSize,
                estimatorData.ItemCount);
            var res = fold.HasValue ? estimatorData.Fold(configuration, fold.Value) : null;

            return(res);
        }