/**
* Output {@link Wire}s and in must be of uniform width
*
- * @param in Must be of uniform length with all outputs.
+ * @param in Must be of uniform width with all outputs.
* @param select Indexes the output array to which the input is mapped. Must have enough bits to index all outputs.
* @param outputs One of these outputs receives the input signal, depending on the select bits
*/
public void setState(BitVector bits)
{
- if (bits.length() != output.width())
- throw new IllegalArgumentException("Incorrect bit vector length");
+ if (bits.width() != output.width())
+ throw new IllegalArgumentException("Incorrect bit vector width");
if (bits.equals(output.getInputValues()))
return;
output.feedSignals(bits);
this.out = union;
this.beginningIndex = new int[inputs.length];
- int length = 0;
+ int width = 0;
for (int i = 0; i < inputs.length; i++)
{
- beginningIndex[i] = length;
- length += inputs[i].width();
+ beginningIndex[i] = width;
+ width += inputs[i].width();
inputs[i].registerObserver(this);
}
- if (length != union.width())
+ if (width != union.width())
throw new IllegalArgumentException(
"The output of merging n WireArrays into one must have width = a1.width() + a2.width() + ... + an.width().");
}
private final int outputSize;
/**
- * Input {@link Wire}s and out must be of uniform length
+ * Input {@link Wire}s and out must be of uniform width
*
- * @param out Must be of uniform length with all inputs.
+ * @param out Must be of uniform width with all inputs.
* @param select Indexes the input array which is to be mapped to the output. Must have enough bits to index all inputs.
* @param inputs One of these inputs is mapped to the output, depending on the select bits
*/
return bits;
}
- public BitVector toVector(int length)
+ public BitVector toVector(int width)
{
- return BitVector.of(this, length);
+ return BitVector.of(this, width);
}
@Override
return new BitVector(bits.clone());
}
- public static BitVector of(Bit bit, int length)
+ public static BitVector of(Bit bit, int width)
{
- if (length == 1)
+ if (width == 1)
return SINGLE_BIT_MAPPING[bit.ordinal()];
- return new BitVector(bit.makeArray(length));
+ return new BitVector(bit.makeArray(width));
}
public static BitVector from(long value, int bits)
return new BitVector(unOp(bits.clone(), Bit::not));
}
- public int length()
+ public int width()
{
return bits.length;
}
public BitVector concat(BitVector other)
{
- Bit[] newBits = Arrays.copyOf(bits, length() + other.length());
- System.arraycopy(other.bits, 0, newBits, length(), other.length());
+ Bit[] newBits = Arrays.copyOf(bits, width() + other.width());
+ System.arraycopy(other.bits, 0, newBits, width(), other.width());
return new BitVector(newBits);
}
public BitVector subVector(int start)
{
- return new BitVector(Arrays.copyOfRange(bits, start, length()));
+ return new BitVector(Arrays.copyOfRange(bits, start, width()));
}
public BitVector subVector(int start, int end)
private void checkCompatibility(BitVector bv)
{
- if (length() != bv.length())
- throw new IllegalArgumentException(format("BitVector length does not match: %d and %d", length(), bv.length()));
+ if (width() != bv.width())
+ throw new IllegalArgumentException(format("BitVector width does not match: %d and %d", width(), bv.width()));
}
static Bit[] binOp(Bit[] dest, Bit[] second, BinaryOperator<Bit> op)
}
/**
- * Returns a new mutator of the specified length, <b>with all bits set to <code>null</code></b>. Use with care!
+ * Returns a new mutator of the specified width, <b>with all bits set to <code>null</code></b>. Use with care!
*/
- public static BitVectorMutator ofLength(int length)
+ public static BitVectorMutator ofWidth(int width)
{
- return new BitVectorMutator(new Bit[length]);
+ return new BitVectorMutator(new Bit[width]);
}
/**
return bits[bits.length - bitIndex - 1];
}
- public int length()
+ public int width()
{
if (bits == null)
- throw new IllegalStateException("cannot obtain a length of an empty mutator");
+ throw new IllegalStateException("cannot obtain a width of an empty mutator");
return bits.length;
}
private void checkCompatibility(BitVector bv)
{
- if (bits != null && bits.length != bv.length())
- throw new IllegalArgumentException(format("BitVector length does not match: %d and %d", bits.length, bv.length()));
+ if (bits != null && bits.length != bv.width())
+ throw new IllegalArgumentException(format("BitVector width does not match: %d and %d", bits.length, bv.width()));
}
}
/**
* Does test for equality of values/content, shifting the other BitVector by <code>offset</code> to the right.<br>
- * Therefore <code>offset + other.length() <= this.length()</code> needs to be true.
+ * Therefore <code>offset + other.width() <= this.wdith()</code> needs to be true.
*
- * @throws ArrayIndexOutOfBoundsException if <code>offset + other.length() > this.length()</code>
+ * @throws ArrayIndexOutOfBoundsException if <code>offset + other.width() > this.width()</code>
*
* @see Object#equals(Object)
*/
{
if (other == null)
return false;
- return Arrays.equals(bits, offset, offset + other.length(), other.bits, 0, other.length());
+ return Arrays.equals(bits, offset, offset + other.width(), other.bits, 0, other.width());
}
/**
@Override
public boolean hasNext()
{
- return pos != length();
+ return pos != width();
}
};
}
public static ColorDefinition formatAsColor(BitVector bitVector)
{
// TODO maybe find a color assignment for multiple-bit bit vectors?
- if (bitVector == null || bitVector.length() != 1)
+ if (bitVector == null || bitVector.width() != 1)
return new ColorDefinition(BuiltInColor.COLOR_BLACK);
switch (bitVector.getLSBit(0))
{
public void feedSignals(BitVector newValues)
{
- if (newValues.length() != width)
+ if (newValues.width() != width)
throw new IllegalArgumentException(
- String.format("Attempted to input %d bits instead of %d bits.", newValues.length(), width));
+ String.format("Attempted to input %d bits instead of %d bits.", newValues.width(), 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.length());
+ System.arraycopy(newValues.getBits(), 0, vals, startingBit, newValues.width());
inputValues = BitVector.of(vals);
Wire.this.recalculate();
}
* Fuses the selected bits of two wires together. If the bits change in one Wire, the other is changed accordingly immediately. Warning:
* The bits are permanently fused together.
*
- * @param a The {@link Wire} to be (partially) fused with b
- * @param b The {@link Wire} to be (partially) fused with a
- * @param fromA The first bit of {@link Wire} a to be fused
- * @param fromB The first bit of {@link Wire} b to be fused
- * @param length The amount of bits to fuse
+ * @param a The {@link Wire} to be (partially) fused with b
+ * @param b The {@link Wire} to be (partially) fused with a
+ * @param fromA The first bit of {@link Wire} a to be fused
+ * @param fromB The first bit of {@link Wire} b to be fused
+ * @param width The amount of bits to fuse
*/
- public static void fuse(Wire a, Wire b, int fromA, int fromB, int length)
+ public static void fuse(Wire a, Wire b, int fromA, int fromB, int width)
{
ReadWriteEnd rA = a.createReadWriteEnd(), rB = b.createReadWriteEnd();
rA.setWriting(false);
rB.setWriting(false);
rA.setValues(BitVector.of(Bit.Z, a.width));
rB.setValues(BitVector.of(Bit.Z, b.width));
- Fusion aF = new Fusion(rB, fromA, fromB, length), bF = new Fusion(rA, fromB, fromA, length);
+ Fusion aF = new Fusion(rB, fromA, fromB, width), bF = new Fusion(rA, fromB, fromA, width);
rA.registerObserver(aF);
rB.registerObserver(bF);
aF.update(rA);
private static class Fusion implements LogicObserver
{
private ReadWriteEnd target;
- int fromSource, fromTarget, length;
+ int fromSource, fromTarget, width;
- public Fusion(ReadWriteEnd target, int fromSource, int fromTarget, int length)
+ public Fusion(ReadWriteEnd target, int fromSource, int fromTarget, int width)
{
this.target = target;
this.fromSource = fromSource;
this.fromTarget = fromTarget;
- this.length = length;
+ this.width = width;
}
@Override
else
{
target.setWriting(true);
- BitVector targetInput = source.wireValuesExcludingMe().subVector(fromSource, fromSource + length);
+ BitVector targetInput = source.wireValuesExcludingMe().subVector(fromSource, fromSource + width);
target.setValues(fromTarget, targetInput);
}
}
assertEquals(SINGLE_U, SINGLE_0.join(SINGLE_U));
assertEquals(SINGLE_X, SINGLE_X.join(SINGLE_Z));
- // higher length
+ // higher width
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 length
+ // higher width
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 length
+ // higher width
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 length
+ // higher width
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 length
+ // higher width
var result = BitVector.of(U, X, ZERO, ONE, Z).not();
assertEquals(BitVector.of(U, X, ONE, ZERO, X), result);
}
@Test
- void testLength()
+ void testWidth()
{
- assertEquals(0, BitVector.of().length());
- assertEquals(1, SINGLE_0.length());
- assertEquals(3, BitVector.of(X, X, Z).length());
+ assertEquals(0, BitVector.of().width());
+ assertEquals(1, SINGLE_0.width());
+ assertEquals(3, BitVector.of(X, X, Z).width());
}
@Test
"q3",
"q4"
],
- "vectorPartLengthes": [
+ "vectorPartWidths": [
1,
1,
1,
"q3",
"q4"
],
- "vectorPartLengthes": [
+ "vectorPartWidths": [
1,
1,
1,
"q3",
"q4"
],
- "vectorPartLengthes": [
+ "vectorPartWidths": [
1,
1,
1,
"c01.q",
"c00.q"
],
- "vectorPartLengthes": [
+ "vectorPartWidths": [
4,
4,
4,
"c01.q",
"c00.q"
],
- "vectorPartLengthes": [
+ "vectorPartWidths": [
16,
16,
16,
return sb.reverse().toString();
}
- public static BitVector of(int value, int length)
+ public static BitVector of(int value, int width)
{
- BitVectorMutator mutator = BitVectorMutator.ofLength(length);
+ BitVectorMutator mutator = BitVectorMutator.ofWidth(width);
int val = value;
- for (int i = length - 1; i >= 0; i--)
+ for (int i = width - 1; i >= 0; i--)
{
mutator.setMSBit(i, Bit.lastBitOf(val));
val >>>= 1;
"q3",
"q4"
],
- "vectorPartLengthes": [
+ "vectorPartWidths": [
1,
1,
1,
"q3",
"q4"
],
- "vectorPartLengthes": [
+ "vectorPartWidths": [
1,
1,
1,
"q3",
"q4"
],
- "vectorPartLengthes": [
+ "vectorPartWidths": [
1,
1,
1,
"c01.q",
"c00.q"
],
- "vectorPartLengthes": [
+ "vectorPartWidths": [
4,
4,
4,
"c01.q",
"c00.q"
],
- "vectorPartLengthes": [
+ "vectorPartWidths": [
16,
16,
16,
{
private SubmodelComponent component;
private final List<String> vectorPartTargets;
- private final List<Integer> vectorPartLengthes;
- private int length;
+ private final List<Integer> vectorPartWidths;
+ private int width;
public BitVectorSplittingAtomicHighLevelStateHandler(HighLevelStateHandlerContext context)
{
{
this.component = context.component;
this.vectorPartTargets = new ArrayList<>();
- this.vectorPartLengthes = new ArrayList<>();
+ this.vectorPartWidths = new ArrayList<>();
if (params != null)
- setVectorParts(params.vectorPartTargets, params.vectorPartLengthes);
+ setVectorParts(params.vectorPartTargets, params.vectorPartWidths);
}
- public void set(List<String> targets, List<Integer> lengthes)
+ public void set(List<String> targets, List<Integer> widths)
{
- setVectorParts(targets, lengthes);
+ setVectorParts(targets, widths);
}
- public void addVectorPart(String target, int length)
+ public void addVectorPart(String target, int width)
{
vectorPartTargets.add(target);
- vectorPartLengthes.add(length);
- this.length += length;
+ vectorPartWidths.add(width);
+ this.width += width;
}
public void clearVectorParts()
{
vectorPartTargets.clear();
- vectorPartLengthes.clear();
- length = 0;
+ vectorPartWidths.clear();
+ width = 0;
}
- private void setVectorParts(List<String> targets, List<Integer> lengthes)
+ private void setVectorParts(List<String> targets, List<Integer> widths)
{
clearVectorParts();
- if (targets.size() != lengthes.size())
- throw new IllegalArgumentException("Targets list and lenghtes list have different sizes");
+ if (targets.size() != widths.size())
+ throw new IllegalArgumentException("Targets list and widths list have different sizes");
vectorPartTargets.addAll(targets);
- vectorPartLengthes.addAll(lengthes);
- length += lengthes.stream().mapToInt(Integer::intValue).sum();
+ vectorPartWidths.addAll(widths);
+ width += widths.stream().mapToInt(Integer::intValue).sum();
}
@Override
vectorPart = BitVector.of((Bit) subStateUncasted);
else
vectorPart = (BitVector) subStateUncasted;
- if (vectorPart.length() != vectorPartLengthes.get(partIndex))
+ if (vectorPart.width() != vectorPartWidths.get(partIndex))
throw new IllegalArgumentException(
- "Incorrect vector part length: " + vectorPart.length() + "; expected " + vectorPartLengthes.get(partIndex));
+ "Incorrect vector part width: " + vectorPart.width() + "; expected " + vectorPartWidths.get(partIndex));
result = vectorPart.concat(result);
}
return result;
public void setHighLevelState(Object newState)
{
BitVector newStateCasted = (BitVector) newState;
- if (newStateCasted.length() != length)
- throw new IllegalArgumentException("Incorrect vector length: " + newStateCasted.length() + "; expected " + length);
+ if (newStateCasted.width() != width)
+ throw new IllegalArgumentException("Incorrect vector width: " + newStateCasted.width() + "; expected " + width);
for (int partIndex = vectorPartTargets.size() - 1, bitIndex = 0; partIndex >= 0; partIndex--)
{
- int vectorPartLength = vectorPartLengthes.get(partIndex);
- BitVector vectorPart = newStateCasted.subVector(bitIndex, bitIndex + vectorPartLength);
+ int vectorPartWidth = vectorPartWidths.get(partIndex);
+ BitVector vectorPart = newStateCasted.subVector(bitIndex, bitIndex + vectorPartWidth);
component.setHighLevelState(vectorPartTargets.get(partIndex), vectorPart);
- bitIndex += vectorPartLength;
+ bitIndex += vectorPartWidth;
}
}
{
BitVectorSplittingAtomicHighLevelStateHandlerParams params = new BitVectorSplittingAtomicHighLevelStateHandlerParams();
params.vectorPartTargets = new ArrayList<>(vectorPartTargets);
- params.vectorPartLengthes = new ArrayList<>(vectorPartLengthes);
+ params.vectorPartWidths = new ArrayList<>(vectorPartWidths);
return params;
}
public static class BitVectorSplittingAtomicHighLevelStateHandlerParams
{
public List<String> vectorPartTargets;
- public List<Integer> vectorPartLengthes;
+ public List<Integer> vectorPartWidths;
}
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.ofLength(size);
+ BitVectorMutator bvm = BitVectorMutator.ofWidth(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.ofLength(size);
+ BitVectorMutator bvm = BitVectorMutator.ofWidth(size);
for (int i = 0; i < size; i++)
bvm.setLSBit(i, Bit.of(bi.testBit(i)));
return bvm.toBitVector();
public void setCell(int index, BitVector bits)
{
- if (bits.length() != cellWidth)
+ if (bits.width() != cellWidth)
throw new IllegalArgumentException(String.format(
- "BitVector to be saved in memory cell has unexpected length. Expected: %d Actual: %d", cellWidth, bits.length()));
+ "BitVector to be saved in memory cell has unexpected width. Expected: %d Actual: %d", cellWidth, bits.width()));
memory[index] = bits;
}
import net.mograsim.machine.MainMemoryDefinition;
/**
- * A memory component that only allows access to words of a specific length
+ * A memory component that only allows access to words of a specific width
*/
public class WordAddressableMemoryComponent extends BasicComponent
{
projects / Mograsim.git / commitdiff