Changeset 8550


Ignore:
Timestamp:
02/12/05 20:56:44 (17 years ago)
Author:
piso
Message:

Work in progress.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/j/src/org/armedbear/lisp/SimpleBitVector.java

    r7968 r8550  
    22 * SimpleBitVector.java
    33 *
    4  * Copyright (C) 2004 Peter Graves
    5  * $Id: SimpleBitVector.java,v 1.10 2004-10-13 00:22:19 piso Exp $
     4 * Copyright (C) 2004-2005 Peter Graves
     5 * $Id: SimpleBitVector.java,v 1.11 2005-02-12 20:56:44 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2727public final class SimpleBitVector extends AbstractBitVector
    2828{
    29     public SimpleBitVector(int capacity) // throws ConditionThrowable
     29    public SimpleBitVector(int capacity)
    3030    {
    3131        this.capacity = capacity;
    32         int size = capacity >>> 6;
     32        int size = capacity >>> 6; // 64 bits in a long
     33        // If the capacity is not an integral multiple of 64, we'll need one
     34        // more long.
    3335        if ((capacity & LONG_MASK) != 0)
    3436            ++size;
     
    9799        if (index < 0 || index >= length())
    98100            badIndex(index, length());
    99         int offset = index >> 6;
    100         return (bits[offset] & (1L << index)) != 0 ? Fixnum.ONE : Fixnum.ZERO;
     101        int offset = index >> 6; // Divide by 64.
     102        return (bits[offset] & (1L << (index & LONG_MASK))) != 0 ? Fixnum.ONE : Fixnum.ZERO;
    101103    }
    102104
     
    106108            badIndex(index, capacity);
    107109        int offset = index >> 6;
    108         return (bits[offset] & (1L << index)) != 0 ? Fixnum.ONE : Fixnum.ZERO;
     110        return (bits[offset] & (1L << (index & LONG_MASK))) != 0 ? Fixnum.ONE : Fixnum.ZERO;
    109111    }
    110112
     
    117119            switch (((Fixnum)newValue).value) {
    118120                case 0:
    119                     bits[offset] &= ~(1L << index);
     121                    bits[offset] &= ~(1L << (index & LONG_MASK));
    120122                    return;
    121123                case 1:
    122                     bits[offset] |= 1L << index;
     124                    bits[offset] |= 1L << (index & LONG_MASK);
    123125                    return;
    124126            }
     
    133135    {
    134136        int offset = index >> 6;
    135         return (bits[offset] & (1L << index)) != 0 ? 1 : 0;
     137        return (bits[offset] & (1L << (index & LONG_MASK))) != 0 ? 1 : 0;
    136138    }
    137139
     
    139141    {
    140142        int offset = index >> 6;
    141         bits[offset] |= 1L << index;
     143        bits[offset] |= 1L << (index & LONG_MASK);
    142144    }
    143145
     
    145147    {
    146148        int offset = index >> 6;
    147         bits[offset] &= ~(1L << index);
     149        bits[offset] &= ~(1L << (index & LONG_MASK));
    148150    }
    149151
     
    218220        return new ComplexBitVector(newCapacity, displacedTo, displacement);
    219221    }
     222
     223    public SimpleBitVector and(SimpleBitVector v, SimpleBitVector result)
     224    {
     225        if (result == null)
     226            result = new SimpleBitVector(capacity);
     227        for (int i = bits.length; i-- > 0;)
     228            result.bits[i] = bits[i] & v.bits[i];
     229        return result;
     230    }
     231
     232    public SimpleBitVector ior(SimpleBitVector v, SimpleBitVector result)
     233    {
     234        if (result == null)
     235            result = new SimpleBitVector(capacity);
     236        for (int i = bits.length; i-- > 0;)
     237            result.bits[i] = bits[i] | v.bits[i];
     238        return result;
     239    }
     240
     241    public SimpleBitVector xor(SimpleBitVector v, SimpleBitVector result)
     242    {
     243        if (result == null)
     244            result = new SimpleBitVector(capacity);
     245        for (int i = bits.length; i-- > 0;)
     246            result.bits[i] = bits[i] ^ v.bits[i];
     247        return result;
     248    }
     249
     250    public SimpleBitVector nand(SimpleBitVector v, SimpleBitVector result)
     251    {
     252        if (result == null)
     253            result = new SimpleBitVector(capacity);
     254        for (int i = bits.length; i-- > 0;)
     255            result.bits[i] = ~(bits[i] & v.bits[i]);
     256        return result;
     257    }
     258
     259    // ### %simple-bit-vector-bit-and
     260    private static final Primitive _SIMPLE_BIT_VECTOR_BIT_AND =
     261        new Primitive("%simple-bit-vector-bit-and", PACKAGE_SYS, false,
     262                      "bit-vector1 bit-vector2 result-bit-vector")
     263    {
     264        public LispObject execute(LispObject first, LispObject second,
     265                                  LispObject third)
     266            throws ConditionThrowable
     267        {
     268            return ((SimpleBitVector)first).and((SimpleBitVector)second,
     269                                                ((SimpleBitVector)third));
     270        }
     271    };
     272
     273    // ### %simple-bit-vector-bit-ior
     274    private static final Primitive _SIMPLE_BIT_VECTOR_BIT_IOR =
     275        new Primitive("%simple-bit-vector-bit-ior", PACKAGE_SYS, false,
     276                      "bit-vector1 bit-vector2 result-bit-vector")
     277    {
     278        public LispObject execute(LispObject first, LispObject second,
     279                                  LispObject third)
     280            throws ConditionThrowable
     281        {
     282            return ((SimpleBitVector)first).ior((SimpleBitVector)second,
     283                                                (SimpleBitVector)third);
     284
     285        }
     286    };
     287
     288    // ### %simple-bit-vector-bit-xor
     289    private static final Primitive _SIMPLE_BIT_VECTOR_BIT_XOR =
     290        new Primitive("%simple-bit-vector-bit-xor", PACKAGE_SYS, false,
     291                      "bit-vector1 bit-vector2 result-bit-vector")
     292    {
     293        public LispObject execute(LispObject first, LispObject second,
     294                                  LispObject third)
     295            throws ConditionThrowable
     296        {
     297            return ((SimpleBitVector)first).xor((SimpleBitVector)second,
     298                                                (SimpleBitVector)third);
     299
     300        }
     301    };
     302
     303    // ### %simple-bit-vector-bit-nand
     304    private static final Primitive _SIMPLE_BIT_VECTOR_BIT_NAND =
     305        new Primitive("%simple-bit-vector-bit-nand", PACKAGE_SYS, false,
     306                      "bit-vector1 bit-vector2 result-bit-vector")
     307    {
     308        public LispObject execute(LispObject first, LispObject second,
     309                                  LispObject third)
     310            throws ConditionThrowable
     311        {
     312            return ((SimpleBitVector)first).nand((SimpleBitVector)second,
     313                                                 (SimpleBitVector)third);
     314        }
     315    };
    220316}
Note: See TracChangeset for help on using the changeset viewer.