std::size_t FSBloomFilter::containsAll(const unsigned char *keys, const std::size_t count) const { uint64_t hashes[count * this->functionCount_]; for (std::size_t i = 0; i < count; i++) { for (std::size_t j = 0; j < this->functionCount_; j++) { hashes[i * this->functionCount_ + j] = this->hashFunction_->operator ()( keys + (this->cryptoHashFunction_.getHashSize() * i), this->cryptoHashFunction_.getHashSize(), j) % this->filterSize_; } } std::sort(hashes, hashes + (count * this->functionCount_)); std::size_t bit_index = 0; std::size_t bit = 0; for (std::size_t i = 0; i < count * this->functionCount_; i++) { compute_indices(hashes[i], bit_index, bit); if ((this->bitArray_[bit_index] & bit_mask[bit]) != bit_mask[bit]) { return i == 0 ? 1 : i; } } return true; }
void FSBloomFilter::addAll(const unsigned char* keys, const std::size_t count) { if (this->hardMaximum_ && this->itemCount_ + count > maxElements_) throw std::runtime_error("Maximum of Elements reached, adding failed"); uint64_t hashes[count * this->functionCount_]; for (std::size_t i = 0; i < count; i++) { for (std::size_t j = 0; j < this->functionCount_; j++) { hashes[i * this->functionCount_ + j] = this->hashFunction_->operator ()( keys + (this->cryptoHashFunction_.getHashSize() * i), this->cryptoHashFunction_.getHashSize(), j); } } std::sort(hashes, hashes + (count * this->functionCount_)); std::size_t bit_index = 0; std::size_t bit = 0; for (std::size_t i = 0; i < count * this->functionCount_; i++) { compute_indices(hashes[i], bit_index, bit); this->bitArray_[bit_index] |= bit_mask[bit]; } if (this->itemCount_ + count < std::numeric_limits<uint64_t>::max()) { this->itemCount_ += count; } else { this->itemCount_ = std::numeric_limits<uint64_t>::max(); } }
/** * @brief Inserts a given value into the bloom filter. * * @param key_begin A pointer to the value being inserted. * @param length Size of the value being inserted in bytes. */ inline void insert(const std::uint8_t *key_begin, const std::size_t &length) { std::size_t bit_index = 0; std::size_t bit = 0; for (std::size_t i = 0; i < hash_fn_count_; ++i) { compute_indices(hash_ap(key_begin, length, hash_fn_[i]), &bit_index, &bit); bit_array_[bit_index / kNumBitsPerByte] |= (1 << bit); } ++inserted_element_count_; }
inline void insert(const integer key) { std::size_t bit_index = 0; std::size_t bit = 0; for(std::size_t i = 0;i < hash_count_; ++i) { compute_indices((hash_[i]).GetHashValue(key),bit_index,bit); bit_table_[bit_index / bits_per_char] |= bit_mask[bit]; } ++inserted_element_count_; }
/** * @brief Test membership of a given value in the bloom filter. * If true is returned, then a value may or may not be present in the bloom filter. * If false is returned, a value is certainly not present in the bloom filter. * * @param key_begin A pointer to the value being tested for membership. * @param length Size of the value being inserted in bytes. */ inline bool contains(const std::uint8_t *key_begin, const std::size_t length) const { std::size_t bit_index = 0; std::size_t bit = 0; for (std::size_t i = 0; i < hash_fn_count_; ++i) { compute_indices(hash_ap(key_begin, length, hash_fn_[i]), &bit_index, &bit); if ((bit_array_[bit_index / kNumBitsPerByte] & (1 << bit)) != (1 << bit)) { return false; } } return true; }
bool FSBloomFilter::contains(const unsigned char *key) const { std::size_t bit_index = 0; std::size_t bit = 0; for (std::size_t i = 0; i < this->functionCount_; i++) { uint64_t pos = this->hashFunction_->operator ()(key, this->cryptoHashFunction_.getHashSize(), i) % this->filterSize_; compute_indices(pos, bit_index, bit); if ((this->bitArray_[bit_index] & bit_mask[bit]) != bit_mask[bit]) { return false; } } return true; }
void FSBloomFilter::add(const unsigned char *key) { if (this->hardMaximum_ && this->itemCount_ >= maxElements_) throw std::runtime_error("Maximum of Elements reached, adding failed"); std::size_t bit_index = 0; std::size_t bit = 0; for (std::size_t i = 0; i < this->functionCount_; i++) { uint64_t pos = this->hashFunction_->operator ()(key, this->cryptoHashFunction_.getHashSize(), i) % this->filterSize_; compute_indices(pos, bit_index, bit); this->bitArray_[bit_index] |= bit_mask[bit]; } if (this->itemCount_ < std::numeric_limits<uint64_t>::max()) this->itemCount_++; }
inline virtual bool contains(const integer key) const { std::size_t bit_index = 0; std::size_t bit = 0; for (std::size_t i = 0; i < hash_count_; ++i) { compute_indices((hash_[i]).GetHashValue(key),bit_index,bit); if ((bit_table_[bit_index / bits_per_char] & bit_mask[bit]) != bit_mask[bit]) { return false; } } return true; }
int C2F(intihm)() { /* une routine d'insertion pour hypermatrice : cas le plus simple : A( vi1, ..., vik ) = B ihm ( vi1, vi2, ..., vik, B, A ) avec des vecteurs d'indices classiques vi1, vi2, .... et B une hypermatrice ou bien une matrice */ HyperMat A, B; int i, k,/* l, li, m, n,*/ ntot, mn,/* err_neg,*/ iconf, ind_max; int nb_index_vectors, B_is_scalar; int *j,/* nd,*/ one = 1, ltot, il, dec/*, Top_save*/; int *PA, *PB; short int *siPA, *siPB; char *cPA, *cPB; int ilp, topk; /* CheckLhs(minlhs,maxlhs); */ if ( Rhs < 3 ) { Scierror(999, _("%s: Wrong number of input arguments: at least %d expected.\n"), "hmops", 3); return 0; }; nb_index_vectors = Rhs - 2; if ( ! get_hmat(Rhs, &A) ) { Scierror(999, _("%s: Wrong type for input argument(s): An hypermatrix expected.\n"), "hmops"); return 0; } else if ( A.type == NOT_REAL_or_CMPLX_or_BOOL_or_INT || A.type == OLD_HYPERMAT ) { /* do the job by the %x_i_hm macro family */ Fin = -Fin; return 0; } if ( ! get_hmat(Rhs - 1, &B) ) /* B is not an hypermat => try if it is a matrix */ if ( ! get_mat_as_hmat(Rhs - 1, &B) ) /* it is not a matrix of type 1, 4 or 8 */ { /* it stays some authorized possibilities like A(....) = B with B a polynomial * matrix and A a real hypermatrix => try the %x_i_hm macro family */ Fin = -Fin; return 0; } if ( A.type != B.type || A.it != B.it || B.size == 0 || A.dimsize < nb_index_vectors ) { /* do the job by the %x_i_hm macro family */ Fin = -Fin; return 0; } if ( B.size == 1 ) { B_is_scalar = 1; } else { B_is_scalar = 0; } if ( A.dimsize > nb_index_vectors ) { ReshapeHMat(Rhs + 1, &A, nb_index_vectors); dec = Rhs + 1; } else { dec = Rhs; } /* get the index vectors */ ntot = 1; iconf = 0; for ( i = 1 ; i <= nb_index_vectors ; i++ ) { if (! create_index_vector(i, dec + i, &mn, A.dims[i - 1], &ind_max)) { return 0; } if ( mn == 0 ) /* the i th index vector is [] */ { if ( B_is_scalar ) /* nothing append (strange but reproduces the Matlab behavior) */ { goto the_end; } else /* B have at least 2 elts */ { Scierror(999, _("%s: Bad hypermatrix insertion.\n"), "hmops"); return 0; } } else if ( ind_max > A.dims[i - 1] ) { /* we have to enlarge the hypermat : do the job by the %x_i_hm macro family */ Fin = -Fin; return 0; } else if ( !B_is_scalar && mn != 1 ) /* do the conformity test */ { while ( iconf < B.dimsize && B.dims[iconf] == 1 ) { iconf++; } if ( iconf >= B.dimsize || B.dims[iconf] != mn ) { Scierror(999, _("%s: Bad hypermatrix insertion.\n"), "hmops"); return 0; } iconf++; } ntot *= mn; } /* to finish the conformity test */ if ( !B_is_scalar && ntot != B.size ) { Scierror(999, _("%s: Bad hypermatrix insertion.\n"), "hmops"); return 0; } /* indices computing */ ltot = 4; CreateVar(dec + Rhs - 1, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &ntot, &one, <ot); j = istk(ltot); compute_indices(dec, nb_index_vectors, A.dims, j); /* modify in place the hypermatrix A */ switch ( A.type ) { case (sci_matrix) : if ( B_is_scalar ) { for ( k = 0 ; k < ntot ; k++ ) { A.R[j[k]] = B.R[0]; } if (A.it == 1) for ( k = 0 ; k < ntot ; k++ ) { A.I[j[k]] = B.I[0]; } } else { for ( k = 0 ; k < ntot ; k++ ) { A.R[j[k]] = B.R[k]; } if (A.it == 1) for ( k = 0 ; k < ntot ; k++ ) { A.I[j[k]] = B.I[k]; } } break; case (sci_boolean) : PA = (int *) A.P ; PB = (int *) B.P; if ( B_is_scalar ) for ( k = 0 ; k < ntot ; k++ ) { PA[j[k]] = PB[0]; } else for ( k = 0 ; k < ntot ; k++ ) { PA[j[k]] = PB[k]; } break; case (sci_ints) : if ( A.it == I_INT32 || A.it == I_UINT32 ) { PA = (int *) A.P ; PB = (int *) B.P; if ( B_is_scalar ) for ( k = 0 ; k < ntot ; k++ ) { PA[j[k]] = PB[0]; } else for ( k = 0 ; k < ntot ; k++ ) { PA[j[k]] = PB[k]; } } else if ( A.it == I_INT16 || A.it == I_UINT16 ) { siPA = (short int *) A.P; siPB = (short int *) B.P; if ( B_is_scalar ) for ( k = 0 ; k < ntot ; k++ ) { siPA[j[k]] = siPB[0]; } else for ( k = 0 ; k < ntot ; k++ ) { siPA[j[k]] = siPB[k]; } } else /* 1 Byte int */ { cPA = (char *) A.P; cPB = (char *) B.P; if ( B_is_scalar ) for ( k = 0 ; k < ntot ; k++ ) { cPA[j[k]] = cPB[0]; } else for ( k = 0 ; k < ntot ; k++ ) { cPA[j[k]] = cPB[k]; } } break; } /* * ici j'essaie de faire le boulot de putlhsvar * le code se base sur setref (SCI/system/createref.f) * on met une variable speciale "en Top" (le nouveau * Top = Top-Rhs+1) qui indique en fait que l'on a * modifi� "en place" la variable topk. * Les instructions LhsVar(1) = 0; et Nbvars = 0; * permettent a priori de sortir "convenablement" * de putlhsvar. */ the_end: il = iadr(*Lstk(Top)); topk = *istk(il + 2); Top = Top - Rhs + 1; ilp = iadr(*Lstk(Top)); *istk(ilp) = -1; *istk(ilp + 1) = -1; *istk(ilp + 2) = topk; if ( topk > 0 ) { *istk(ilp + 3) = *Lstk(topk + 1) - *Lstk(topk); } else { *istk(ilp + 3) = 0; } *Lstk(Top + 1) = sadr(ilp + 4); LhsVar(1) = 0; Nbvars = 0; return 0; }
int C2F(intehm)() { /* * Extraction routine for an hypermatrix of type REAL_OR_COMPLEX, BOOLEAN * and INTEGER (the 6 types of scilab ints) * * He = ehm ( v_1, v_2, ..., v_nb_iv, H ) * */ HyperMat H, He; int dec, i, k, l, m, n, mn, ntot, ind_max; int *j, ier, one = 1, zero = 0, ltot, nb_index_vectors, final_dimsize, lr, lc; int *P, *Pe; short int *siP, *siPe; char *cP, *cPe; /* CheckLhs(minlhs,maxlhs); */ if ( Rhs < 2 ) { Scierror(999, _("%s: Wrong number of input arguments: at least %d expected.\n"), "hmops", 2); return(0); }; if ( ! get_hmat(Rhs, &H) ) { Scierror(999, _("%s: Wrong type for input argument(s): An hypermatrix expected.\n"), "hmops"); return 0; } else if ( H.type == NOT_REAL_or_CMPLX_or_BOOL_or_INT || H.type == OLD_HYPERMAT ) { /* do the extraction with the macro %hm_e */ Fin = -Fin; return 0; } nb_index_vectors = Rhs - 1; if ( H.dimsize < nb_index_vectors ) { Scierror(999, _("%s: Wrong number of input arguments: at most %d expected.\n"), "hmops", H.dimsize); return 0; } else if ( H.dimsize > nb_index_vectors ) /* reshape H */ { ReshapeHMat(Rhs + 1, &H, nb_index_vectors ); dec = Rhs + 1; } else { dec = Rhs; } if ( H.size == 0 ) /* the hypermat is empty => return an empty matrix ? */ { CreateVar(dec + 1, MATRIX_OF_DOUBLE_DATATYPE, &zero, &zero, &l); LhsVar(1) = dec + 1; PutLhsVar(); return 0; } ntot = 1; /* will be the nb of elts of the extracted hmat or mat */ for ( i = 1 ; i <= nb_index_vectors ; i++ ) { ier = create_index_vector(i, dec + i, &mn, H.dims[i - 1], &ind_max); if ( ier == 0 || ind_max > H.dims[i - 1] ) { Scierror(999, _("%s: Bad index #%d in hypermatrix extraction. "), "hmops", i); return 0; } if ( mn == 0 ) /* the vector index is [] => we return an empty matrix */ { CreateVar(dec + i + 1, MATRIX_OF_DOUBLE_DATATYPE, &zero, &zero, &l); LhsVar(1) = dec + i + 1; PutLhsVar(); return 0; } ntot *= mn; } /* For the Matlab compatibility : an hypermatrix of profil n1 x ... x nj x ... x nk * with nj > 1 and nj+1 = ... = nk = 1 becomes an hypermatrix of profil n1 x ... x nj * Moreover, in scilab, if nj <= 2, we get in fact a matrix. */ final_dimsize = nb_index_vectors; while (final_dimsize > 1 && get_length(dec + final_dimsize) == 1) { final_dimsize--; } if ( final_dimsize > 2 ) /* we create an hypermatrix for the extraction result */ { He.dimsize = final_dimsize; He.size = ntot; He.it = H.it; He.type = H.type; CreateHMat(dec + Rhs, &He); for ( k = 0 ; k < final_dimsize ; k++ ) { He.dims[k] = get_length(dec + k + 1); } } else /* we create a matrix for the extraction result */ { m = get_length(dec + 1); if (final_dimsize > 1) { n = get_length(dec + 2); } else { n = 1; } switch (H.type) { case (sci_matrix): CreateCVar(dec + Rhs, MATRIX_OF_DOUBLE_DATATYPE, &(H.it), &m, &n, &lr, &lc); He.R = stk(lr); if ( H.it == 1 ) { He.I = stk(lc); } break; case (sci_boolean): CreateVar(dec + Rhs, MATRIX_OF_BOOLEAN_DATATYPE, &m, &n, &lr); He.P = (void *) istk(lr); break; case (sci_ints): lr = H.it; CreateVar(dec + Rhs, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &m, &n, &lr); He.P = (void *) istk(lr); break; } } /* indices computing */ ltot = 4; CreateVar(dec + Rhs + 1, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &ntot, &one, <ot); j = istk(ltot); compute_indices(dec, nb_index_vectors, H.dims, j); /* fill the resulting hypermatrix or matrix */ switch ( H.type ) { case (sci_matrix) : for ( k = 0 ; k < ntot ; k++ ) { He.R[k] = H.R[j[k]]; } if (H.it == 1) for ( k = 0 ; k < ntot ; k++ ) { He.I[k] = H.I[j[k]]; } break; case (sci_boolean) : /* (sci_boolean stored with 4 bytes) */ Pe = (int *) He.P ; P = (int *) H.P; for ( k = 0 ; k < ntot ; k++ ) { Pe[k] = P[j[k]]; } break; case (sci_ints) : if ( H.it == I_INT32 || H.it == I_UINT32 ) { Pe = (int *) He.P; P = (int *) H.P; for ( k = 0 ; k < ntot ; k++ ) { Pe[k] = P[j[k]]; } } else if ( H.it == I_INT16 || H.it == I_UINT16 ) { siPe = (short int *) He.P; siP = (short int *) H.P; for ( k = 0 ; k < ntot ; k++ ) { siPe[k] = siP[j[k]]; } } else /* SCI_INT8 and SCI_UINT8 : 1 Byte int */ { cPe = (char *) He.P; cP = (char *) H.P; for ( k = 0 ; k < ntot ; k++ ) { cPe[k] = cP[j[k]]; } } break; } LhsVar(1) = dec + Rhs; PutLhsVar(); return 0; }