Changeset 12

Show
Ignore:
Timestamp:
03/25/06 09:02:36 (2 years ago)
Author:
nail
Message:

Added possibility to define left-opened interval for unit uniform engines

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/helix/random.d

    r11 r12  
    168168 
    169169/********************************************************************/ 
    170 struct UnitUniformEngine(BaseEngine, bool closed) 
     170struct UnitUniformEngine(BaseEngine, bool closedLeft, bool closedRight) 
    171171{ 
    172172    private BaseEngine baseEngine; 
    173173 
    174     const static real min = 0; 
    175     const static real max = cast(real)(baseEngine.max - baseEngine.min) * (1.l / denominator); 
    176  
    177     private const static real denominator = 
    178         cast(real)(cast(ulong)(baseEngine.max - baseEngine.min) + (closed ? 0 : 1)); 
     174    const static 
     175    { 
     176        real min = (closedLeft ? 0 : increment) * (1/denominator); 
     177        real max = (range + (closedLeft ? 0 : increment)) * (1/denominator); 
     178    } 
     179 
     180    private const static 
     181    { 
     182        real range = cast(real)(baseEngine.max - baseEngine.min); 
     183        real increment = (baseEngine.max > uint.max) ? 2.l : 0.2l; 
     184        real denominator = range + (closedLeft ? 0 : increment) + (closedRight ? 0 : increment); 
     185    } 
    179186 
    180187    real pop() 
    …… 
    192199        else 
    193200        { 
    194             return cast(real)(x - baseEngine.min) * (1.l / denominator); 
     201            return (cast(real)(x - baseEngine.min) + (closedLeft ? 0 : increment)) * (1/denominator); 
    195202        } 
    196203    } 
    …… 
    204211unittest 
    205212{ 
    206     static assert(UnitUniformEngine!(Rand48Engine, true).max == 1.l); 
    207     static assert(UnitUniformEngine!(Rand48Engine, false).max < 1.l); 
     213    alias UnitUniformEngine!(Rand48Engine, true, true) fullClosed; 
     214    alias UnitUniformEngine!(Rand48Engine, true, false) closedLeft; 
     215    alias UnitUniformEngine!(Rand48Engine, false, true) closedRight; 
     216    alias UnitUniformEngine!(Rand48Engine, false, false) fullOpened; 
     217 
     218    static assert(fullClosed.min == 0.l); 
     219    static assert(fullClosed.max == 1.l); 
     220 
     221    static assert(closedLeft.min == 0.l); 
     222    static assert(closedLeft.max < 1.l); 
     223     
     224    static assert(closedRight.min > 0.l); 
     225    static assert(closedRight.max == 1.l); 
     226 
     227    static assert(fullOpened.min > 0.l); 
     228    static assert(fullOpened.max < 1.l); 
    208229} 
    209230 
    210231/********************************************************************/ 
    211 struct HighresUnitUniformEngine(BaseEngine, bool closed) 
     232struct HighresUnitUniformEngine(BaseEngine, bool closedLeft, bool closedRight) 
    212233{ 
    213234    private BaseEngine baseEngine; 
    214235 
    215     static const real min = 0; 
    216     static const real max = 0x1p64 * (1 / denominator); 
    217  
    218     private const static real denominator = 0x1p64 + (closed ? 0 : 2); 
     236    static const 
     237    { 
     238        real min = (closedLeft ? 0 : increment) * (1 / denominator); 
     239        real max = (rawMax + (closedLeft ? 0 : increment)) * (1 / denominator); 
     240    } 
     241 
     242    private const static 
     243    { 
     244        real rawMax = uint.max * 0x1p32 + uint.max; 
     245        real increment = 2.l; 
     246        real denominator = rawMax + (closedLeft ? 0 : increment) + (closedRight ? 0 : increment); 
     247    } 
    219248 
    220249    real pop() 
    …… 
    236265            static assert( baseEngine.min == 0 && baseEngine.max == uint.max ); 
    237266 
    238             uint a = cast(uint)(baseEngine.pop() & 0xffff_ffff); 
    239             uint b = cast(uint)(baseEngine.pop() & 0xffff_ffff); 
    240             return (a * 0x1p32 + b) * (1 / denominator); 
     267            uint a = cast(uint)baseEngine.pop(); 
     268            uint b = cast(uint)baseEngine.pop(); 
     269            return (a * 0x1p32 + b + (closedLeft ? 0 : increment)) * (1 / denominator); 
    241270        } 
    242271    } 
    …… 
    250279unittest 
    251280{ 
    252     static assert(HighresUnitUniformEngine!(Rand48Engine, true).max == 1.l); 
    253     static assert(HighresUnitUniformEngine!(Rand48Engine, false).max < 1.l); 
    254 } 
     281    alias HighresUnitUniformEngine!(Rand48Engine, true, true) fullClosed; 
     282    alias HighresUnitUniformEngine!(Rand48Engine, true, false) closedLeft; 
     283    alias HighresUnitUniformEngine!(Rand48Engine, false, true) closedRight; 
     284    alias HighresUnitUniformEngine!(Rand48Engine, false, false) fullOpened; 
     285 
     286    static assert(fullClosed.min == 0.l); 
     287    static assert(fullClosed.max == 1.l); 
     288 
     289    static assert(closedLeft.min == 0.l); 
     290    static assert(closedLeft.max < 1.l); 
     291     
     292    static assert(closedRight.min > 0.l); 
     293    static assert(closedRight.max == 1.l); 
     294 
     295    static assert(fullOpened.min > 0.l); 
     296    static assert(fullOpened.max < 1.l); 
     297}