public void setState(BitVector bits)
{
- if (bits.width() != output.width())
- throw new IllegalArgumentException("Incorrect bit vector width");
+ if (bits.length() != output.width())
+ throw new IllegalArgumentException("Incorrect bit vector length");
if (bits.equals(output.getInputValues()))
return;
output.feedSignals(bits);
return bits;
}
- public BitVector toVector(int width)
+ public BitVector toVector(int length)
{
- return BitVector.of(this, width);
+ return BitVector.of(this, length);
}
@Override
return new BitVector(bits.clone());
}
- public static BitVector of(Bit bit, int width)
+ public static BitVector of(Bit bit, int length)
{
- if (width == 1)
+ if (length == 1)
return SINGLE_BIT_MAPPING[bit.ordinal()];
- return new BitVector(bit.makeArray(width));
+ return new BitVector(bit.makeArray(length));
}
public static BitVector from(long value, int bits)
return new BitVector(unOp(bits.clone(), Bit::not));
}
- public int width()
+ public int length()
{
return bits.length;
}
public BitVector concat(BitVector other)
{
- Bit[] newBits = Arrays.copyOf(bits, width() + other.width());
- System.arraycopy(other.bits, 0, newBits, width(), other.width());
+ Bit[] newBits = Arrays.copyOf(bits, length() + other.length());
+ System.arraycopy(other.bits, 0, newBits, length(), other.length());
return new BitVector(newBits);
}
public BitVector subVector(int start)
{
- return new BitVector(Arrays.copyOfRange(bits, start, width()));
+ return new BitVector(Arrays.copyOfRange(bits, start, length()));
}
public BitVector subVector(int start, int end)
private void checkCompatibility(BitVector bv)
{
- if (width() != bv.width())
- throw new IllegalArgumentException(format("BitVector width does not match: %d and %d", width(), bv.width()));
+ if (length() != bv.length())
+ throw new IllegalArgumentException(format("BitVector length does not match: %d and %d", length(), bv.length()));
}
static Bit[] binOp(Bit[] dest, Bit[] second, BinaryOperator<Bit> op)
}
/**
- * Returns a new mutator of the specified width, <b>with all bits set to <code>null</code></b>. Use with care!
+ * Returns a new mutator of the specified length, <b>with all bits set to <code>null</code></b>. Use with care!
*/
- public static BitVectorMutator ofWidth(int width)
+ public static BitVectorMutator ofLength(int length)
{
- return new BitVectorMutator(new Bit[width]);
+ return new BitVectorMutator(new Bit[length]);
}
/**
return bits[bits.length - bitIndex - 1];
}
- public int width()
+ public int length()
{
if (bits == null)
- throw new IllegalStateException("cannot obtain a width of an empty mutator");
+ throw new IllegalStateException("cannot obtain a length of an empty mutator");
return bits.length;
}
private void checkCompatibility(BitVector bv)
{
- if (bits != null && bits.length != bv.width())
- throw new IllegalArgumentException(format("BitVector width does not match: %d and %d", bits.length, bv.width()));
+ if (bits != null && bits.length != bv.length())
+ throw new IllegalArgumentException(format("BitVector length does not match: %d and %d", bits.length, bv.length()));
}
}
/**
* Does test for equality of values/content, shifting the other BitVector by <code>offset</code> to the right.<br>
- * Therefore <code>offset + other.width() <= this.wdith()</code> needs to be true.
+ * Therefore <code>offset + other.length() <= this.wdith()</code> needs to be true.
*
- * @throws ArrayIndexOutOfBoundsException if <code>offset + other.width() > this.width()</code>
+ * @throws ArrayIndexOutOfBoundsException if <code>offset + other.length() > this.length()</code>
*
* @see Object#equals(Object)
*/
{
if (other == null)
return false;
- return Arrays.equals(bits, offset, offset + other.width(), other.bits, 0, other.width());
+ return Arrays.equals(bits, offset, offset + other.length(), other.bits, 0, other.length());
}
/**
@Override
public boolean hasNext()
{
- return pos != width();
+ return pos != length();
}
};
}
public static ColorDefinition formatAsColor(BitVector bitVector)
{
// TODO maybe find a color assignment for multiple-bit bit vectors?
- if (bitVector == null || bitVector.width() != 1)
+ if (bitVector == null || bitVector.length() != 1)
return new ColorDefinition(BuiltInColor.COLOR_BLACK);
switch (bitVector.getLSBit(0))
{
public void feedSignals(BitVector newValues)
{
- if (newValues.width() != width)
+ if (newValues.length() != width)
throw new IllegalArgumentException(
- String.format("Attempted to input %d bits instead of %d bits.", newValues.width(), width));
+ String.format("Attempted to input %d bits instead of %d bits.", newValues.length(), width));
if (!open)
throw new IllegalStateException("Attempted to write to closed WireArrayEnd.");
timeline.addEvent(e -> setValues(newValues), travelTime);
if (!inputValues.equalsWithOffset(newValues, startingBit))
{
Bit[] vals = inputValues.getBits();
- System.arraycopy(newValues.getBits(), 0, vals, startingBit, newValues.width());
+ System.arraycopy(newValues.getBits(), 0, vals, startingBit, newValues.length());
inputValues = BitVector.of(vals);
Wire.this.recalculate();
}
assertEquals(SINGLE_U, SINGLE_0.join(SINGLE_U));
assertEquals(SINGLE_X, SINGLE_X.join(SINGLE_Z));
- // higher width
+ // higher length
var result = BitVector.of(U, X, ZERO, ONE, Z).join(BitVector.of(ONE, ZERO, ZERO, ONE, Z));
assertEquals(BitVector.of(U, X, ZERO, ONE, Z), result);
}
assertEquals(SINGLE_0, SINGLE_0.and(SINGLE_U));
assertEquals(SINGLE_X, SINGLE_X.and(SINGLE_Z));
- // higher width
+ // higher length
var result = BitVector.of(U, X, ZERO, ONE, ONE).and(BitVector.of(ONE, ONE, ZERO, ZERO, ONE));
assertEquals(BitVector.of(U, X, ZERO, ZERO, ONE), result);
}
assertEquals(SINGLE_1, SINGLE_1.or(SINGLE_U));
assertEquals(SINGLE_X, SINGLE_X.or(SINGLE_Z));
- // higher width
+ // higher length
var result = BitVector.of(U, X, ZERO, ONE, ZERO).or(BitVector.of(ZERO, ZERO, ZERO, ONE, ONE));
assertEquals(BitVector.of(U, X, ZERO, ONE, ONE), result);
}
assertEquals(SINGLE_U, SINGLE_0.xor(SINGLE_U));
assertEquals(SINGLE_X, SINGLE_X.xor(SINGLE_Z));
- // higher width
+ // higher length
var result = BitVector.of(U, X, ZERO, ONE, ONE).xor(BitVector.of(ONE, ZERO, ZERO, ZERO, ONE));
assertEquals(BitVector.of(U, X, ZERO, ONE, ZERO), result);
}
assertEquals(SINGLE_X, SINGLE_X.not());
assertEquals(SINGLE_X, SINGLE_Z.not());
- // higher width
+ // higher length
var result = BitVector.of(U, X, ZERO, ONE, Z).not();
assertEquals(BitVector.of(U, X, ONE, ZERO, X), result);
}
@Test
- void testWidth()
+ void testLength()
{
- assertEquals(0, BitVector.of().width());
- assertEquals(1, SINGLE_0.width());
- assertEquals(3, BitVector.of(X, X, Z).width());
+ assertEquals(0, BitVector.of().length());
+ assertEquals(1, SINGLE_0.length());
+ assertEquals(3, BitVector.of(X, X, Z).length());
}
@Test
"q3",
"q4"
],
- "vectorPartWidths": [
+ "vectorPartLengthes": [
1,
1,
1,
"q3",
"q4"
],
- "vectorPartWidths": [
+ "vectorPartLengthes": [
1,
1,
1,
"q3",
"q4"
],
- "vectorPartWidths": [
+ "vectorPartLengthes": [
1,
1,
1,
"c01.q",
"c00.q"
],
- "vectorPartWidths": [
+ "vectorPartLengthes": [
4,
4,
4,
"c01.q",
"c00.q"
],
- "vectorPartWidths": [
+ "vectorPartLengthes": [
16,
16,
16,
return sb.reverse().toString();
}
- public static BitVector of(int value, int width)
+ public static BitVector of(int value, int length)
{
- BitVectorMutator mutator = BitVectorMutator.ofWidth(width);
+ BitVectorMutator mutator = BitVectorMutator.ofLength(length);
int val = value;
- for (int i = width - 1; i >= 0; i--)
+ for (int i = length - 1; i >= 0; i--)
{
mutator.setMSBit(i, Bit.lastBitOf(val));
val >>>= 1;
"q3",
"q4"
],
- "vectorPartWidths": [
+ "vectorPartLengthes": [
1,
1,
1,
"q3",
"q4"
],
- "vectorPartWidths": [
+ "vectorPartLengthes": [
1,
1,
1,
"q3",
"q4"
],
- "vectorPartWidths": [
+ "vectorPartLengthes": [
1,
1,
1,
"c01.q",
"c00.q"
],
- "vectorPartWidths": [
+ "vectorPartLengthes": [
4,
4,
4,
"c01.q",
"c00.q"
],
- "vectorPartWidths": [
+ "vectorPartLengthes": [
16,
16,
16,
{
private SubmodelComponent component;
private final List<String> vectorPartTargets;
- private final List<Integer> vectorPartWidths;
- private int width;
+ private final List<Integer> vectorPartLengthes;
+ private int length;
public BitVectorSplittingAtomicHighLevelStateHandler(HighLevelStateHandlerContext context)
{
{
this.component = context.component;
this.vectorPartTargets = new ArrayList<>();
- this.vectorPartWidths = new ArrayList<>();
+ this.vectorPartLengthes = new ArrayList<>();
if (params != null)
- setVectorParts(params.vectorPartTargets, params.vectorPartWidths);
+ setVectorParts(params.vectorPartTargets, params.vectorPartLengthes);
}
- public void set(List<String> targets, List<Integer> widths)
+ public void set(List<String> targets, List<Integer> lengthes)
{
- setVectorParts(targets, widths);
+ setVectorParts(targets, lengthes);
}
- public void addVectorPart(String target, int width)
+ public void addVectorPart(String target, int length)
{
vectorPartTargets.add(target);
- vectorPartWidths.add(width);
- this.width += width;
+ vectorPartLengthes.add(length);
+ this.length += length;
}
public void clearVectorParts()
{
vectorPartTargets.clear();
- vectorPartWidths.clear();
- width = 0;
+ vectorPartLengthes.clear();
+ length = 0;
}
- private void setVectorParts(List<String> targets, List<Integer> widths)
+ private void setVectorParts(List<String> targets, List<Integer> lengthes)
{
clearVectorParts();
- if (targets.size() != widths.size())
- throw new IllegalArgumentException("Targets list and widths list have different sizes");
+ if (targets.size() != lengthes.size())
+ throw new IllegalArgumentException("Targets list and lengthes list have different sizes");
vectorPartTargets.addAll(targets);
- vectorPartWidths.addAll(widths);
- width += widths.stream().mapToInt(Integer::intValue).sum();
+ vectorPartLengthes.addAll(lengthes);
+ length += lengthes.stream().mapToInt(Integer::intValue).sum();
}
@Override
vectorPart = BitVector.of((Bit) subStateUncasted);
else
vectorPart = (BitVector) subStateUncasted;
- if (vectorPart.width() != vectorPartWidths.get(partIndex))
+ if (vectorPart.length() != vectorPartLengthes.get(partIndex))
throw new IllegalArgumentException(
- "Incorrect vector part width: " + vectorPart.width() + "; expected " + vectorPartWidths.get(partIndex));
+ "Incorrect vector part length: " + vectorPart.length() + "; expected " + vectorPartLengthes.get(partIndex));
result = vectorPart.concat(result);
}
return result;
public void setHighLevelState(Object newState)
{
BitVector newStateCasted = (BitVector) newState;
- if (newStateCasted.width() != width)
- throw new IllegalArgumentException("Incorrect vector width: " + newStateCasted.width() + "; expected " + width);
+ if (newStateCasted.length() != length)
+ throw new IllegalArgumentException("Incorrect vector length: " + newStateCasted.length() + "; expected " + length);
for (int partIndex = vectorPartTargets.size() - 1, bitIndex = 0; partIndex >= 0; partIndex--)
{
- int vectorPartWidth = vectorPartWidths.get(partIndex);
- BitVector vectorPart = newStateCasted.subVector(bitIndex, bitIndex + vectorPartWidth);
+ int vectorPartLength = vectorPartLengthes.get(partIndex);
+ BitVector vectorPart = newStateCasted.subVector(bitIndex, bitIndex + vectorPartLength);
component.setHighLevelState(vectorPartTargets.get(partIndex), vectorPart);
- bitIndex += vectorPartWidth;
+ bitIndex += vectorPartLength;
}
}
{
BitVectorSplittingAtomicHighLevelStateHandlerParams params = new BitVectorSplittingAtomicHighLevelStateHandlerParams();
params.vectorPartTargets = new ArrayList<>(vectorPartTargets);
- params.vectorPartWidths = new ArrayList<>(vectorPartWidths);
+ params.vectorPartLengthes = new ArrayList<>(vectorPartLengthes);
return params;
}
public static class BitVectorSplittingAtomicHighLevelStateHandlerParams
{
public List<String> vectorPartTargets;
- public List<Integer> vectorPartWidths;
+ public List<Integer> vectorPartLengthes;
}
static
int bitLength = raw.bitLength() - (bi.signum() - 1) / 2;
if (bitLength > size)
throw new AsmNumberFormatException("Error parsing %s: bit count %d exceeds size %d", bi, bitLength, size);
- BitVectorMutator bvm = BitVectorMutator.ofWidth(size);
+ BitVectorMutator bvm = BitVectorMutator.ofLength(size);
for (int i = 0; i < size; i++)
bvm.setLSBit(i, Bit.of(raw.testBit(i)));
return bvm.toBitVector();
int bitLength = bi.bitLength() - (bi.signum() - 1) / 2;
if (bitLength > size)
throw new AsmNumberFormatException("Error parsing %s: bit count %d exceeds size %d", bi, bitLength, size);
- BitVectorMutator bvm = BitVectorMutator.ofWidth(size);
+ BitVectorMutator bvm = BitVectorMutator.ofLength(size);
for (int i = 0; i < size; i++)
bvm.setLSBit(i, Bit.of(bi.testBit(i)));
return bvm.toBitVector();
vectorLenght = 0;
else
{
- vectorLenght = values[0].getValue().width();
+ vectorLenght = values[0].getValue().length();
for(int i = 1; i < values.length; i++)
- if(values[i].getValue().width() != vectorLenght)
+ if(values[i].getValue().length() != vectorLenght)
throw new IllegalArgumentException("MnemonicFamily is not of uniform vector length!");
}
byText = Arrays.stream(values).collect(Collectors.toMap(m -> m.getText(), m -> m));
public void setCell(int index, BitVector bits)
{
- if (bits.width() != cellWidth)
+ if (bits.length() != cellWidth)
throw new IllegalArgumentException(String.format(
- "BitVector to be saved in memory cell has unexpected width. Expected: %d Actual: %d", cellWidth, bits.width()));
+ "BitVector to be saved in memory cell has unexpected width. Expected: %d Actual: %d", cellWidth, bits.length()));
memory[index] = bits;
}
projects / Mograsim.git / commitdiff