Lucene 源码分析集------- BitUtil

最新推荐文章于 2021-02-24 22:44:36 发布
最新推荐文章于 2021-02-24 22:44:36 发布
阅读量172 收藏
点赞数
分类专栏： Lucene源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenxiongdi/article/details/90545354
版权 
const uint8_t BitUtil::ntzTable[] = {
    8, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
};

BitUtil::~BitUtil() {
}

// 对于64位的int，返回其bit为1的个数

int32_t BitUtil::pop(int64_t x) {
    x = x - (MiscUtils::unsignedShift(x, (int64_t)1) & 0x5555555555555555LL);
    x = (x & 0x3333333333333333LL) + (MiscUtils::unsignedShift(x, (int64_t)2) & 0x3333333333333333LL);
    x = (x + MiscUtils::unsignedShift(x, (int64_t)4)) & 0x0f0f0f0f0f0f0f0fLL;
    x = x + MiscUtils::unsignedShift(x, (int64_t)8);
    x = x + MiscUtils::unsignedShift(x, (int64_t)16);
    x = x + MiscUtils::unsignedShift(x, (int64_t)32);
    return (int32_t)x & 0x7f;
}

//对于64int的数组，从第wordOffset个开始，一直计算numWords个，计算其中bit为1的个数

int64_t BitUtil::pop_array(const int64_t* A, int32_t wordOffset, int32_t numWords) {
    int32_t n = wordOffset + numWords;
    int64_t tot = 0;
    int64_t tot8 = 0;
    int64_t ones = 0;
    int64_t twos = 0;
    int64_t fours = 0;

    int32_t i = wordOffset;
    for (; i <= n - 8; i += 8) {
        int64_t twosA;
        CSA(twosA, ones, ones, A[i], A[i + 1]);

        int64_t twosB;
        CSA(twosB, ones, ones, A[i + 2], A[i + 3]);

        int64_t foursA;
        CSA(foursA, twos, twos, twosA, twosB);

        CSA(twosA, ones, ones, A[i + 4], A[i + 5]);

        CSA(twosB, ones, ones, A[i + 6], A[i + 7]);

        int64_t foursB;
        CSA(foursB, twos, twos, twosA, twosB);

        int64_t eights;
        CSA(eights, fours, fours, foursA, foursB);

        tot8 += pop(eights);
    }

    // Handle trailing words in a binary-search manner.
    // Derived from the loop above by setting specific elements to 0.

    if (i <= n - 4) {
        int64_t twosA;
        CSA(twosA, ones, ones, A[i], A[i + 1]);

        int64_t twosB;
        CSA(twosB, ones, ones, A[i + 2], A[i + 3]);

        int64_t foursA;
        CSA(foursA, twos, twos, twosA, twosB);

        int64_t eights = fours & foursA;
        fours = fours ^ foursA;

        tot8 += pop(eights);
        i += 4;
    }

    if (i <= n - 2) {
        int64_t twosA;
        CSA(twosA, ones, ones, A[i], A[i + 1]);

        int64_t foursA = twos & twosA;
        twos = twos ^ twosA;

        int64_t eights = fours & foursA;
        fours = fours ^ foursA;

        tot8 += pop(eights);
        i += 2;
    }

    if (i < n) {
        tot += pop(A[i]);
    }

    tot += (pop(fours) << 2) + (pop(twos) << 1) + pop(ones) + (tot8 << 3);

    return tot;
}

int64_t BitUtil::pop_intersect(const int64_t* A, const int64_t* B, int32_t wordOffset, int32_t numWords) {
    int32_t n = wordOffset + numWords;
    int64_t tot = 0;
    int64_t tot8 = 0;
    int64_t ones = 0;
    int64_t twos = 0;
    int64_t fours = 0;

    int32_t i = wordOffset;
    for (; i <= n - 8; i += 8) {
        int64_t twosA;
        CSA(twosA, ones, ones, (A[i] & B[i]), (A[i + 1] & B[i + 1]));

        int64_t twosB;
        CSA(twosB, ones, ones, (A[i + 2] & B[i + 2]), (A[i + 3] & B[i + 3]));

        int64_t foursA;
        CSA(foursA, twos, twos, twosA, twosB);

        CSA(twosA, ones, ones, (A[i + 4] & B[i + 4]), (A[i + 5] & B[i + 5]));

        CSA(twosB, ones, ones, (A[i + 6] & B[i + 6]), (A[i + 7] & B[i + 7]));

        int64_t foursB;
        CSA(foursB, twos, twos, twosA, twosB);

        int64_t eights;
        CSA(eights, fours, fours, foursA, foursB);

        tot8 += pop(eights);
    }

    if (i <= n - 4) {
        int64_t twosA;
        CSA(twosA, ones, ones, (A[i] & B[i]), (A[i + 1] & B[i + 1]));

        int64_t twosB;
        CSA(twosB, ones, ones, (A[i + 2] & B[i + 2]), (A[i + 3] & B[i + 3]));

        int64_t foursA;
        CSA(foursA, twos, twos, twosA, twosB);

        int64_t eights = fours & foursA;
        fours = fours ^ foursA;

        tot8 += pop(eights);
        i += 4;
    }

    if (i <= n - 2) {
        int64_t twosA;
        CSA(twosA, ones, ones, (A[i] & B[i]), (A[i + 1] & B[i + 1]));

        int64_t foursA = twos & twosA;
        twos = twos ^ twosA;

        int64_t eights = fours & foursA;
        fours = fours ^ foursA;

        tot8 += pop(eights);
        i += 2;
    }

    if (i < n) {
        tot += pop((A[i] & B[i]));
    }

    tot += (pop(fours) << 2) + (pop(twos) << 1) + pop(ones) + (tot8 << 3);

    return tot;
}

int64_t BitUtil::pop_union(const int64_t* A, const int64_t* B, int32_t wordOffset, int32_t numWords) {
    int32_t n = wordOffset + numWords;
    int64_t tot = 0;
    int64_t tot8 = 0;
    int64_t ones = 0;
    int64_t twos = 0;
    int64_t fours = 0;

    int32_t i = wordOffset;
    for (; i <= n - 8; i += 8) {
        int64_t twosA;
        CSA(twosA, ones, ones, (A[i] | B[i]), (A[i + 1] | B[i + 1]));

        int64_t twosB;
        CSA(twosB, ones, ones, (A[i + 2] | B[i + 2]), (A[i + 3] | B[i + 3]));

        int64_t foursA;
        CSA(foursA, twos, twos, twosA, twosB);

        CSA(twosA, ones, ones, (A[i + 4] | B[i + 4]), (A[i + 5] | B[i + 5]));

        CSA(twosB, ones, ones, (A[i + 6] | B[i + 6]), (A[i + 7] | B[i + 7]));

        int64_t foursB;
        CSA(foursB, twos, twos, twosA, twosB);

        int64_t eights;
        CSA(eights, fours, fours, foursA, foursB);

        tot8 += pop(eights);
    }

    if (i <= n - 4) {
        int64_t twosA;
        CSA(twosA, ones, ones, (A[i] | B[i]), (A[i + 1] | B[i + 1]));

        int64_t twosB;
        CSA(twosB, ones, ones, (A[i + 2] | B[i + 2]), (A[i + 3] | B[i + 3]));

        int64_t foursA;
        CSA(foursA, twos, twos, twosA, twosB);

        int64_t eights = fours & foursA;
        fours = fours ^ foursA;

        tot8 += pop(eights);
        i += 4;
    }

    if (i <= n - 2) {
        int64_t twosA;
        CSA(twosA, ones, ones, (A[i] | B[i]), (A[i + 1] | B[i + 1]));

        int64_t foursA = twos & twosA;
        twos = twos ^ twosA;

        int64_t eights = fours & foursA;
        fours = fours ^ foursA;

        tot8 += pop(eights);
        i += 2;
    }

    if (i < n) {
        tot += pop((A[i] | B[i]));
    }

    tot += (pop(fours) << 2) + (pop(twos) << 1) + pop(ones) + (tot8 << 3);

    return tot;
}

int64_t BitUtil::pop_andnot(const int64_t* A, const int64_t* B, int32_t wordOffset, int32_t numWords) {
    int32_t n = wordOffset + numWords;
    int64_t tot = 0;
    int64_t tot8 = 0;
    int64_t ones = 0;
    int64_t twos = 0;
    int64_t fours = 0;

    int32_t i = wordOffset;
    for (; i <= n - 8; i += 8) {
        int64_t twosA;
        CSA(twosA, ones, ones, (A[i] & ~B[i]), (A[i + 1] & ~B[i + 1]));

        int64_t twosB;
        CSA(twosB, ones, ones, (A[i + 2] & ~B[i + 2]), (A[i + 3] & ~B[i + 3]));

        int64_t foursA;
        CSA(foursA, twos, twos, twosA, twosB);

        CSA(twosA, ones, ones, (A[i + 4] & ~B[i + 4]), (A[i + 5] & ~B[i + 5]));

        CSA(twosB, ones, ones, (A[i + 6] & ~B[i + 6]), (A[i + 7] & ~B[i + 7]));

        int64_t foursB;
        CSA(foursB, twos, twos, twosA, twosB);

        int64_t eights;
        CSA(eights, fours, fours, foursA, foursB);

        tot8 += pop(eights);
    }

    if (i <= n - 4) {
        int64_t twosA;
        CSA(twosA, ones, ones, (A[i] & ~B[i]), (A[i + 1] & ~B[i + 1]));

        int64_t twosB;
        CSA(twosB, ones, ones, (A[i + 2] & ~B[i + 2]), (A[i + 3] & ~B[i + 3]));

        int64_t foursA;
        CSA(foursA, twos, twos, twosA, twosB);

        int64_t eights = fours & foursA;
        fours = fours ^ foursA;

        tot8 += pop(eights);
        i += 4;
    }

    if (i <= n - 2) {
        int64_t twosA;
        CSA(twosA, ones, ones, (A[i] & ~B[i]), (A[i + 1] & ~B[i + 1]));

        int64_t foursA = twos & twosA;
        twos = twos ^ twosA;

        int64_t eights = fours & foursA;
        fours = fours ^ foursA;

        tot8 += pop(eights);
        i += 2;
    }

    if (i < n) {
        tot += pop((A[i] & ~B[i]));
    }

    tot += (pop(fours) << 2) + (pop(twos) << 1) + pop(ones) + (tot8 << 3);

    return tot;
}

int64_t BitUtil::pop_xor(const int64_t* A, const int64_t* B, int32_t wordOffset, int32_t numWords) {
    int32_t n = wordOffset + numWords;
    int64_t tot = 0;
    int64_t tot8 = 0;
    int64_t ones = 0;
    int64_t twos = 0;
    int64_t fours = 0;

    int32_t i = wordOffset;
    for (; i <= n - 8; i += 8) {
        int64_t twosA;
        CSA(twosA, ones, ones, (A[i] ^ B[i]), (A[i + 1] ^ B[i + 1]));

        int64_t twosB;
        CSA(twosB, ones, ones, (A[i + 2] ^ B[i + 2]), (A[i + 3] ^ B[i + 3]));

        int64_t foursA;
        CSA(foursA, twos, twos, twosA, twosB);

        CSA(twosA, ones, ones, (A[i + 4] ^ B[i + 4]), (A[i + 5] ^ B[i + 5]));

        CSA(twosB, ones, ones, (A[i + 6] ^ B[i + 6]), (A[i + 7] ^ B[i + 7]));

        int64_t foursB;
        CSA(foursB, twos, twos, twosA, twosB);

        int64_t eights;
        CSA(eights, fours, fours, foursA, foursB);

        tot8 += pop(eights);
    }

    if (i <= n - 4) {
        int64_t twosA;
        CSA(twosA, ones, ones, (A[i] ^ B[i]), (A[i + 1] ^ B[i + 1]));

        int64_t twosB;
        CSA(twosB, ones, ones, (A[i + 2] ^ B[i + 2]), (A[i + 3] ^ B[i + 3]));

        int64_t foursA;
        CSA(foursA, twos, twos, twosA, twosB);

        int64_t eights = fours & foursA;
        fours = fours ^ foursA;

        tot8 += pop(eights);
        i += 4;
    }

    if (i <= n - 2) {
        int64_t twosA;
        CSA(twosA, ones, ones, (A[i] ^ B[i]), (A[i + 1] ^ B[i + 1]));

        int64_t foursA = twos & twosA;
        twos = twos ^ twosA;

        int64_t eights = fours & foursA;
        fours = fours ^ foursA;

        tot8 += pop(eights);
        i += 2;
    }

    if (i < n) {
        tot += pop((A[i] ^ B[i]));
    }

    tot += (pop(fours) << 2) + (pop(twos) << 1) + pop(ones) + (tot8 << 3);

    return tot;
}

void BitUtil::CSA(int64_t& h, int64_t& l, int64_t a, int64_t b, int64_t c) {
    int64_t u = a ^ b;
    h = (a & b) | (u & c);
    l = u ^ c;
}

//对于64位int，计算其二进制的尾部有几个0

int32_t BitUtil::ntz(int64_t val) {
    // A full binary search to determine the low byte was slower than a linear search for nextSetBit().
    // This is most likely because the implementation of nextSetBit() shifts bits to the right, increasing
    // the probability that the first non-zero byte is in the rhs.

    // This implementation does a single binary search at the top level only so that all other bit shifting
    // can be done on ints instead of longs to remain friendly to 32 bit architectures.  In addition, the
    // case of a non-zero first byte is checked for first because it is the most common in dense bit arrays.

    int32_t lower = (int32_t)val;
    int32_t lowByte = lower & 0xff;
    if (lowByte != 0) {
        return ntzTable[lowByte];
    }

    if (lower != 0) {
        lowByte = MiscUtils::unsignedShift(lower, 8) & 0xff;
        if (lowByte != 0) {
            return ntzTable[lowByte] + 8;
        }
        lowByte = MiscUtils::unsignedShift(lower, 16) & 0xff;
        if (lowByte != 0) {
            return ntzTable[lowByte] + 16;
        }
        // no need to mask off low byte for the last byte in the 32 bit word
        // no need to check for zero on the last byte either.
        return ntzTable[MiscUtils::unsignedShift(lower, 24)] + 24;
    } else {
        // grab upper 32 bits
        int32_t upper = (int32_t)(val >> 32);
        lowByte = upper & 0xff;
        if (lowByte != 0) {
            return ntzTable[lowByte] + 32;
        }
        lowByte = MiscUtils::unsignedShift(upper, 8) & 0xff;
        if (lowByte != 0) {
            return ntzTable[lowByte] + 40;
        }
        lowByte = MiscUtils::unsignedShift(upper, 16) & 0xff;
        if (lowByte != 0) {
            return ntzTable[lowByte] + 48;
        }
        // no need to mask off low byte for the last byte in the 32 bit word
        // no need to check for zero on the last byte either.
        return ntzTable[MiscUtils::unsignedShift(upper, 24)] + 56;
    }
}

int32_t BitUtil::ntz(int32_t val) {
    // This implementation does a single binary search at the top level only.  In addition, the case
    // of a non-zero first byte is checked for first because it is the most common in dense bit arrays.

    int32_t lowByte = val & 0xff;
    if (lowByte != 0) {
        return ntzTable[lowByte];
    }
    lowByte = MiscUtils::unsignedShift(val, 8) & 0xff;
    if (lowByte != 0) {
        return ntzTable[lowByte] + 8;
    }
    lowByte = MiscUtils::unsignedShift(val, 16) & 0xff;
    if (lowByte != 0) {
        return ntzTable[lowByte] + 16;
    }
    // no need to mask off low byte for the last byte.
    // no need to check for zero on the last byte either.
    return ntzTable[MiscUtils::unsignedShift(val, 24)] + 24;
}

int32_t BitUtil::ntz2(int64_t x) {
    int32_t n = 0;
    int32_t y = (int32_t)x;
    if (y == 0) { // the only 64 bit shift necessary
        n += 32;
        y = (int32_t)MiscUtils::unsignedShift(x, (int64_t)32);
    }
    if ((y & 0x0000ffff) == 0) {
        n += 16;
        y = MiscUtils::unsignedShift(y, 16);
    }
    if ((y & 0x000000ff) == 0) {
        n += 8;
        y = MiscUtils::unsignedShift(y, 8);
    }
    return (ntzTable[y & 0xff]) + n;
}

int32_t BitUtil::ntz3(int64_t x) {
    int32_t n = 1;

    // do the first step as a long, all others as ints.
    int32_t y = (int32_t)x;
    if (y == 0) {
        n += 32;
        y = (int32_t)MiscUtils::unsignedShift(x, (int64_t)32);
    }
    if ((y & 0x0000ffff) == 0) {
        n += 16;
        y = MiscUtils::unsignedShift(y, 16);
    }
    if ((y & 0x000000ff) == 0) {
        n += 8;
        y = MiscUtils::unsignedShift(y, 8);
    }
    if ((y & 0x0000000f) == 0) {
        n += 4;
        y = MiscUtils::unsignedShift(y, 4);
    }
    if ((y & 0x00000003) == 0) {
        n += 2;
        y = MiscUtils::unsignedShift(y, 2);
    }
    return n - (y & 1);
}

// 是否2的幂次方

bool BitUtil::isPowerOfTwo(int32_t v) {
    return ((v & (v - 1)) == 0);
}

bool BitUtil::isPowerOfTwo(int64_t v) {
    return ((v & (v - 1)) == 0);
}

//对于32位int，计算大于等于当前值的最近的一个2的幂次方

int32_t BitUtil::nextHighestPowerOfTwo(int32_t v) {
    --v;
    v |= v >> 1;
    v |= v >> 2;
    v |= v >> 4;
    v |= v >> 8;
    v |= v >> 16;
    return ++v;
}

int64_t BitUtil::nextHighestPowerOfTwo(int64_t v) {
    --v;
    v |= v >> 1;
    v |= v >> 2;
    v |= v >> 4;
    v |= v >> 8;
    v |= v >> 16;
    v |= v >> 32;
    return ++v;
}

 

chenxiongdi
关注
专栏目录
以太坊源码分析(20)core-bloombits源码分析
尹成的技术博客
05-14 1394
# scheduler.goscheduler是基于section的布隆过滤器的单个bit值检索的调度。 除了调度检索操作之外，这个结构还可以对请求进行重复数据删除并缓存结果，从而即使在复杂的过滤情况下也可以将网络/数据库开销降至最低。### 数据结构request表示一个bloom检索任务，以便优先从本地数据库中或从网络中剪检索。 section 表示区块段号，每段4096个区块， bit代表检...
研究Lucene的源码
hsy的博客
08-04 330
研究Lucene的源码 Lucene是apache软件基金会4 jakarta项目组的一个子项目，是一个开放源代码的全文检索引擎工具包，是简单而功能强大的基于Java的搜索库。它可以用于任何应用程序来搜索功能。它是可扩展的，高性能的库用于索引和搜索几乎任何类型的文本。虽然，可能现在Lucene用得不多研究，但是挺多的引擎是基于Lucene实现的，所以研究其源码的设计模式还是有必要的。 前期的准备工...
bitutils:用于按位操作的简单实用函数
06-27
位实用程序 用于按位操作的简单实用函数 安装 作为子模块 git submodule add https://github.com/matthewpalmer/bitutils.git 您可以手动复制bitutils.c和bitutils.h文件。 用法 有关更多文档，请参阅 。 int kth_bit_from_right ( int n, int k); int set_kth_bit_from_right ( int n, int k); int unset_kth_bit_from_right ( int n, int k); int bits_in_range ( int n, int k1, int k2); // 0th bit is the rightmost bit int append_bit ( int n, int bit); void print_bits
BitmapUtils构造函数和一些常用方法整理
xupingwei
04-24 1377
1.BitmapUtils构造方法   BitmapUtils(Context context)   BitmapUtils(Context context, String diskCachePath)  //创建缓存路径   BitmapUtils(Context context, String diskCachePath, int memoryCacheSize)    //缓存路径，内
java 获取默认工具包_GitHub - 1711680493/ShendiKit: Java工具包
weixin_35736086的博客
02-24 211
简介Shendi Kitauthor:Shendiversion: 1.1QQ:1711680493引导页面Java工具包,纯Java制作,使用JDK8以前版本可在分支中找到测试样例样例在源码的 shendi.kit.test 包下.目录统一在 shendi.kit.util 包下流处理工具类自定义类加载器HTTP工具类 *已移动至 shendi.kit.net.http, 具体请参考文档HTTP...
#Lucene# org.apache.lucene.util.BitUtil.pop(long x) 笔记
Mr.野狐
05-14 127
今天读 Lucene 源码，有这样一个函数： /** Returns the number of bits set in the long */ public static int pop(long x) { /* * Hacker's Delight 32 bit pop function: * http://www.hackersdelight.org/HDcode...
Lucene 源码剖析 六
solotraveler
07-08 6693
<br />4           索引是如何创建的<br />为了使用Lucene来索引数据，首先你比把它转换成一个纯文本（plain-text）tokens的数据流（stream），并通过它创建出Document对象，其包含的Fields成员容纳这些文本数据。一旦你准备好些Document对象，你就可以调用IndexWriter类的addDocument(Document)方法来传递这些对象到Lucene并写入索引中。当你做这些的时候，Lucene首先分析（analyzer）这些数据来使得它们更适合索引
je-analysis-1.5.3、lucene-core-2.4.1分词组件
12-31
本文将深入探讨"je-analysis-1.5.3"和"lucene-core-2.4.1"这两个分词组件，以及它们在相关场景中的应用。 首先，让我们了解什么是分词。分词，即词语切分，是自然语言处理（NLP）中的基本任务之一，它的目标是将...
lucene-sequence-diagram:lucene搜索端uml时序图，lucene源码解析
05-14
lucene-sequence-diagram lucene搜索端uml时序图，lucene源码解析 图比较大，看不清，可以下载【sd-search.svg】后再用浏览器打开 使用starUML画图，可以下载【lucene.mdj】后打开，编辑 前提 只考虑最简单的查询，...
lucene-analyzers-smartcn-7.7.0-API文档-中文版.zip
07-13
赠送jar包：lucene-analyzers-smartcn-7.7.0.jar； 赠送原API文档：lucene-analyzers-smartcn-7.7.0-javadoc.jar； 赠送源代码：lucene-analyzers-smartcn-7.7.0-sources.jar； 赠送Maven依赖信息文件：lucene-...
lucene-core-7.7.0-API文档-中文版.zip
07-13
赠送jar包：lucene-core-7.7.0.jar； 赠送原API文档：lucene-core-7.7.0-javadoc.jar； 赠送源代码：lucene-core-7.7.0-sources.jar； 赠送Maven依赖信息文件：lucene-core-7.7.0.pom； 包含翻译后的API文档：lucene...
Lucene.net-4.8.0 -new Bate.rar
05-29
《深入理解Lucene.Net 4.8：源码解析与实战指南》 Lucene.Net，作为.NET平台下的全文搜索引擎库，是开发高效、可扩展的搜索功能的强大工具。4.8.0版本作为其重要的更新迭代，引入了诸多新特性与优化，为开发者提供...
基于java的人事管理系统设计与实现.docx
09-13
基于java的人事管理系统设计与实现.docx
Spring Boot微博后端系统（spring-boot-tucao-weibo）.zip
最新发布
09-13
这是一个基于Spring Boot框架开发的微博后端系统，实现前后端分离，使得后台可以独立开发和调试。该系统采用Vue实现前端界面，并提供了丰富的功能，如发布微博、评论、点赞等。技术栈包括Spring Boot、Spring Data JPA和Stomp（WebSocket）。项目提供开发环境和生产环境的运行方式，支持H2内存数据库和mySQL数据库。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看reADME.md文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。
基于java的房产销售系统设计与实现.docx
09-13
基于java的房产销售系统设计与实现.docx
51单片机PID算法控制无刷直流电机proteus仿真 功能描述 1.五个按键，停止 启动，正转，反转，加速，减速 2.显示lc
09-13
51单片机PID算法控制无刷直流电机proteus仿真 功能描述 1.五个按键，停止 启动，正转，反转，加速，减速 2.显示lcd1602,第一行设置速度set= 3.第二行实际速度speed= r min 4.第一行右上角转正显示Z，反转显示F 5.驱动用ir2101加上6个mos管， 6.程序里有pid算法
基于java的疫苗发布和接种预约系统设计与实现.docx
09-13
基于java的疫苗发布和接种预约系统设计与实现.docx
基于python+DQN深度强化学习解决三维在线装箱问题+源码+项目文档+逻辑解析（毕业设计&课程设计&项目开发）
09-13
基于python+DQN深度强化学习解决三维在线装箱问题+源码+项目文档+逻辑解析，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用，详情见md文档~ 问题描述： 物流公司在流通过程中，需要将打包完毕的箱子装入到一个货车的车厢中，为了提高物流效率，需要将车厢尽量填满，显然，车厢如果能被100%填满是最优的，但通常认为，车厢能够填满85%，可认为装箱是比较优化的。 设车厢为长方形，其长宽高分别为L，W，H；共有n个箱子，箱子也为长方形，第i个箱子的长宽高为li，wi，hi（n个箱子的体积总和是要远远大于车厢的体积），做以下假设和要求： 长方形的车厢共有8个角，并设靠近驾驶室并位于下端的一个角的坐标为（0,0,0），车厢共6个面，其中长的4个面，以及靠近驾驶室的面是封闭的，只有一个面是开着的，用于工人搬运箱子； 需要计算出每个箱子在车厢中的坐标，即每个箱子摆放后，其和车厢坐标为（0,0,0）的角相对应的角在车厢中的坐标，并计算车厢的填充率。
基于微信小程序的医院预约挂号系统小程序设计与实现.docx
09-13
基于微信小程序的医院预约挂号系统小程序设计与实现.docx
Lucene源码解析--Term Dictionary和Term Index
05-18
Lucene是一个全文检索引擎，它的核心数据结构包括倒排索引和正排索引。其中，倒排索引是Lucene最重要的数据结构之一，它通过将文档中的每个词都映射到包含该词的文档列表来实现快速的文本搜索。 Lucene中的Term ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值