Changeset 510

Show
Ignore:
Timestamp:
11/21/07 16:06:12 (1 year ago)
Author:
andrei
Message:

Post Brad review

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • candidate/phobos/std/algorithm.d

    r507 r510  
    3636 
    3737module std.algorithm; 
    38 import std.stdio, std.math, std.random, std.date, std.functional; 
     38private import std.stdio; 
     39private import std.math; 
     40private import std.random; 
     41private import std.date; 
     42private import std.functional; 
    3943 
    4044/* The iterator-related part below is undocumented and might 
    …… 
    121125 
    122126/** 
    123 Implements C.A.R. Hoare's $(LINK2 http://tinyurl.com/27fk5o, 
     127Implements C.A.R. Hoare's 
     128$(LINK2 http://en.wikipedia.org/wiki/Selection_algorithm#Partition-based_general_selection_algorithm, 
    124129partition) algorithm. Specifically, reorders the range [$(D_PARAM 
    125130left), $(D_PARAM right)$(RPAREN) such that everything strictly smaller 
    …… 
    230235} 
    231236 
    232 unittest { 
    233   scope(failure) writeln(stderr, "Failure testing algorithm"); 
    234   auto v = ([ 25, 7, 9, 2, 0, 5, 21 ]).dup; 
    235   auto n = 4; 
    236   nthElement!(less)(v.ptr, v.ptr + n, v.ptr + v.length); 
    237   assert(v[n] == 9); 
    238   // 
    239   v = ([3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5]).dup; 
    240   n = 3; 
    241   nthElement!(less)(v.ptr, v.ptr + n, v.ptr + v.length); 
    242   assert(v[n] == 3); 
    243   // 
    244   v = ([3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5]).dup; 
    245   n = 1; 
    246   nthElement!(less)(v.ptr, v.ptr + n, v.ptr + v.length); 
    247   assert(v[n] == 2); 
    248   // 
    249   v = ([3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5]).dup; 
    250   n = v.length - 1; 
    251   nthElement!(less)(v.ptr, v.ptr + n, v.ptr + v.length); 
    252   assert(v[n] == 7); 
    253   // 
    254   v = ([3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5]).dup; 
    255   n = 0; 
    256   nthElement!(less)(v.ptr, v.ptr + n, v.ptr + v.length); 
    257   assert(v[n] == 1); 
     237unittest 
     238{ 
     239    scope(failure) writeln(stderr, "Failure testing algorithm"); 
     240    auto v = ([ 25, 7, 9, 2, 0, 5, 21 ]).dup; 
     241    auto n = 4; 
     242    nthElement!(less)(v.ptr, v.ptr + n, v.ptr + v.length); 
     243    assert(v[n] == 9); 
     244    // 
     245    v = ([3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5]).dup; 
     246    n = 3; 
     247    nthElement!(less)(v.ptr, v.ptr + n, v.ptr + v.length); 
     248    assert(v[n] == 3); 
     249    // 
     250    v = ([3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5]).dup; 
     251    n = 1; 
     252    nthElement!(less)(v.ptr, v.ptr + n, v.ptr + v.length); 
     253    assert(v[n] == 2); 
     254    // 
     255    v = ([3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5]).dup; 
     256    n = v.length - 1; 
     257    nthElement!(less)(v.ptr, v.ptr + n, v.ptr + v.length); 
     258    assert(v[n] == 7); 
     259    // 
     260    v = ([3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5]).dup; 
     261    n = 0; 
     262    nthElement!(less)(v.ptr, v.ptr + n, v.ptr + v.length); 
     263    assert(v[n] == 1); 
    258264} 
    259265 

  • candidate/phobos/std/bitarray.d

    r496 r510  
    1111module std.bitarray; 
    1212public import std.bitmanip; 
     13 
     14pragma(msg, "You may want to import std.bitmanip instead of std.bitarray"); 

  • candidate/phobos/std/bitmanip.d

    r495 r510  
    1010module std.bitmanip; 
    1111 
    12 //debug = bitarray;        // uncomment to turn on debugging printf's 
     12//debug = bitarray;                // uncomment to turn on debugging printf's 
    1313 
    1414private import std.intrinsic; 
    15 import std.stdio; 
     15private import std.metastrings; 
     16private import std.stdio; 
    1617 
    1718private string myToString(ulong n) 
    …… 
    268269    size_t dim() 
    269270    { 
    270    return (len + 31) / 32; 
     271        return (len + 31) / 32; 
    271272    } 
    272273 
    273274    size_t length() 
    274275    { 
    275    return len; 
     276        return len; 
    276277    } 
    277278 
    278279    void length(size_t newlen) 
    279280    { 
    280    if (newlen != len) 
    281    { 
    282        size_t olddim = dim(); 
    283        size_t newdim = (newlen + 31) / 32; 
    284  
    285        if (newdim != olddim) 
    286        { 
    287        // Create a fake array so we can use D's realloc machinery 
    288        uint[] b = ptr[0 .. olddim]; 
    289        b.length = newdim;      // realloc 
    290        ptr = b.ptr; 
    291        if (newdim & 31) 
    292        {   // Set any pad bits to 0 
    293            ptr[newdim - 1] &= ~(~0 << (newdim & 31)); 
    294        } 
    295        } 
    296  
    297        len = newlen; 
    298    } 
     281        if (newlen != len) 
     282        { 
     283            size_t olddim = dim(); 
     284            size_t newdim = (newlen + 31) / 32; 
     285 
     286            if (newdim != olddim) 
     287            { 
     288                // Create a fake array so we can use D's realloc machinery 
     289                uint[] b = ptr[0 .. olddim]; 
     290                b.length = newdim;                // realloc 
     291                ptr = b.ptr; 
     292                if (newdim & 31) 
     293                {   // Set any pad bits to 0 
     294                    ptr[newdim - 1] &= ~(~0 << (newdim & 31)); 
     295                } 
     296            } 
     297 
     298            len = newlen; 
     299        } 
    299300    } 
    300301 
    …… 
    305306    in 
    306307    { 
    307    assert(i < len); 
     308        assert(i < len); 
    308309    } 
    309310    body 
    310311    { 
    311    return cast(bool)bt(ptr, i); 
     312        return cast(bool)bt(ptr, i); 
    312313    } 
    313314 
    …… 
    316317    in 
    317318    { 
    318    assert(i < len); 
     319        assert(i < len); 
    319320    } 
    320321    body 
    321322    { 
    322    if (b) 
    323        bts(ptr, i); 
    324    else 
    325        btr(ptr, i); 
    326    return b; 
     323        if (b) 
     324            bts(ptr, i); 
     325        else 
     326            btr(ptr, i); 
     327        return b; 
    327328    } 
    328329 
    …… 
    332333    BitArray dup() 
    333334    { 
    334    BitArray ba; 
    335  
    336    uint[] b = ptr[0 .. dim].dup; 
    337    ba.len = len; 
    338    ba.ptr = b.ptr; 
    339    return ba; 
    340     } 
    341  
    342     unittest 
    343     { 
    344    BitArray a; 
    345    BitArray b; 
    346    int i; 
    347  
    348    debug(bitarray) printf("BitArray.dup.unittest\n"); 
    349  
    350    a.length = 3; 
    351    a[0] = 1; a[1] = 0; a[2] = 1; 
    352    b = a.dup; 
    353    assert(b.length == 3); 
    354    for (i = 0; i < 3; i++) 
    355    {   debug(bitarray) printf("b[%d] = %d\n", i, b[i]); 
    356        assert(b[i] == (((i ^ 1) & 1) ? true : false)); 
    357    } 
     335        BitArray ba; 
     336 
     337        uint[] b = ptr[0 .. dim].dup; 
     338        ba.len = len; 
     339        ba.ptr = b.ptr; 
     340        return ba; 
     341    } 
     342 
     343    unittest 
     344    { 
     345        BitArray a; 
     346        BitArray b; 
     347        int i; 
     348 
     349        debug(bitarray) printf("BitArray.dup.unittest\n"); 
     350 
     351        a.length = 3; 
     352        a[0] = 1; a[1] = 0; a[2] = 1; 
     353        b = a.dup; 
     354        assert(b.length == 3); 
     355        for (i = 0; i < 3; i++) 
     356        {   debug(bitarray) printf("b[%d] = %d\n", i, b[i]); 
     357            assert(b[i] == (((i ^ 1) & 1) ? true : false)); 
     358        } 
    358359    } 
    359360 
    …… 
    363364    int opApply(int delegate(inout bool) dg) 
    364365    { 
    365    int result; 
    366  
    367    for (size_t i = 0; i < len; i++) 
    368    {   bool b = opIndex(i); 
    369        result = dg(b); 
    370        (*this)[i] = b; 
    371        if (result) 
    372        break; 
    373    } 
    374    return result; 
     366        int result; 
     367 
     368        for (size_t i = 0; i < len; i++) 
     369        {   bool b = opIndex(i); 
     370            result = dg(b); 
     371            (*this)[i] = b; 
     372            if (result) 
     373                break; 
     374        } 
     375        return result; 
    375376    } 
    376377 
    …… 
    378379    int opApply(int delegate(inout size_t, inout bool) dg) 
    379380    { 
    380    int result; 
    381  
    382    for (size_t i = 0; i < len; i++) 
    383    {   bool b = opIndex(i); 
    384        result = dg(i, b); 
    385        (*this)[i] = b; 
    386        if (result) 
    387        break; 
    388    } 
    389    return result; 
    390     } 
    391  
    392     unittest 
    393     { 
    394    debug(bitarray) printf("BitArray.opApply unittest\n"); 
    395  
    396    static bool[] ba = [1,0,1]; 
    397  
    398    BitArray a; a.init(ba); 
    399  
    400    int i; 
    401    foreach (b;a) 
    402    { 
    403        switch (i) 
    404        {   case 0: assert(b == true); break; 
    405        case 1: assert(b == false); break; 
    406        case 2: assert(b == true); break; 
    407        default: assert(0); 
    408        } 
    409        i++; 
    410    } 
    411  
    412    foreach (j,b;a) 
    413    { 
    414        switch (j) 
    415        {   case 0: assert(b == true); break; 
    416        case 1: assert(b == false); break; 
    417        case 2: assert(b == true); break; 
    418        default: assert(0); 
    419        } 
    420    } 
     381        int result; 
     382 
     383        for (size_t i = 0; i < len; i++) 
     384        {   bool b = opIndex(i); 
     385            result = dg(i, b); 
     386            (*this)[i] = b; 
     387            if (result) 
     388                break; 
     389        } 
     390        return result; 
     391    } 
     392 
     393    unittest 
     394    { 
     395        debug(bitarray) printf("BitArray.opApply unittest\n"); 
     396 
     397        static bool[] ba = [1,0,1]; 
     398 
     399        BitArray a; a.init(ba); 
     400 
     401        int i; 
     402        foreach (b;a) 
     403        { 
     404            switch (i) 
     405            {        case 0: assert(b == true); break; 
     406                case 1: assert(b == false); break; 
     407                case 2: assert(b == true); break; 
     408                default: assert(0); 
     409            } 
     410            i++; 
     411        } 
     412 
     413        foreach (j,b;a) 
     414        { 
     415            switch (j) 
     416            {        case 0: assert(b == true); break; 
     417                case 1: assert(b == false); break; 
     418                case 2: assert(b == true); break; 
     419                default: assert(0); 
     420            } 
     421        } 
    421422    } 
    422423 
    …… 
    427428 
    428429    BitArray reverse() 
    429    out (result) 
    430    { 
    431        assert(result == *this); 
    432    } 
    433    body 
    434    { 
    435        if (len >= 2) 
    436        { 
    437        bool t; 
    438        size_t lo, hi; 
    439  
    440        lo = 0; 
    441        hi = len - 1; 
    442        for (; lo < hi; lo++, hi--) 
    443        { 
    444            t = (*this)[lo]; 
    445            (*this)[lo] = (*this)[hi]; 
    446            (*this)[hi] = t; 
    447        } 
    448        } 
    449        return *this; 
    450    } 
    451  
    452     unittest 
    453     { 
    454    debug(bitarray) printf("BitArray.reverse.unittest\n"); 
    455  
    456    BitArray b; 
    457    static bool[5] data = [1,0,1,1,0]; 
    458    int i; 
    459  
    460    b.init(data); 
    461    b.reverse; 
    462    for (i = 0; i < data.length; i++) 
    463    { 
    464        assert(b[i] == data[4 - i]); 
    465    } 
     430        out (result) 
     431        { 
     432            assert(result == *this); 
     433        } 
     434        body 
     435        { 
     436            if (len >= 2) 
     437            { 
     438                bool t; 
     439                size_t lo, hi; 
     440 
     441                lo = 0; 
     442                hi = len - 1; 
     443                for (; lo < hi; lo++, hi--) 
     444                { 
     445                    t = (*this)[lo]; 
     446                    (*this)[lo] = (*this)[hi]; 
     447                    (*this)[hi] = t; 
     448                } 
     449            } 
     450            return *this; 
     451        } 
     452 
     453    unittest 
     454    { 
     455        debug(bitarray) printf("BitArray.reverse.unittest\n"); 
     456 
     457        BitArray b; 
     458        static bool[5] data = [1,0,1,1,0]; 
     459        int i; 
     460 
     461        b.init(data); 
     462        b.reverse; 
     463        for (i = 0; i < data.length; i++) 
     464        { 
     465            assert(b[i] == data[4 - i]); 
     466        } 
    466467    } 
    467468 
    …… 
    472473 
    473474    BitArray sort() 
    474    out (result) 
    475    { 
    476        assert(result == *this); 
    477    } 
    478    body 
    479    { 
    480        if (len >= 2) 
    481        { 
    482        size_t lo, hi; 
    483  
    484        lo = 0; 
    485        hi = len - 1; 
    486        while (1) 
    487        { 
    488            while (1) 
    489            { 
    490            if (lo >= hi) 
    491                goto Ldone; 
    492            if ((*this)[lo] == true) 
    493                break; 
    494            lo++; 
    495            } 
    496  
    497            while (1) 
    498            { 
    499            if (lo >= hi) 
    500                goto Ldone; 
    501            if ((*this)[hi] == false) 
    502                break; 
    503            hi--; 
    504            } 
    505  
    506            (*this)[lo] = false; 
    507            (*this)[hi] = true; 
    508  
    509            lo++; 
    510            hi--; 
    511        } 
    512        Ldone: 
    513        ; 
    514        } 
    515        return *this; 
    516    } 
    517  
    518     unittest 
    519     { 
    520    debug(bitarray) printf("BitArray.sort.unittest\n"); 
    521  
    522    static uint x = 0b1100011000; 
    523    static BitArray ba = { 10, &x }; 
    524    ba.sort; 
    525    for (size_t i = 0; i < 6; i++) 
    526        assert(ba[i] == false); 
    527    for (size_t i = 6; i < 10; i++) 
    528        assert(ba[i] == true); 
     475        out (result) 
     476        { 
     477            assert(result == *this); 
     478        } 
     479        body 
     480        { 
     481            if (len >= 2) 
     482            { 
     483                size_t lo, hi; 
     484 
     485                lo = 0; 
     486                hi = len - 1; 
     487                while (1) 
     488                { 
     489                    while (1) 
     490                    { 
     491                        if (lo >= hi) 
     492                            goto Ldone; 
     493                        if ((*this)[lo] == true) 
     494                            break; 
     495                        lo++; 
     496                    } 
     497 
     498                    while (1) 
     499                    { 
     500                        if (lo >= hi) 
     501                            goto Ldone; 
     502                        if ((*this)[hi] == false) 
     503                            break; 
     504                        hi--; 
     505                    } 
     506 
     507                    (*this)[lo] = false; 
     508                    (*this)[hi] = true; 
     509 
     510                    lo++; 
     511                    hi--; 
     512                } 
     513            Ldone: 
     514                ; 
     515            } 
     516            return *this; 
     517        } 
     518 
     519    unittest 
     520    { 
     521        debug(bitarray) printf("BitArray.sort.unittest\n"); 
     522 
     523        static uint x = 0b1100011000; 
     524        static BitArray ba = { 10, &x }; 
     525        ba.sort; 
     526        for (size_t i = 0; i < 6; i++) 
     527            assert(ba[i] == false); 
     528        for (size_t i = 6; i < 10; i++) 
     529            assert(ba[i] == true); 
    529530    } 
    530531 
    …… 
    537538    {   int i; 
    538539 
    539    if (this.length != a2.length) 
    540        return 0;       // not equal 
    541    byte *p1 = cast(byte*)this.ptr; 
    542    byte *p2 = cast(byte*)a2.ptr; 
    543    uint n = this.length / 8; 
    544    for (i = 0; i < n; i++) 
    545    { 
    546        if (p1[i] != p2[i]) 
    547        return 0;       // not equal 
    548    } 
    549  
    550    ubyte mask; 
    551  
    552    n = this.length & 7; 
    553    mask = cast(ubyte)((1 << n) - 1); 
    554    //printf("i = %d, n = %d, mask = %x, %x, %x\n", i, n, mask, p1[i], p2[i]); 
    555    return (mask == 0) || (p1[i] & mask) == (p2[i] & mask); 
    556     } 
    557  
    558     unittest 
    559     { 
    560    debug(bitarray) printf("BitArray.opEquals unittest\n"); 
    561  
    562    static bool[] ba = [1,0,1,0,1]; 
    563    static bool[] bb = [1,0,1]; 
    564    static bool[] bc = [1,0,1,0,1,0,1]; 
    565    static bool[] bd = [1,0,1,1,1]; 
    566    static bool[] be = [1,0,1,0,1]; 
    567  
    568    BitArray a; a.init(ba); 
    569    BitArray b; b.init(bb); 
    570    BitArray c; c.init(bc); 
    571    BitArray d; d.init(bd); 
    572    BitArray e; e.init(be); 
    573  
    574    assert(a != b); 
    575    assert(a != c); 
    576    assert(a != d); 
    577    assert(a == e); 
     540        if (this.length != a2.length) 
     541            return 0;                // not equal 
     542        byte *p1 = cast(byte*)this.ptr; 
     543        byte *p2 = cast(byte*)a2.ptr; 
     544        uint n = this.length / 8; 
     545        for (i = 0; i < n; i++) 
     546        { 
     547            if (p1[i] != p2[i]) 
     548                return 0;                // not equal 
     549        } 
     550 
     551        ubyte mask; 
     552 
     553        n = this.length & 7; 
     554        mask = cast(ubyte)((1 << n) - 1); 
     555        //printf("i = %d, n = %d, mask = %x, %x, %x\n", i, n, mask, p1[i], p2[i]); 
     556        return (mask == 0) || (p1[i] & mask) == (p2[i] & mask); 
     557    } 
     558 
     559    unittest 
     560    { 
     561        debug(bitarray) printf("BitArray.opEquals unittest\n"); 
     562 
     563        static bool[] ba = [1,0,1,0,1]; 
     564        static bool[] bb = [1,0,1]; 
     565        static bool[] bc = [1,0,1,0,1,0,1]; 
     566        static bool[] bd = [1,0,1,1,1]; 
     567        static bool[] be = [1,0,1,0,1]; 
     568 
     569        BitArray a; a.init(ba); 
     570        BitArray b; b.init(bb); 
     571        BitArray c; c.init(bc); 
     572        BitArray d; d.init(bd); 
     573        BitArray e; e.init(be); 
     574 
     575        assert(a != b); 
     576        assert(a != c); 
     577        assert(a != d); 
     578        assert(a == e); 
    578579    } 
    579580 
    …… 
    584585    int opCmp(BitArray a2) 
    585586    { 
    586    uint len; 
    587    uint i; 
    588  
    589    len = this.length; 
    590    if (a2.length < len) 
    591        len = a2.length; 
    592    ubyte* p1 = cast(ubyte*)this.ptr; 
    593    ubyte* p2 = cast(ubyte*)a2.ptr; 
    594    uint n = len / 8; 
    595    for (i = 0; i < n; i++) 
    596    { 
    597        if (p1[i] != p2[i]) 
    598        break;      // not equal 
    599    } 
    600    for (uint j = i * 8; j < len; j++) 
    601    {   ubyte mask = cast(ubyte)(1 << j); 
    602        int c; 
    603  
    604        c = cast(int)(p1[i] & mask) - cast(int)(p2[i] & mask); 
    605        if (c) 
    606        return c; 
    607    } 
    608    return cast(int)this.len - cast(int)a2.length; 
    609     } 
    610  
    611     unittest 
    612     { 
    613    debug(bitarray) printf("BitArray.opCmp unittest\n"); 
    614  
    615    static bool[] ba = [1,0,1,0,1]; 
    616    static bool[] bb = [1,0,1]; 
    617    static bool[] bc = [1,0,1,0,1,0,1]; 
    618    static bool[] bd = [1,0,1,1,1]; 
    619    static bool[] be = [1,0,1,0,1]; 
    620  
    621    BitArray a; a.init(ba); 
    622    BitArray b; b.init(bb); 
    623    BitArray c; c.init(bc); 
    624    BitArray d; d.init(bd); 
    625    BitArray e; e.init(be); 
    626  
    627    assert(a >  b); 
    628    assert(a >= b); 
    629    assert(a <  c); 
    630    assert(a <= c); 
    631    assert(a <  d); 
    632    assert(a <= d); 
    633    assert(a == e); 
    634    assert(a <= e); 
    635    assert(a >= e); 
     587        uint len; 
     588        uint i; 
     589 
     590        len = this.length; 
     591        if (a2.length < len) 
     592            len = a2.length; 
     593        ubyte* p1 = cast(ubyte*)this.ptr; 
     594        ubyte* p2 = cast(ubyte*)a2.ptr; 
     595        uint n = len / 8; 
     596        for (i = 0; i < n; i++) 
     597        { 
     598            if (p1[i] != p2[i]) 
     599                break;                // not equal 
     600        } 
     601        for (uint j = i * 8; j < len; j++) 
     602        {   ubyte mask = cast(ubyte)(1 << j); 
     603            int c; 
     604 
     605            c = cast(int)(p1[i] & mask) - cast(int)(p2[i] & mask); 
     606            if (c) 
     607                return c; 
     608        } 
     609        return cast(int)this.len - cast(int)a2.length; 
     610    } 
     611 
     612    unittest 
     613    { 
     614        debug(bitarray) printf("BitArray.opCmp unittest\n"); 
     615 
     616        static bool[] ba = [1,0,1,0,1]; 
     617        static bool[] bb = [1,0,1]; 
     618        static bool[] bc = [1,0,1,0,1,0,1]; 
     619        static bool[] bd = [1,0,1,1,1]; 
     620        static bool[] be = [1,0,1,0,1]; 
     621 
     622        BitArray a; a.init(ba); 
     623        BitArray b; b.init(bb); 
     624        BitArray c; c.init(bc); 
     625        BitArray d; d.init(bd); 
     626        BitArray e; e.init(be); 
     627 
     628        assert(a >  b); 
     629        assert(a >= b); 
     630        assert(a <  c); 
     631        assert(a <= c); 
     632        assert(a <  d); 
     633        assert(a <= d); 
     634        assert(a == e); 
     635        assert(a <= e); 
     636        assert(a >= e); 
    636637    } 
    637638 
    …… 
    642643    void init(bool[] ba) 
    643644    { 
    644    length = ba.length; 
    645    foreach (i, b; ba) 
    646    { 
    647        (*this)[i] = b; 
    648    } 
     645        length = ba.length; 
     646        foreach (i, b; ba) 
     647        { 
     648            (*this)[i] = b; 
     649        } 
    649650    } 
    650651 
    …… 
    659660    in 
    660661    { 
    661    assert(numbits <= v.length * 8); 
    662    assert((v.length & 3) == 0); 
     662        assert(numbits <= v.length * 8); 
     663        assert((v.length & 3) == 0); 
    663664    } 
    664665    body 
    665666    { 
    666    ptr = cast(uint*)v.ptr; 
    667    len = numbits; 
    668     } 
    669  
    670     unittest 
    671     { 
    672    debug(bitarray) printf("BitArray.init unittest\n"); 
    673  
    674    static bool[] ba = [1,0,1,0,1]; 
    675  
    676    BitArray a; a.init(ba); 
    677    BitArray b; 
    678    void[] v; 
    679  
    680    v = cast(void[])a; 
    681    b.init(v, a.length); 
    682  
    683    assert(b[0] == 1); 
    684    assert(b[1] == 0); 
    685    assert(b[2] == 1); 
    686    assert(b[3] == 0); 
    687    assert(b[4] == 1); 
    688  
    689    a[0] = 0; 
    690    assert(b[0] == 0); 
    691  
    692    assert(a == b); 
     667        ptr = cast(uint*)v.ptr; 
     668        len = numbits; 
     669    } 
     670 
     671    unittest 
     672    { 
     673        debug(bitarray) printf("BitArray.init unittest\n"); 
     674 
     675        static bool[] ba = [1,0,1,0,1]; 
     676 
     677        BitArray a; a.init(ba); 
     678        BitArray b; 
     679        void[] v; 
     680 
     681        v = cast(void[])a; 
     682        b.init(v, a.length); 
     683 
     684        assert(b[0] == 1); 
     685        assert(b[1] == 0); 
     686        assert(b[2] == 1); 
     687        assert(b[3] == 0); 
     688        assert(b[4] == 1); 
     689 
     690        a[0] = 0; 
     691        assert(b[0] == 0); 
     692 
     693        assert(a == b); 
    693694    } 
    694695 
    …… 
    698699    void[] opCast() 
    699700    { 
    700    return cast(void[])ptr[0 .. dim]; 
    701     } 
    702  
    703     unittest 
    704     { 
    705    debug(bitarray) printf("BitArray.opCast unittest\n"); 
    706  
    707    static bool[] ba = [1,0,1,0,1]; 
    708  
    709    BitArray a; a.init(ba); 
    710    void[] v = cast(void[])a; 
    711  
    712    assert(v.length == a.dim * uint.sizeof); 
     701        return cast(void[])ptr[0 .. dim]; 
     702    } 
     703 
     704    unittest 
     705    { 
     706        debug(bitarray) printf("BitArray.opCast unittest\n"); 
     707 
     708        static bool[] ba = [1,0,1,0,1]; 
     709 
     710        BitArray a; a.init(ba); 
     711        void[] v = cast(void[])a; 
     712 
     713        assert(v.length == a.dim * uint.sizeof); 
    713714    } 
    714715 
    …… 
    718719    BitArray opCom() 
    719720    { 
    720    auto dim = this.dim(); 
    721  
    722    BitArray result; 
    723  
    724    result.length = len; 
    725    for (size_t i = 0; i < dim; i++) 
    726        result.ptr[i] = ~this.ptr[i]; 
    727    if (len & 31) 
    728        result.ptr[dim - 1] &= ~(~0 << (len & 31)); 
    729    return result; 
    730     } 
    731  
    732     unittest 
    733     { 
    734    debug(bitarray) printf("BitArray.opCom unittest\n"); 
    735  
    736    static bool[] ba = [1,0,1,0,1]; 
    737  
    738    BitArray a; a.init(ba); 
    739    BitArray b = ~a; 
    740  
    741    assert(b[0] == 0); 
    742    assert(b[1] == 1); 
    743    assert(b[2] == 0); 
    744    assert(b[3] == 1); 
    745    assert(b[4] == 0); 
     721        auto dim = this.dim(); 
     722 
     723        BitArray result; 
     724 
     725        result.length = len; 
     726        for (size_t i = 0; i < dim; i++) 
     727            result.ptr[i] = ~this.ptr[i]; 
     728        if (len & 31) 
     729            result.ptr[dim - 1] &= ~(~0 << (len & 31)); 
     730        return result; 
     731    } 
     732 
     733    unittest 
     734    { 
     735        debug(bitarray) printf("BitArray.opCom unittest\n"); 
     736 
     737        static bool[] ba = [1,0,1,0,1]; 
     738 
     739        BitArray a; a.init(ba); 
     740        BitArray b = ~a; 
     741 
     742        assert(b[0] == 0); 
     743        assert(b[1] == 1); 
     744        assert(b[2] == 0); 
     745        assert(b[3] == 1); 
     746        assert(b[4] == 0); 
    746747    } 
    747748 
    …… 
    753754    in 
    754755    { 
    755    assert(len == e2.length); 
     756        assert(len == e2.length); 
    756757    } 
    757758    body 
    758759    { 
    759    auto dim = this.dim(); 
    760  
    761    BitArray result; 
    762  
    763    result.length = len; 
    764    for (size_t i = 0; i < dim; i++) 
    765        result.ptr[i] = this.ptr[i] & e2.ptr[i]; 
    766    return result; 
    767     } 
    768  
    769     unittest 
    770     { 
    771    debug(bitarray) printf("BitArray.opAnd unittest\n"); 
    772  
    773    static bool[] ba = [1,0,1,0,1]; 
    774    static bool[] bb = [1,0,1,1,0]; 
    775  
    776    BitArray a; a.init(ba); 
    777    BitArray b; b.init(bb); 
    778  
    779    BitArray c = a & b; 
    780  
    781    assert(c[0] == 1); 
    782    assert(c[1] == 0); 
    783    assert(c[2] == 1); 
    784    assert(c[3] == 0); 
    785    assert(c[4] == 0); 
     760        auto dim = this.dim(); 
     761 
     762        BitArray result; 
     763 
     764        result.length = len; 
     765        for (size_t i = 0; i < dim; i++) 
     766            result.ptr[i] = this.ptr[i] & e2.ptr[i]; 
     767        return result; 
     768    } 
     769 
     770    unittest 
     771    { 
     772        debug(bitarray) printf("BitArray.opAnd unittest\n"); 
     773 
     774        static bool[] ba = [1,0,1,0,1]; 
     775        static bool[] bb = [1,0,1,1,0]; 
     776 
     777        BitArray a; a.init(ba); 
     778        BitArray b; b.init(bb); 
     779 
     780        BitArray c = a & b; 
     781 
     782        assert(c[0] == 1); 
     783        assert(c[1] == 0); 
     784        assert(c[2] == 1); 
     785        assert(c[3] == 0); 
     786        assert(c[4] == 0); 
    786787    } 
    787788 
    …… 
    793794    in 
    794795    { 
    795    assert(len == e2.length); 
     796        assert(len == e2.length); 
    796797    } 
    797798    body 
    798799    { 
    799    auto dim = this.dim(); 
    800  
    801    BitArray result; 
    802  
    803    result.length = len; 
    804    for (size_t i = 0; i < dim; i++) 
    805        result.ptr[i] = this.ptr[i] | e2.ptr[i]; 
    806    return result; 
    807     } 
    808  
    809     unittest 
    810     { 
    811    debug(bitarray) printf("BitArray.opOr unittest\n"); 
    812  
    813    static bool[] ba = [1,0,1,0,1]; 
    814    static bool[] bb = [1,0,1,1,0]; 
    815  
    816    BitArray a; a.init(ba); 
    817    BitArray b; b.init(bb); 
    818  
    819    BitArray c = a | b; 
    820  
    821    assert(c[0] == 1); 
    822    assert(c[1] == 0); 
    823    assert(c[2] == 1); 
    824    assert(c[3] == 1); 
    825    assert(c[4] == 1); 
     800        auto dim = this.dim(); 
     801 
     802        BitArray result; 
     803 
     804        result.length = len; 
     805        for (size_t i = 0; i < dim; i++) 
     806            result.ptr[i] = this.ptr[i] | e2.ptr[i]; 
     807        return result; 
     808    } 
     809 
     810    unittest 
     811    { 
     812        debug(bitarray) printf("BitArray.opOr unittest\n"); 
     813 
     814        static bool[] ba = [1,0,1,0,1]; 
     815        static bool[] bb = [1,0,1,1,0]; 
     816 
     817        BitArray a; a.init(ba); 
     818        BitArray b; b.init(bb); 
     819 
     820        BitArray c = a | b; 
     821 
     822        assert(c[0] == 1); 
     823        assert(c[1] == 0); 
     824        assert(c[2] == 1); 
     825        assert(c[3] == 1); 
     826        assert(c[4] == 1); 
    826827    } 
    827828 
    …… 
    833834    in 
    834835    { 
    835    assert(len == e2.length); 
     836        assert(len == e2.length); 
    836837    } 
    837838    body 
    838839    { 
    839    auto dim = this.dim(); 
    840  
    841    BitArray result; 
    842  
    843    result.length = len; 
    844    for (size_t i = 0; i < dim; i++) 
    845        result.ptr[i] = this.ptr[i] ^ e2.ptr[i]; 
    846    return result; 
    847     } 
    848  
    849     unittest 
    850     { 
    851    debug(bitarray) printf("BitArray.opXor unittest\n"); 
    852  
    853    static bool[] ba = [1,0,1,0,1]; 
    854    static bool[] bb = [1,0,1,1,0]; 
    855  
    856    BitArray a; a.init(ba); 
    857    BitArray b; b.init(bb); 
    858  
    859    BitArray c = a ^ b; 
    860  
    861    assert(c[0] == 0); 
    862    assert(c[1] == 0); 
    863    assert(c[2] == 0); 
    864    assert(c[3] == 1); 
    865    assert(c[4] == 1); 
     840        auto dim = this.dim(); 
     841 
     842        BitArray result; 
     843 
     844        result.length = len; 
     845        for (size_t i = 0; i < dim; i++) 
     846            result.ptr[i] = this.ptr[i] ^ e2.ptr[i]; 
     847        return result; 
     848    } 
     849 
     850    unittest 
     851    { 
     852        debug(bitarray) printf("BitArray.opXor unittest\n"); 
     853 
     854        static bool[] ba = [1,0,1,0,1]; 
     855        static bool[] bb = [1,0,1,1,0]; 
     856 
     857        BitArray a; a.init(ba); 
     858        BitArray b; b.init(bb); 
     859 
     860        BitArray c = a ^ b; 
     861 
     862        assert(c[0] == 0); 
     863        assert(c[1] == 0); 
     864        assert(c[2] == 0); 
     865        assert(c[3] == 1); 
     866        assert(c[4] == 1);