Я люблю математику, но не в лошадиных дозах.

#ifdef MXX_RU_INPLACE_CODEGEN

    require 'mxx_ru/cpp/inplace_codegen'

    class Config < CppValueIncapsulator
        cpp_name "cfg_t"
        hpp { :where => :here }
        cpp { :where => :file, :file_name => "../cfg.impl.cpp" }
        attr_prefix "m_"
        setter_prefix "set_"

        attr :listening_mbox, "std::string"

        attr :interception_priority, "int", :default => 2

        attr :low_watermark, "unsigned int"

        attr :high_watermark, "unsigned int"

        attr :cprov_high_watermark, "unsigned int"

        attr :max_life_time, "unsigned int", :default => 60

        attr :check_life_time_period, "unsigned int", :default => 5
    end

#endif

#ifdef MXX_RU_INPLACE_CODEGEN
<...>
#else
//inplace_codegen:md5:....
class cfg_t
    {
        std::string    m_listening_mbox;
        int    m_interception_priority;
        unsigned int m_low_watermark;
        unsigned int m_high_watermark;
        unsigned int m_cprov_high_watermark;
        unsigned int m_max_life_time;
        unsigned int m_check_life_time_period;
        
    public :
        cfg_t();
        
        void set_listening_mbox( const std::string & v );
        const std::string & listening_mbox() const;
        ...
        void set_check_life_time_period( unsigned int v );
        unsigned int check_life_time_period() const;
    };
#endif

cfg_t::cfg_t()
    : m_interception_priority( 2 )
    , m_low_watermark( 0 )
    , m_high_watermark( 0 )
    , m_cprov_high_watermark( 0 )
    , m_max_life_time( 60 )
    , m_check_life_time_period( 5 )
    {}
    
void cfg_t::set_listening_mbox( const std::string & v ) { m_listening_mbox = v; }
const std::string & listening_mbox() const { return m_listening_mbox; }
...
void set_check_life_time_period( unsigned int v ) { m_check_life_time_period = v; }
unsigned int check_life_time_period() const { return m_check_life_time_period; }

1.upto( 10000 ) {
    |x|
    prime = true
    2.upto( x - 1 ) {
        |y|
        if 0 == ( x % y )
            prime = false
            break
        end
    }

    puts "#{x}" if prime
}

float f = Sine<32,5>::sin();

float r = d * Sine< 32, 5 >::sin() + c * Cos< 16, 5 >::cos() + 1 / Sine< 3, 5 >::sin();

const float sin_32 = Sine< 32, 5 >::sin();
const float cos_16 = Cos< 16, 5 >::cos();
const float sin_3 = Sine< 3, 5 >::sin();

r = d * sine_32 + c * cos_16 + 1 / sin_3;

const float sin_32 = 0.8314696123f;
const float cos_16 = ...;
const float sin_3  = ...;

r = d * sine_32 + c * cos_16 + 1 / sin_3;

#include "consts.h"

r = d * sine_32 + c * cos_16 + 1 / sin_3;

# consts.rb
puts <<EOF
const float sin_32 = #{Math::sin(10*Math::PI/32)}f;
...
EOF

# Makefile
...
consts.h: consts.rb
    ruby consts.rb > consts.h
...

template<unsigned int A,unsigned int B,unsigned int C>
class random{
  unsigned int state;
public:
  unsigned int operator()(){
    return state=(A*state+B)%C;
  }
};

//Расширенный алгоритм Евклида для поиска наибольшего общего делителя result
//и коэффициентов X,Y таких что result = A*X+B*Y
//Глубина рекурсии ("фибоначчи" логарифм max(a,b)) и число инстанцированных типов не доставляют проблем компиляторам.
template<unsigned int a,unsigned int b>
struct euclid_ex{
  typedef euclid_ex<b,a%b> d;
  enum{result=d::result, x=d::y, div=a/b, y=d::x-div*d::y };
};
template<unsigned int a>
struct euclid_ex<a,0u>{enum{result=a,x=1u,y=0u};};

#define STATIC_ASSERT(C0ND1T10N) typedef int blablabla[(C0ND1T10N)?1:-1]

template<unsigned int A,unsigned int B,unsigned int C>
class random{
  unsigned int state;
  STATIC_ASSERT(euclid_ex<A,B>::result==1);
  STATIC_ASSERT(euclid_ex<A,C>::result==1);
  STATIC_ASSERT(euclid_ex<B,C>::result==1);
public:
  unsigned int operator()(){
    return state=(A*state+B)%C;
  }
};

// Проверка числа на простоту методом близким к решету Эратосфена.
// Практически не может превысить лимиты компилятора на число инстанцированных типов.
// для простых N инстанцируется около sqrt(N)/6 типов для составных гораздо меньше.
// для чётных N только два, для нечётных N кратных трём три.
// Мне в MSVC 7.1 удалось проинстанцировать все is_prime от нуля до 1900 одновременно
// и не удалось найти N превышающих лимиты компилятора.
template<unsigned int N>
class is_prime{
  template<unsigned int K>
  struct ask{
    enum{
      tmp=(N<K*K),//Временных переменных никто не отменял :-)
      answer=tmp|ask<(K+6u)*(!tmp&&(N%K)&&(N%(K+2u))&&(N%(K+4u)))>::answer
    };
  };
  template<>struct ask<0u>{enum{answer=0u};};//Признак окончания разбора.
public:
  enum{result=ask<3u*(N&1u)>::answer};
};
template<>class is_prime<1u>{public:enum{result=0u};};
template<>class is_prime<2u>{public:enum{result=1u};};


//Это только пример. Не ругайтесь.
template<class KEY,class DATA,unsigned int size,unsigned int(*hash_fun)(KEY const&)>
class hash{
  STATIC_ASSERT(is_prime<size>::result);
  std::list<std::pair<KEY,DATA> > buffer[size];
public:
  ...
  void insert(KEY const&k,DATA const&d){
    //Кто не любит делить может посмотреть ассемблерный код
    //взятия по известному компилятору модулю при полной оптимизации.
    //только не ищите команду div
    buffer[((*hash_fun)(k))%size].insert(std::make_pair(k,d));
  }
  ...
};

-- Молодой человек, извините, не подскажите, в Лондоне кроме дождя другая погода бывает?
-- Не могу вам точно сказать, мне всего 35 лет.

"Красиво излагает, сволочь! Учитесь, Киса!" (с) Ильф и Петров

namespace text_print
{
    //форвард декларация
    template <class Char>  
    struct format_t;

    namespace detail
    {
        //собственно, элемент списка. Prev - тип предыдыдущего элемента.
        template <class T, class Prev, class Char>
        struct printf_link_t
        {
            typedef Prev prev_t;
            typedef Char char_t;
            typedef T type;
            Prev *m_prev;
            const T *m_param;

            printf_link_t(Prev *in_prev, const T *in_param)
                :m_prev(in_prev)
                ,m_param(in_param)
            {
            }

            //создаём следующий элемент списка.
            template <class Next> 
            detail::printf_link_t<Next, printf_link_t, Char>
            operator %(const Next &x)
            {
                return detail::printf_link_t<Next, printf_link_t, Char>(this, &x);
            }
        };


        struct printf_param_info_t
        {
            polymorphic_print_t m_polymorphic_print; //указатель на функцию, которая распечатывает void * аргумент.
            const void *m_param;
        };

        //мяу-функция на списком. вычисляет длину и делает функцию, которая заполняет массив.
        template <class PrintfLink>
        struct make_array_from_list_t
        {
            enum { len = 1 + make_array_from_list_t<typename PrintfLink::prev_t>::len };

            static format_t<typename PrintfLink::char_t> *
                fill(printf_param_info_t printf_param_info[], PrintfLink *printf_link) 
            {
                --printf_param_info;
                printf_param_info->m_polymorphic_print = &polymorphic_print_gen<typename PrintfLink::type>;
                printf_param_info->m_param = printf_link->m_param;

                return make_array_from_list_t<typename PrintfLink::prev_t>::fill(
                    printf_param_info, printf_link->m_prev);
            }
        };
    } //detail

    namespace detail
    {
        //специализация для останова.
        template <class Char>
        struct make_array_from_list_t<format_t<Char> >
        {
            enum { len = 0 };
            static format_t<Char> *fill(printf_param_info_t *, format_t<Char> *format) 
            {
                return format;
            }
        };
    }

size_t const capacity[]={
  near_prime<fibonachchi<10>::result>::result,
  near_prime<fibonachchi<11>::result>::result,
  near_prime<fibonachchi<12>::result>::result,
  near_prime<fibonachchi<13>::result>::result,
  near_prime<fibonachchi<14>::result>::result,
…..
  near_prime<fibonachchi<44>::result>::result,
  near_prime<fibonachchi<45>::result>::result,
  near_prime<fibonachchi<46>::result>::result,
};

const my_const = my_const1 + my_const2;

// system tags

//               mass    length   time  temperature      light intensity
//                 |        |       |        |                   |
//                 |        |       |        | current strength  |  quantity of substance
//                 |        |       |        |        |          |      |
//                 v        v       v        v        v          v      v
typedef vector<int_<1>, int_<0>, int_<0>, int_<0>, int_<0>, int_<0>, int_<0> > mass_tag;
typedef vector<int_<0>, int_<1>, int_<0>, int_<0>, int_<0>, int_<0>, int_<0> > length_tag;
typedef vector<int_<0>, int_<0>, int_<1>, int_<0>, int_<0>, int_<0>, int_<0> > time_tag;
typedef vector<int_<0>, int_<0>, int_<0>, int_<1>, int_<0>, int_<0>, int_<0> > temperature_tag;
typedef vector<int_<0>, int_<0>, int_<0>, int_<0>, int_<1>, int_<0>, int_<0> > current_strength_tag;
typedef vector<int_<0>, int_<0>, int_<0>, int_<0>, int_<0>, int_<1>, int_<0> > light_intensity_tag;
typedef vector<int_<0>, int_<0>, int_<0>, int_<0>, int_<0>, int_<0>, int_<1> > quantity_of_substance_tag;

typedef vector<int_<0>, int_<2>, int_<0>, int_<0>, int_<0>, int_<0>, int_<0> > area_tag;
typedef vector<int_<0>, int_<3>, int_<0>, int_<0>, int_<0>, int_<0>, int_<0> > volume_tag;
typedef vector<int_<0>, int_<1>, int_<-1>, int_<0>, int_<0>, int_<0>, int_<0> > velocity_tag;
typedef vector<int_<0>, int_<1>, int_<-2>, int_<0>, int_<0>, int_<0>, int_<0> > acceleration_tag;

is_prime<N>::result;
near_prime<N>::result;
fibonachchi<N,A,B>::result

// is_prime<N>::result - Проверка числа на простоту
...skip...
// Ближайшее к N простое число не меньшее N.
template<unsigned int N,bool ready=is_prime<N>::result>
struct near_prime{
  enum{result=near_prime<N+1u>::result};
};
template<unsigned int N>
struct near_prime<N,true>{
  enum{result=N};
};

// fibonachchi<N,A,B>::result - Вычисление чисел Фибоначчи
// Вычисляется N-ный член ряда F(N)=F(N-1)+F(N-2) где F(0)=А F(1)=B
template<unsigned int n,unsigned int a=0u,unsigned int b=1u>
struct fibonachchi{
  enum{result=fibonachchi<n-1u,b,a+b>::result};
};
template<unsigned int a,unsigned int b>
struct fibonachchi<0u,a,b>{
  enum{result=a};
};

template<unsigned int n>
struct is_prime{
  template<unsigned int k>
  struct helper{enum{result=n%k?helper<k-1>::result:0};};
  template<>struct helper<1u>{enum{result=1};};
  enum{result=helper<n-1>::result};
};
template<>struct is_prime<2u>{enum{result=1};};

//Для сравнения. Очень не эффективный но короткий и ясный код run-time.
bool is_prime_fun(unsigned int n){
  if(n<2)
    return false;
  for(unsigned int i(n-1);i!=1;--i)
    if(n%i==0)
      return false;
  return true;
}

using namespace cttl_old;

struct MyPointMeta
{
    struct attribyte
    {
        struct PosX : integer<int, 0> {}; // int - тип переменной, 0-значение по умолчанию
        struct PosY : integer<int, 0> {};
        struct PosZ : integer<int, 0> {}; 

        typedef typelist<PosX, PosY, PosZ> alist; // увы, обязательно
    };

    // еще можно использовать функции
    // функции реализованы как функторы, принимающие два параметра 
    // - контейнер аргументов + сам объект(контейнер аттрибутов)
    struct function
    {
        // функция не несет никакого смысла, только пример
        // Пусть Show принимает три параматра ;) 
        // void - возвращаемый тип
        struct Show : signature<void, typelist<int, int, int> >
        {
            // args - входные параметры
            // object - сам объект (все по ссылкам)
            BODY(args, object)
            {
                using attribyte::PosY;
                
                std::cout << "PosX: " << object.get<attribyte::PosX>() << //можно так
                          << "PosY: " << object.get<PosY>() <<        // или так. см. using выше
                          << "PosZ: " << object.get<attribyte::PosZ>() << 
                std::endl;

                // доступ к входным параметрам
                object.get<attribyte::PosX>() = args.get<0>();
                object.get<attribyte::PosZ>() = args.get<2>();
                object.get<PosY>() = args.get<1>();
            }
        };

        // список всех функций, в принципе необязательно, необходим для некоторых возможностей
        typedef typelist<Show> fnlist; 
                    
    };
};


int main()
{
    using namespace std;
    

    typedef make_class<MyPointMeta> MyPoint;

    MyPoint pt; // будет вызван конструктор с указанными параметрами по умолчанию

    // get/set выражены одной функцией get, возвращающей ссылку
    pt.get<MyPoint::PosX>() = 100;
    pt.get<MyPoint::PosY>() = 4306;

    // x имеет тип int ;)
    MyPoint::PosX::type x = pt.get<MyPoint::PosX>();
    cout << x << endl;

    // вызов функций 

    MyPoint::function::Show::args a;
    a << 1 << 2 << 3; // Типы, естественно проверяются
    
    pt.call<MyPoint::function::Show>(a);
    
    // было еще такое ;)

    // куда трассируем (в указанном порядке)
    typedef typelist<trace::file, trace::output_window, trace::console>    my_destination;

    // трассировать все
    typedef tracer<my_destination, trace::full> my_tracer;
    
    // заодно измерим время выполнения...
    typedef typelist<my_tracer, timed> call_mode;

    call_mode cm;

    // установим дополнительные параметры
    cm.get<trace::file_name>() = "c:\\temp\\log.txt";
    
    system::ret_val res;

    // собственно вызов функции. + замер времени выполнения, + трассировка в файл, 
    // output_window и на консоль, и это _без_ модификации исходной функции
    // Это вызов одной функции, а можно одной строкой привязать call_mode ко всем функциям в классе.
    res = pt.call<MyPoint::function::Show>(a, cm); 
    
    // время выполнения
    cout << res.get<function::exec_time>() << endl; 
}

$ ./hash_test.exe 2000 < log/gate_1/20050722.log
2000: 1875

$ ./hash_test.exe 2001 < log/gate_1/20050722.log
2001: 1863

$ ./hash_test.exe 2003 < log/gate_1/20050722.log
2003: 737

$ ./hash_test.exe 2005 < log/gate_1/20050722.log
2005: 745

$ ./hash_test.exe 2007 < log/gate_1/20050722.log
2007: 724

$ ./hash_test.exe 2009 < log/gate_1/20050722.log
2009: 759

$ ./hash_test.exe 2000 < log/gate_1/20050722.log
2000: 737

$ ./hash_test.exe 2001 < log/gate_1/20050722.log
2001: 773

$ ./hash_test.exe 2003 < log/gate_1/20050722.log
2003: 746

$ ./hash_test.exe 2005 < log/gate_1/20050722.log
2005: 760

$ ./hash_test.exe 2007 < log/gate_1/20050722.log
2007: 729

$ ./hash_test.exe 2500 < log/gate_1/20050722.log
2500: 959

$ ./hash_test.exe 2501 < log/gate_1/20050722.log
2501: 957

$ ./hash_test.exe 2502 < log/gate_1/20050722.log
2502: 942

$ ./hash_test.exe 2503 < log/gate_1/20050722.log
2503: 950

$ ./hash_test.exe 2504 < log/gate_1/20050722.log
2504: 962

                      2000         2001         2002         2003         2500         2501         2502         2503         2504
ACE::hash_pjw 1875/27/1989   743/6/1990 1148/11/1991   729/9/1992 1890/18/2405  944/16/2406 1435/18/2407  951/18/2408 2191/27/2409
 Ruby ELFHASH 1875/26/1988   733/7/1989 1127/10/1990   727/7/1991 1888/20/2402  964/17/2403 1436/24/2404  922/16/2405 2191/22/2406
    Ruby PERL   737/8/1989   729/7/1990   751/7/1991   706/8/1992  947/15/2405  958/17/2406  952/16/2407  929/17/2408  930/15/2409
 Ruby default   763/7/1989   755/6/1990   754/6/1991   726/6/1992  966/15/2405  923/16/2406  941/16/2407  945/16/2408  976/15/2409
BDB HAM_FUNC2   727/8/1989   761/7/1990   754/7/1991   758/6/1992  917/16/2405  960/18/2406  958/18/2407  968/17/2408  952/19/2409
BDB HAM_FUNC3   742/8/1989   748/7/1990   751/8/1991   746/7/1992  943/15/2405  972/15/2406  937/18/2407  938/16/2408  971/16/2409
BDB HAM_FUNC4   730/6/1989   739/6/1990   726/8/1991   732/7/1992  942/15/2405  973/16/2406  966/16/2407  961/18/2408  956/16/2409
BDB HAM_FUNC5   728/8/1989   744/6/1990   742/8/1991   769/6/1992  956/16/2405  964/15/2406  946/15/2407  953/16/2408  972/16/2409

#include <memory>
#include <iostream>
#include <vector>
#include <list>
#include <set>
#include <string>
#include <iterator>
#include <algorithm>
#include <functional>

#include <cstdlib>

#include <ace/ACE.h>

typedef std::list< int > capacities_t;
typedef std::list< std::string > lines_t;

typedef unsigned long (*pfn_hash_t)(
        const char * data,
        std::size_t data_size );

struct    distribution_t
    {
        //! Количество свободных элементов в хеш таблице.
        int    m_free;
        //! Максимальное количество коллизий в одном элементе.
        u_long    m_max;
        //! Количество уникальных 32-х битовых хешей.
        int    m_uniq;

        distribution_t( int free, u_long max, int uniq )
            :    m_free( free )
            ,    m_max( max )
            ,    m_uniq( uniq )
            {}
    };

std::ostream &
operator<<( std::ostream & o, const distribution_t & d )
    {
        char sz[ 48 ];
        std::sprintf( sz, "%d/%lu/%d", d.m_free, d.m_max, d.m_uniq );
        return o << sz;
    }

capacities_t
all_capacities( char ** b, char ** e )
    {
        capacities_t r;
        std::transform( b, e,
                std::back_inserter( r ),
                std::ptr_fun( std::atoi ) );

        return r;
    }

std::auto_ptr< lines_t >
load_data( int max_capacity )
    {
        std::auto_ptr< lines_t > data( new lines_t() );
        for( int i = 0; std::cin && i != max_capacity; )
            {
                std::string v;
                std::getline( std::cin, v );

                if( !v.empty() )
                    {
                        data->push_back( v );
                        ++i;
                    }
            }

        return data;
    }

distribution_t
calc_distribution(
    const lines_t & lines,
    int capacity,
    pfn_hash_t hash )
    {
        typedef std::vector< u_long > vector_t;
        typedef std::set< u_long > uniques_t;

        vector_t hash_table( capacity );
        uniques_t uniq;

        int i = 0;
        for( lines_t::const_iterator it = lines.begin();
                i != capacity;
                ++i, ++it )
            {
                unsigned long h = (*hash)( it->data(), it->size() );
                uniq.insert( h );
                ++hash_table[ h % capacity ];
            }

        return distribution_t(
                std::count( hash_table.begin(), hash_table.end(), 0 ),
                *std::max_element( hash_table.begin(), hash_table.end() ),
                uniq.size() );
    }

const int method_name_width = 13;
const int value_width = 13;

void
show_table_header(
    const capacities_t & capacities )
    {
        std::cout.width( method_name_width );
        std::cout << "";

        for( capacities_t::const_iterator it = capacities.begin(),
                it_end = capacities.end();
                it != it_end;
                ++it )
            {
                std::cout.width( value_width );
                std::cout << *it << std::flush;
            }

        std::cout << std::endl;
    }

void
try_hash_method(
    const std::string & method_name,
    pfn_hash_t hash,
    const lines_t & lines,
    const capacities_t & capacities )
    {
        std::cout.width( method_name_width );
        std::cout << method_name;

        for( capacities_t::const_iterator it = capacities.begin(),
                it_end = capacities.end();
                it != it_end;
                ++it )
            {
                std::cout.width( value_width );
                std::cout << calc_distribution( lines, *it, hash ) << std::flush;
            }

        std::cout << std::endl;
    }

// Примечание: следующий код находится под Ruby лицензией.

unsigned long
ruby_elf( const char * p, std::size_t len )
    {
        unsigned long key = 0;
        unsigned long g;
        while (len--) {
            key = (key << 4) + *p++;
            if (g = key & 0xF0000000)
                key ^= g >> 24;
            key &= ~g;
        }

        return key;
    }

unsigned long
ruby_perl( const char * p, std::size_t len )
    {
        unsigned long key = 0;
        while (len--) {
            key += *p++;
            key += (key << 10);
            key ^= (key >> 6);
        }
        key += (key << 3);
        key ^= (key >> 11);
        key += (key << 15);

        return key;
    }

unsigned long
ruby_default( const char * p, std::size_t len )
    {
        unsigned long key = 0;
        while (len--) {
            key = key*65599 + *p;
            p++;
        }
        key = key + (key>>5);
        return key;
    }

// Примечание: следующий код находится под действием лицензии Berkeley DB.

/*
 * __ham_func2 --
 *    Phong Vo's linear congruential hash.
 *
 * PUBLIC: u_int32_t __ham_func2 __P((DB *, const void *, u_int32_t));
 */
#define    DCHARHASH(h, c)    ((h) = 0x63c63cd9*(h) + 0x9c39c33d + (c))

unsigned long
__ham_func2( const char * key, unsigned int len)
{
    const unsigned char *e, *k;
    unsigned int h;
    unsigned char c;

    k = reinterpret_cast< const unsigned char * >( key );
    e = k + len;
    for (h = 0; k != e;) {
        c = *k++;
        if (!c && k > e)
            break;
        DCHARHASH(h, c);
    }
    return (h);
}

/*
 * __ham_func3 --
 *    Ozan Yigit's original sdbm hash.
 *
 * Ugly, but fast.  Break the string up into 8 byte units.  On the first time
 * through the loop get the "leftover bytes" (strlen % 8).  On every other
 * iteration, perform 8 HASHC's so we handle all 8 bytes.  Essentially, this
 * saves us 7 cmp & branch instructions.
 *
 * PUBLIC: u_int32_t __ham_func3 __P((DB *, const void *, u_int32_t));
 */
unsigned long
__ham_func3(const char * key, unsigned int len)
{
    const unsigned char *k;
    unsigned int n, loop;

    if (len == 0)
        return (0);

#define    HASHC    n = *k++ + 65599 * n
    n = 0;
    k = reinterpret_cast< const unsigned char * >( key );

    loop = (len + 8 - 1) >> 3;
    switch (len & (8 - 1)) {
    case 0:
        do {
            HASHC;
    case 7:
            HASHC;
    case 6:
            HASHC;
    case 5:
            HASHC;
    case 4:
            HASHC;
    case 3:
            HASHC;
    case 2:
            HASHC;
    case 1:
            HASHC;
        } while (--loop);
    }
    return (n);
}

/*
 * __ham_func4 --
 *    Chris Torek's hash function.  Although this function performs only
 *    slightly worse than __ham_func5 on strings, it performs horribly on
 *    numbers.
 *
 * PUBLIC: u_int32_t __ham_func4 __P((DB *, const void *, u_int32_t));
 */
unsigned long
__ham_func4(const char * key, unsigned int len)
{
    const unsigned char *k;
    unsigned int h, loop;

    if (len == 0)
        return (0);

#define    HASH4a    h = (h << 5) - h + *k++;
#define    HASH4b    h = (h << 5) + h + *k++;
#define    HASH4    HASH4b
    h = 0;
    k = reinterpret_cast< const unsigned char * >( key );

    loop = (len + 8 - 1) >> 3;
    switch (len & (8 - 1)) {
    case 0:
        do {
            HASH4;
    case 7:
            HASH4;
    case 6:
            HASH4;
    case 5:
            HASH4;
    case 4:
            HASH4;
    case 3:
            HASH4;
    case 2:
            HASH4;
    case 1:
            HASH4;
        } while (--loop);
    }
    return (h);
}

/*
 * Fowler/Noll/Vo hash
 *
 * The basis of the hash algorithm was taken from an idea sent by email to the
 * IEEE Posix P1003.2 mailing list from Phong Vo (kpv@research.att.com) and
 * Glenn Fowler (gsf@research.att.com).  Landon Curt Noll (chongo@toad.com)
 * later improved on their algorithm.
 *
 * The magic is in the interesting relationship between the special prime
 * 16777619 (2^24 + 403) and 2^32 and 2^8.
 *
 * This hash produces the fewest collisions of any function that we've seen so
 * far, and works well on both numbers and strings.
 *
 * PUBLIC: u_int32_t __ham_func5 __P((DB *, const void *, u_int32_t));
 */
unsigned long
__ham_func5(const char * key, unsigned int len)
{
    const unsigned char *k, *e;
    unsigned int h;

    k = reinterpret_cast< const unsigned char * >( key );
    e = k + len;
    for (h = 0; k < e; ++k) {
        h *= 16777619;
        h ^= *k;
    }
    return (h);
}

// ---

int
main( int argc, char ** argv )
    {
        if( 1 < argc )
            {
                capacities_t capacities = all_capacities( argv + 1, argv + argc );
                int max_capacity = *std::max_element(
                        capacities.begin(), capacities.end() );

                std::auto_ptr< lines_t > data = load_data( max_capacity );

                show_table_header( capacities );

                try_hash_method( "ACE::hash_pjw", &ACE::hash_pjw,
                        *data, capacities );

                try_hash_method( "Ruby ELFHASH", &ruby_elf,
                        *data, capacities );
                try_hash_method( "Ruby PERL", &ruby_perl,
                        *data, capacities );
                try_hash_method( "Ruby default", &ruby_default,
                        *data, capacities );

                try_hash_method( "BDB HAM_FUNC2", &__ham_func2,
                        *data, capacities );
                try_hash_method( "BDB HAM_FUNC3", &__ham_func3,
                        *data, capacities );
                try_hash_method( "BDB HAM_FUNC4", &__ham_func4,
                        *data, capacities );
                try_hash_method( "BDB HAM_FUNC5", &__ham_func5,
                        *data, capacities );

                return 0;
            }
        else
            {
                std::cout << "hash_test2 <capacity1> [<capacity2> ...]"
                        << std::endl;
                return -1;
            }
    }

class Dmi_3
WORD (*phrase)[];
public://Вы просили публично.
  get_to_back(){delete phrase; phrase=0;}
};
Dmi_3 the_Dmi_3;
int main(){
  the_Dmi_3.get_to_back();
}

unsigned long
hash_fun( const char * p, std::size_t len ){
  unsigned long key = 0;
  while (len--) {
    enum{mul=89};
    STATIC_ASSERT(is_prime<mul>::result);//Это иногда делает hash_fun хорошей.
    key = key*mul + *p;
    p++;
  }
  key = key + (key>>5);
  return key;
}

int fibo(int n,int a=0,int b=1){//template<N,A=0,B=1>struct FIBO
  if(n==0) return a; // Аналог частичной специализации для N=0 enum{result=A};
  return fibo(n-1,b,a+b);// enum{result=FIBO<N-1,B,A+B>::result};
}

template <size_t size> is_pow_of_two { enum { value =   0 == (x & (x-1)) }; };

Summary

Don't put off 'til run time what you can do at build time: Prefer to write code that uses the compiler to check for invariants during compilation, instead of checking them at run time. Run-time checks are control- and data-dependent, which means you'll seldom know whether they are exhaustive. In contrast, compile-time checking is not control- or data-dependent and typically offers higher degrees of confidence.

Discussion

The C++ language offers many opportunities to "accelerate" error detection by pushing it to compilation time. Exploiting these static checking capabilities offers you many advantages, including the following:

Static checks are data- and flow-independent: Static checking offers guarantees that are independent of the program inputs or execution flow. In contrast, to make sure that your run-time checking is strong enough, you need to test it for a representative sample of all inputs. This is a daunting task for all but the most trivial systems.

Statically expressed models are stronger: Oftentimes, a program that relies less on run-time checks and more on compile-time checks reflects a better design because the model the program creates is properly expressed using C++'s type system. This way, you and the compiler are partners having a consistent view of the program's invariants; run-time checks are often a fallback to do checking that could be done statically but cannot be expressed precisely in the language. (See Item 68.)

Static checks don't incur run-time overhead: With static checks replacing dynamic checks, the resulting executable will be faster without sacrificing correctness.

One of C++'s most powerful static checking tools is its static type checking. The debate on whether types should be checked statically (C++, Java, ML, Haskell) or dynamically (Smalltalk, Ruby, Python, Lisp) is open and lively. There is no clear winner in the general case, and there are languages and development styles that favor either kind of checking with reportedly good results. The static checking crowd argues that a large category of run-time error handling can be thus easily eliminated, resulting in stronger programs. On the other hand, the dynamic checking camp says that compilers can only check a fraction of potential bugs, so if you need to write unit tests anyway you might as well not bother with static checking at all and get a less restrictive programming environment.

One thing is clear: Within the context of the statically typed language C++, which provides strong static checking and little automatic run-time checking, programmers should definitely use the type system to their advantage wherever possible (see also Items 90 through 100). At the same time, run-time checks are sensible for data- and flow-dependent checking (e.g., array bounds checking or input data validation) (see Items 70 and 71).

Examples
There are several instances in which you can replace run-time checks with compile-time checks.

Example 1: Compile-time Boolean conditions. If you are testing for compile-time Boolean conditions such as sizeof(int) >= 8, use static assertions instead of run-time tests. (But see also Item 91.)

Example 2: Compile-time polymorphism. Consider replacing run-time polymorphism (virtual functions) with compile-time polymorphism (templates) when defining generic functions or types. The latter yields code that is better checked statically. (See also Item 64.)

Example 3: Enums. Consider defining enums (or, better yet, full-fledged types) when you need to express symbolic constants or restricted integral values.

Example 4: Downcasting. If you frequently use dynamic_cast (or, worse, an unchecked static_cast) to perform downcasting, it can be a sign that your base classes offer too little functionality. Consider redesigning your interfaces so that your program can express computation in terms of the base class.

Exceptions

Some conditions cannot be checked at compile time and require run-time checks. For these, prefer to use assertions to detect internal programming errors (see Item 68) and follow the advice in the rest of the error handling section for other run-time errors such as data-dependent errors (see Items 69 through 75).

E>Смущает только то, что это программисту нужно самому искать простые числа. А STATIC_ASSERT его затем просто проверяет.

//Можно и N-ное простое число вычислить но тут уже лимиты компилятора играют.
//Нет формулы а чисел больно много N/ln(N).
template<int N>
struct prime{
  enum{result=берём прошлое число и прибавляем двойку пока не получим простое};
};

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

#include <ace/ACE.h>

int
main( int argc, char ** argv )
    {
        const std::size_t capacity = 2048;
        
        typedef std::vector< u_long > vector_t;

        vector_t hash_table( capacity );

        for( std::size_t i = 0; std::cin && i != capacity; )
            {
                std::string v;
                std::getline( std::cin, v );

                if( !v.empty() )
                    {
                        u_long h = ACE::hash_pjw( v.data(), v.size() );
                        ++hash_table[ h % capacity ];
                        ++i;
                    }
            }

        std::cout << capacity << ": "
                << std::count( hash_table.begin(), hash_table.end(), 0 )
                << std::endl;

        return 0;
    }

2049: 750
2053: 741  # Простое число.
2048: 1920

8192: 7680
8209: 3610 # Простое число.
8193: 3612

E>2049: 750
E>2053: 741  # Простое число.
E>2048: 1920
E>

E>8192: 7680
E>8209: 3610 # Простое число.
E>8193: 3612
E>

2000: 1875
2001: 743
2003: 729  # Простое число.

2500: 1890
2501: 944
2503: 951    # Простое число.

Name: value
Name2: another value

    typedef std::map<std::wstring,std::wstring> props; //Карта, в 
которую будут складываться свойства

    std::wstring name,value; //Текущие имя и значение
    rule<wide_phrase_scanner_t> identifier_rule=lexeme_d[(alpha_p | L'_' 
| L'$') >> *(alnum_p | L'_' | L'$')];
    rule<wide_phrase_scanner_t> 
value_rule=lexeme_d[*(anychar_p-L'\n'-L'\r')];   
    rule<wide_phrase_scanner_t> record_rule=
        identifier_rule[assign_a(name)] >> ":" >> 
value_rule[assign_a(value)];
    rule<wide_phrase_scanner_t> 
manifest_rule=+(record_rule[insert_at_a(props,cref(name),cref(value))]);

    //Вызов парсера
    parse_info<const wchar_t*> info=::parse(_manifest, 
_manifest+_size,manifest_rule,space_p);
    if (!info.hit || !info.full) //Проверка ошибок
        throw 
std::runtime_error(narrow_string_to_utf8(load_string(IDS_ERROR_MANIFEST)));

require 'mxx_ru/cpp'

require 'oess_1/util_cpp_serializer/gen'

Mxx_ru::setup_target( Mxx_ru::Cpp::Exe_target.new( "some_project.rb" ) {
    ...
    ddl = generator( Oess_1::Util_cpp_serializer::Gen.new( self ) )
    ...
    ddl.ddl_file "some_file.ddl"
    ...
    }
)

ddl = generator( Oess_1::Util_cpp_serializer::Gen.new( self ) )

— используем стороннюю утилиту для генерации распознавателя (flex, re2c, lemon, antlr и проч)
за: (1)не требуется интерпретации выражения в run-time
против: (1)во время билда требуется утилита-генератор и (возможно) сопровождающие ее библиотеки (2)требуется модификация проекта чтобы утилита вовремя вызывалась.

//Вычислим ближайщее к N простое число не меньшее N.
template<unsigned int N>
class get_near_prime_number{
  template<unsigned int K>
  struct ask{
    enum{
      tmp=is_prime<K>::result,
      answer=tmp?K:ask<(K+2u)*!tmp>::answer
    };
  };
  template<>struct ask<0u>{enum{answer=0u};};
public:
  enum{result=ask<N|1u>::answer};
};

template<unsigned int N>
class is_prime{
  template<unsigned int K>
  struct ask{
    enum{
      tmp=(N<K*K),//Временных переменных никто не отменял :-)
      answer=tmp|ask<(K+6u)*(!tmp&&(N%K)&&(N%(K+2u))&&(N%(K+4u)))>::answer
    };
  };
  template<>struct ask<0u>{enum{answer=0u};};//Признак окончания разбора.
public:
  enum{result=ask<3u*(N&1u)>::answer};
};
template<>class is_prime<1u>{public:enum{result=0u};};
template<>class is_prime<2u>{public:enum{result=1u};};

template<unsigned int N>
class get_near_prime_number{
  template<unsigned int K>
  struct ask{
    enum{
      tmp=is_prime<K>::result,
      answer=tmp?K:ask<(K+2u)*!tmp>::answer
    };
  };
  template<>struct ask<0u>{enum{answer=0u};};
public:
  enum{result=ask<N|1u>::answer};
};

// Позволил себе слегка модифицировать твой пример.
template<class KEY,class DATA,unsigned int starting_size,unsigned int(*hash_fun)(KEY const&)>
class hash{
    enum { size = get_near_prime_number<starting_size>::result };
  std::list<std::pair<KEY,DATA> > buffer[size];

template<class KEY,class DATA,unsigned int size,unsigned int(*hash_fun)(KEY const&)>
class hash{
    STATIC_ASSERT( ( size & 2 ) == 0 );
  std::list<std::pair<KEY,DATA> > buffer[size];

Прогонял его на одном и том же log-файле с разными значениями capacity. Оказалось, что capacity, который является степенью двойки, дает наихудший результат (причем намного худший):
2049: 750
2053: 741 # Простое число.
2048: 1920


А на вчетверо больших значениях еще страшнее:
8192: 7680
8209: 3610 # Простое число.
8193: 3612

В общем, уважаемые коллеги по C++ цеху, давайте не будем stupid, и будет пытаться "Keep it simple"

Если же подумать, увидишь, что идеальное объявление привлечет одного
человека, и того именно, кто нужен. Начнем с предельного случая:

"Требуется акробат, который может пройти по проволоке на высоте 200 м
над бушующим пламенем. Ходить придется дважды в день, по субботам —
трижды. Плата — 25 фунтов в неделю. Ни пенсии, ни компенсации за увечье не
будет. Явиться лично в цирк "Дикий Кот" от 9 до 10".

D_>size_t const capacity[]={
D_>  near_prime<fibonachchi<10>::result>::result,
D_>  near_prime<fibonachchi<11>::result>::result,
D_>  near_prime<fibonachchi<12>::result>::result,
D_>  near_prime<fibonachchi<13>::result>::result,
D_>  near_prime<fibonachchi<14>::result>::result,
D_>…..
D_>  near_prime<fibonachchi<44>::result>::result,
D_>  near_prime<fibonachchi<45>::result>::result,
D_>  near_prime<fibonachchi<46>::result>::result,
D_>};
D_>

/*! \note Это последовательность простых чисел, ближайших к числам Фибоначчи. */
size_t const capacity[]={
    59, 89, 149, 233, 379, 613, 991, 1597,
    2591, 4201, 6779, 10949, 17713, 28657,
    46381, 75029, 121403, 196429, 317827,
    514229, 832063, 1346273, 2178313,
    3524603, 5702897
};

near_prime<fibbonachchi<46>::result>::result,
near_prime<fibbonachchi<47>::result>::result,
near_prime<fibbonachchi<47>::result>::result,
near_prime<fibbonachchi<49>::result>::result,

template<unsigned int N>
class is_prime{
  template<unsigned int K>
  struct ask{
    enum{
      tmp=(N<K*K),//Временных переменных никто не отменял :-)
      answer=tmp|ask<(K+6u)*(!tmp&&(N%K)&&(N%(K+2u))&&(N%(K+4u)))>::answer
    };
  };
  template<>struct ask<0u>{enum{answer=0u};};//Признак окончания разбора.
public:
  enum{result=ask<3u*(N&1u)>::answer};
};
template<>class is_prime<1u>{public:enum{result=0u};};
template<>class is_prime<2u>{public:enum{result=1u};};

template<unsigned int N>
class get_near_prime_number{
  template<unsigned int K>
  struct ask{
    enum{
      tmp=is_prime<K>::result,
      answer=tmp?K:ask<(K+2u)*!tmp>::answer
    };
  };
  template<>struct ask<0u>{enum{answer=0u};};
public:
  enum{result=ask<N|1u>::answer};
};

template< unsigned int N >
class is_prime
    {
        template< unsigned int K >
        struct ask
            {
                enum
                    {
                        // Временных переменных никто не отменял :-)
                        tmp = ( N < K*K ),
                        
                        // Здесь бы не помешал какой-то осмысленный комментарий.
                        answer = tmp |
                            ask< ( K + 6u ) *
                                ( !tmp && (N%K) && (N % (K+2u) ) && ( N % (K+4u) ) ) >::answer
                    };
            };
            
        template<>
        struct ask< 0u >
            {
                enum
                    {
                        // Признак окончания разбора.
                        answer = 0u
                    };
            };
    public:
        enum
            {
                // Здесь бы не помешал какой-то осмысленный комментарий.
                result = ask< 3u * (N & 1u) >::answer
            };
    };
    
template<>
class is_prime< 1u >
    {
    public:
        enum { result = 0u };
    };

template<>
class is_prime< 2u >
    {
    public:
        enum { result = 1u };
    };

template< unsigned int N >
class get_near_prime_number
    {
        template<unsigned int K>
        struct ask
            {
                enum
                    {
                        tmp= is_prime< K >::result,
                        // Здесь бы не помешал какой-то осмысленный комментарий.
                        answer = tmp ?
                                K :
                                ask< ( K + 2u ) * !tmp >::answer
                    };
            };
            
        template<>
        struct ask< 0u >
            {
                enum { answer = 0u };
            };
            
    public:
        enum
            {
                result= ask< N | 1u >::answer
            };
    };

// Сила
si::force f1(10);      // 10 Н
cgs::force f2 = f1*2;  // 10 Н * 2 = 2000000 дин

si::force f3 = m1*l2/(t1*t1); // 1 г * 1 м / (1 с * 1 с) = 0.001 Н

E>>>Так вот в СГС есть только три основные размерности. Остальные выражаются через эти

CX>>Кроме электрических и магнитных величин.

E>Не, они там тоже выражаются, только степени полуцелые выходят

Так как в системе СГС большинство единиц не имеет наименований, то единицу какой-либо физической величины мы будем обозначать символом этой системы с соответствующим индексом. Так, например, единицу силы тока — символом СГСi, единицу емкости — СГСc, напряжение — СГСu и т.д.