C/C++. Counting bits

Ниже приведены способы подсчета битов в беззнаковом целом числе. Все эти способы помещены в пространстве имен utils. По быстроте данные способы располагаются в следующем порядке (по возрастанию):

utils::count_bits < utils::count_bits2 < utils::count_bits3 <= utils::count_bits4

В следующей ссылке предлагается более подробное описание данной темы - "Обстоятельно о подсчете единичных битов".
Всем удачи!   

#include <iostream>
#include <bitset>

/* support bits count */
class Bits_Counter {
    static unsigned char byte_bit_count[256]; /* lookup table */
public:
    // must be called before the first call
    // to the count method
    void initialize() {
        int cnt, n;

        for (int i = 0; i < 256; i++) {
            cnt = 0;
            n = i;

            while (n != 0) {
                n = n & (n - 1);
                cnt++;
            }

            byte_bit_count[i] = cnt;
        }
    }

    int count(unsigned int n) {
        const unsigned char * byte = (unsigned char *) &n;

        return byte_bit_count[byte[0]] + byte_bit_count[byte[1]] +
               byte_bit_count[byte[2]] + byte_bit_count[byte[3]];
    }
};

unsigned char Bits_Counter::byte_bit_count[256];

/* utilities for count bits in given number */
namespace utils {
    using namespace std;

    // show bits
    void show_bits(unsigned int n) {
        string binary;

        while (n != 0) {
            binary = bitset<8>(n).to_string();
            cout << binary << endl;
            n = n >> 1;
        }
    }

    // count bits
    int count_bits(unsigned int n) {
        int cnt = 0;

        while (n != 0) {
            if (n & 1) cnt++;
            n = n >> 1;
        }

        return cnt;
    }

    // count bits
    int count_bits2(unsigned int n) {
        int cnt = 0;

        while (n != 0) {
            n = n & (n - 1);
            cnt++;
        }

        return cnt;
    }

    // count bits
    int count_bits3(unsigned int n) {
        Bits_Counter bits_counter;
        bits_counter.initialize();
        return bits_counter.count(n);
    }

    // count bits
    int count_bits4(unsigned int n) {
        static unsigned int mask[] = { 0x55555555,
                                                           0x33333333,
                                                           0x0F0F0F0F,
                                                           0x00FF00FF,
                                                           0x0000FFFF };

        for (int i = 0, shift = 1; i < 5; i++, shift *= 2) {
            n = (n & mask[i]) + ((n >> shift) & mask[i]);
        }

        return n;
    }
};

int main()
{
    unsigned int n = 55689; // 1010111000001

    std::cout << utils::count_bits(n)  << std::endl  // 8
              << utils::count_bits2(n) << std::endl       // 8
              << utils::count_bits3(n) << std::endl       // 8
              << utils::count_bits4(n);                           // 8

    return 0;
}

Oracle. Compile all of the invalid objects in your schema

For compile all of the invalid objects owned by YOUR_SCHEMA (note: must use upper case on the schema name):

begin
  dbms_utility.compile_schema('YOUR_SCHEMA');
end;

If some objects are still invalid that means there is some error with them.

Oracle. ANSI join syntax limitation in materialized views.

Начиная с версии 9 в Oracle для объединений таблиц стал доступен ANSI sql-синтаксиc (стандарт SQL:1999):

INNER JOIN
NATURAL JOIN
CROSS JOIN
LEFT OUTER JOIN
RIGHT OUTER JOIN
FULL OUTER JOIN

Данный синтаксис для современного разработчика более естественен, по сравнению с "old-style". Так же данный синтаксис расширяет возможности объединения таблиц (например, возможность полного объединения с использованием FULL OUTER JOIN). Но тем не менее получается, что полностью от старого синтаксиса невозможно отказаться, если Вам необходимо использовать в своих решениях материализованные представления (MATERIALIZED VIEWS) в режиме ON COMMIT. Связано это с тем, что при создании представления невозможно использовать объединения "ANSI-style".

Напоследок напомню про один нюанс использования объединений старого стиля: использовать метку (+) необходимо непосредственно с полем объединения, например:

select t1.*, t2.*
from table1 t1, table2 t2
/* where regexp_substr(t1.field, '\d+') = regexp_substr(t2.field, '\d+') (+) */
where regexp_substr(t1.field, '\d+') = regexp_substr(t2.field (+), '\d+')

В примере ошибочный вариант использования (+) закомментирован.
Или такой пример:

select t1.*, t2.*
from table1 t1, table2 t2 
where t1.id = t2.id (+)
    and regexp_like(t2.field (+), '^[A-Za-z]+')

Всем удачи :)