sealed class Vec[T <: Data] extends Aggregate with VecLike[T]
A vector (array) of Data elements. Provides hardware versions of various collection transformation functions found in software array implementations.
Careful consideration should be given over the use of Vec vs Seq or some other Scala collection. In general Vec only needs to be used when there is a need to express the hardware collection in a Reg or IO Bundle or when access to elements of the array is indexed via a hardware signal.
Example of indexing into a Vec using a hardware address and where the Vec is defined in an IO Bundle
val io = IO(new Bundle { val in = Input(Vec(20, UInt(16.W))) val addr = Input(UInt(5.W)) val out = Output(UInt(16.W)) }) io.out := io.in(io.addr)
- T
type of elements
- Note
- when multiple conflicting assignments are performed on a Vec element, the last one takes effect (unlike Mem, where the result is undefined)
- Vecs, unlike classes in Scala's collection library, are propagated intact to FIRRTL as a vector type, which may make debugging easier
- Alphabetic
- By Inheritance
- Vec
- VecLike
- IndexedSeq
- IndexedSeqLike
- Seq
- SeqLike
- GenSeq
- GenSeqLike
- Iterable
- IterableLike
- Equals
- GenIterable
- GenIterableLike
- Traversable
- GenTraversable
- GenericTraversableTemplate
- TraversableLike
- GenTraversableLike
- Parallelizable
- TraversableOnce
- GenTraversableOnce
- FilterMonadic
- HasNewBuilder
- PartialFunction
- Function1
- Aggregate
- Data
- SourceInfoDoc
- NamedComponent
- HasId
- InstanceId
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
class
Elements extends AbstractIterator[A] with BufferedIterator[A] with Serializable
- Attributes
- protected
- Definition Classes
- IndexedSeqLike
- Annotations
- @SerialVersionUID()
-
type
Self = IndexedSeq[T]
- Attributes
- protected[this]
- Definition Classes
- TraversableLike
-
class
WithFilter extends FilterMonadic[A, Repr]
- Definition Classes
- TraversableLike
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
def
++[B >: T, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
++:[B >: T, That](that: Traversable[B])(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
- Definition Classes
- TraversableLike
-
def
++:[B >: T, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
- Definition Classes
- TraversableLike
-
def
+:[B >: T, That](elem: B)(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
- Definition Classes
- SeqLike → GenSeqLike
-
def
:+[B >: T, That](elem: B)(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
- Definition Classes
- SeqLike → GenSeqLike
- def :=(that: Vec[T])(implicit sourceInfo: SourceInfo, moduleCompileOptions: CompileOptions): Unit
-
def
:=(that: Seq[T])(implicit sourceInfo: SourceInfo, moduleCompileOptions: CompileOptions): Unit
Strong bulk connect, assigning elements in this Vec from elements in a Seq.
Strong bulk connect, assigning elements in this Vec from elements in a Seq.
- Note
the length of this Vec must match the length of the input Seq
-
final
def
:=(that: ⇒ Data)(implicit sourceInfo: SourceInfo, connectionCompileOptions: CompileOptions): Unit
Connect this data to that data mono-directionally and element-wise.
Connect this data to that data mono-directionally and element-wise.
This uses the MonoConnect algorithm.
- that
the data to connect to
- Definition Classes
- Data
- def <>(that: Vec[T])(implicit sourceInfo: SourceInfo, moduleCompileOptions: CompileOptions): Unit
-
def
<>(that: Seq[T])(implicit sourceInfo: SourceInfo, moduleCompileOptions: CompileOptions): Unit
Strong bulk connect, assigning elements in this Vec from elements in a Seq.
Strong bulk connect, assigning elements in this Vec from elements in a Seq.
- Note
the length of this Vec must match the length of the input Seq
-
final
def
<>(that: ⇒ Data)(implicit sourceInfo: SourceInfo, connectionCompileOptions: CompileOptions): Unit
Connect this data to that data bi-directionally and element-wise.
Connect this data to that data bi-directionally and element-wise.
This uses the BiConnect algorithm.
- that
the data to connect to
- Definition Classes
- Data
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
addString(b: StringBuilder): StringBuilder
- Definition Classes
- TraversableOnce
-
def
addString(b: StringBuilder, sep: String): StringBuilder
- Definition Classes
- TraversableOnce
-
def
addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
- Definition Classes
- TraversableOnce
-
def
aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
andThen[C](k: (T) ⇒ C): PartialFunction[Int, C]
- Definition Classes
- PartialFunction → Function1
-
def
apply(idx: Int): T
Creates a statically indexed read or write accessor into the array.
Creates a statically indexed read or write accessor into the array.
- Definition Classes
- Vec → SeqLike → GenSeqLike → Function1
-
macro
def
apply(p: UInt): T
Creates a dynamically indexed read or write accessor into the array.
-
def
applyOrElse[A1 <: Int, B1 >: T](x: A1, default: (A1) ⇒ B1): B1
- Definition Classes
- PartialFunction
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
macro
def
asTypeOf[T <: Data](that: T): T
Does a reinterpret cast of the bits in this node into the format that provides.
Does a reinterpret cast of the bits in this node into the format that provides. Returns a new Wire of that type. Does not modify existing nodes.
x.asTypeOf(that) performs the inverse operation of x := that.toBits.
- Definition Classes
- Data
- Note
bit widths are NOT checked, may pad or drop bits from input
,that should have known widths
-
final macro
def
asUInt(): UInt
Reinterpret cast to UInt.
Reinterpret cast to UInt.
- Definition Classes
- Data
- Note
value not guaranteed to be preserved: for example, a SInt of width 3 and value -1 (0b111) would become an UInt with value 7
,Aggregates are recursively packed with the first element appearing in the least-significant bits of the result.
-
def
autoSeed(name: String): Vec.this.type
Takes the last seed suggested.
Takes the last seed suggested. Multiple calls to this function will take the last given seed, unless this HasId is a module port (see overridden method in Data.scala).
If the final computed name conflicts with the final name of another signal, the final name may get uniquified by appending a digit at the end of the name.
Is a lower priority than suggestName, in that regardless of whether autoSeed was called, suggestName will always take precedence if it was called.
- returns
this object
- Definition Classes
- Data → HasId
- def binding: Option[Binding]
-
def
bindingToString: String
- Attributes
- protected
- Definition Classes
- Data
-
def
binding_=(target: Binding): Unit
- Attributes
- protected
- Definition Classes
- Data
-
def
canEqual(that: Any): Boolean
- Definition Classes
- IterableLike → Equals
-
def
circuitName: String
- Attributes
- protected
- Definition Classes
- HasId
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
cloneType: Vec.this.type
Internal API; Chisel users should look at chisel3.chiselTypeOf(...).
-
def
collect[B, That](pf: PartialFunction[T, B])(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
collectFirst[B](pf: PartialFunction[T, B]): Option[B]
- Definition Classes
- TraversableOnce
-
def
combinations(n: Int): Iterator[IndexedSeq[T]]
- Definition Classes
- SeqLike
-
def
companion: GenericCompanion[IndexedSeq]
- Definition Classes
- IndexedSeq → Seq → GenSeq → Iterable → GenIterable → Traversable → GenTraversable → GenericTraversableTemplate
-
def
compose[A](g: (A) ⇒ Int): (A) ⇒ T
- Definition Classes
- Function1
- Annotations
- @unspecialized()
-
def
computeName(defaultPrefix: Option[String], defaultSeed: Option[String]): Option[String]
Computes the name of this HasId, if one exists
Computes the name of this HasId, if one exists
- defaultPrefix
Optionally provide a default prefix for computing the name
- defaultSeed
Optionally provide default seed for computing the name
- returns
the name, if it can be computed
- Definition Classes
- HasId
-
macro
def
contains(x: T)(implicit ev: <:<[T, UInt]): Bool
Outputs true if the vector contains at least one element equal to x (using the === operator).
Outputs true if the vector contains at least one element equal to x (using the === operator).
- Definition Classes
- VecLike
-
def
contains[A1 >: T](elem: A1): Boolean
- Definition Classes
- SeqLike
-
def
containsSlice[B](that: GenSeq[B]): Boolean
- Definition Classes
- SeqLike
-
def
copyToArray[B >: T](xs: Array[B], start: Int, len: Int): Unit
- Definition Classes
- IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
-
def
copyToArray[B >: T](xs: Array[B]): Unit
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
copyToArray[B >: T](xs: Array[B], start: Int): Unit
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
copyToBuffer[B >: T](dest: Buffer[B]): Unit
- Definition Classes
- TraversableOnce
-
def
corresponds[B](that: GenSeq[B])(p: (T, B) ⇒ Boolean): Boolean
- Definition Classes
- SeqLike → GenSeqLike
-
macro
def
count(p: (T) ⇒ Bool): UInt
Outputs the number of elements for which p is true.
Outputs the number of elements for which p is true.
- Definition Classes
- VecLike
-
def
count(p: (T) ⇒ Boolean): Int
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
diff[B >: T](that: GenSeq[B]): IndexedSeq[T]
- Definition Classes
- SeqLike → GenSeqLike
-
def
distinct: IndexedSeq[T]
- Definition Classes
- SeqLike → GenSeqLike
- def do_apply(p: UInt)(implicit compileOptions: CompileOptions): T
-
def
do_asTypeOf[T <: Data](that: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): T
- Definition Classes
- Data
- def do_asUInt(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): UInt
-
def
do_contains(x: T)(implicit sourceInfo: SourceInfo, ev: <:<[T, UInt], compileOptions: CompileOptions): Bool
- Definition Classes
- VecLike
-
def
do_count(p: (T) ⇒ Bool)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): UInt
- Definition Classes
- VecLike
-
def
do_exists(p: (T) ⇒ Bool)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): Bool
- Definition Classes
- VecLike
-
def
do_forall(p: (T) ⇒ Bool)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): Bool
- Definition Classes
- VecLike
-
def
do_indexWhere(p: (T) ⇒ Bool)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): UInt
- Definition Classes
- VecLike
-
def
do_lastIndexWhere(p: (T) ⇒ Bool)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): UInt
- Definition Classes
- VecLike
-
def
do_onlyIndexWhere(p: (T) ⇒ Bool)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): UInt
- Definition Classes
- VecLike
- def do_reduceTree(redOp: (T, T) ⇒ T, layerOp: (T) ⇒ T = (x: T) => x)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): T
-
def
drop(n: Int): IndexedSeq[T]
- Definition Classes
- IterableLike → TraversableLike → GenTraversableLike
-
def
dropRight(n: Int): IndexedSeq[T]
- Definition Classes
- IterableLike
-
def
dropWhile(p: (T) ⇒ Boolean): IndexedSeq[T]
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
endsWith[B](that: GenSeq[B]): Boolean
- Definition Classes
- SeqLike → GenSeqLike
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(that: Any): Boolean
- Definition Classes
- VecLike → HasId → GenSeqLike → Equals → AnyRef → Any
-
macro
def
exists(p: (T) ⇒ Bool): Bool
Outputs true if p outputs true for at least one element.
Outputs true if p outputs true for at least one element.
- Definition Classes
- VecLike
-
def
exists(p: (T) ⇒ Boolean): Boolean
- Definition Classes
- IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
-
def
filter(p: (T) ⇒ Boolean): IndexedSeq[T]
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
filterNot(p: (T) ⇒ Boolean): IndexedSeq[T]
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
find(p: (T) ⇒ Boolean): Option[T]
- Definition Classes
- IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
-
def
flatMap[B, That](f: (T) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
- Definition Classes
- TraversableLike → GenTraversableLike → FilterMonadic
-
def
flatten[B](implicit asTraversable: (T) ⇒ GenTraversableOnce[B]): IndexedSeq[B]
- Definition Classes
- GenericTraversableTemplate
-
def
fold[A1 >: T](z: A1)(op: (A1, A1) ⇒ A1): A1
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
foldLeft[B](z: B)(op: (B, T) ⇒ B): B
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
foldRight[B](z: B)(op: (T, B) ⇒ B): B
- Definition Classes
- IterableLike → TraversableOnce → GenTraversableOnce
-
macro
def
forall(p: (T) ⇒ Bool): Bool
Outputs true if p outputs true for every element.
Outputs true if p outputs true for every element.
- Definition Classes
- VecLike
-
def
forall(p: (T) ⇒ Boolean): Boolean
- Definition Classes
- IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
-
def
foreach[U](f: (T) ⇒ U): Unit
- Definition Classes
- IterableLike → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic
-
def
genericBuilder[B]: Builder[B, IndexedSeq[B]]
- Definition Classes
- GenericTraversableTemplate
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
getElements: Seq[Data]
Returns a Seq of the immediate contents of this Aggregate, in order.
-
final
def
getWidth: Int
Returns the width, in bits, if currently known.
Returns the width, in bits, if currently known.
- Definition Classes
- Data
-
def
groupBy[K](f: (T) ⇒ K): Map[K, IndexedSeq[T]]
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
grouped(size: Int): Iterator[IndexedSeq[T]]
- Definition Classes
- IterableLike
-
def
hasDefiniteSize: Boolean
- Definition Classes
- TraversableLike → TraversableOnce → GenTraversableOnce
-
def
hasSeed: Boolean
- returns
Whether either autoName or suggestName has been called
- Definition Classes
- HasId
-
def
hashCode(): Int
- Definition Classes
- VecLike → HasId → IndexedSeqLike → GenSeqLike → AnyRef → Any
-
def
head: T
- Definition Classes
- IterableLike → TraversableLike → GenTraversableLike
-
def
headOption: Option[T]
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
indexOf[B >: T](elem: B, from: Int): Int
- Definition Classes
- GenSeqLike
-
def
indexOf[B >: T](elem: B): Int
- Definition Classes
- GenSeqLike
-
def
indexOfSlice[B >: T](that: GenSeq[B], from: Int): Int
- Definition Classes
- SeqLike
-
def
indexOfSlice[B >: T](that: GenSeq[B]): Int
- Definition Classes
- SeqLike
-
macro
def
indexWhere(p: (T) ⇒ Bool): UInt
Outputs the index of the first element for which p outputs true.
Outputs the index of the first element for which p outputs true.
- Definition Classes
- VecLike
-
def
indexWhere(p: (T) ⇒ Boolean, from: Int): Int
- Definition Classes
- SeqLike → GenSeqLike
-
def
indexWhere(p: (T) ⇒ Boolean): Int
- Definition Classes
- GenSeqLike
-
def
indices: Range
- Definition Classes
- SeqLike
-
def
init: IndexedSeq[T]
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
inits: Iterator[IndexedSeq[T]]
- Definition Classes
- TraversableLike
-
def
instanceName: String
- Definition Classes
- HasId → InstanceId
-
def
intersect[B >: T](that: GenSeq[B]): IndexedSeq[T]
- Definition Classes
- SeqLike → GenSeqLike
-
def
isDefinedAt(idx: Int): Boolean
- Definition Classes
- GenSeqLike
-
def
isEmpty: Boolean
- Definition Classes
- SeqLike → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
isLit(): Boolean
- Definition Classes
- Data
-
final
def
isTraversableAgain: Boolean
- Definition Classes
- TraversableLike → GenTraversableLike → GenTraversableOnce
-
final
def
isWidthKnown: Boolean
Returns whether the width is currently known.
Returns whether the width is currently known.
- Definition Classes
- Data
-
def
iterator: Iterator[T]
- Definition Classes
- IndexedSeqLike → IterableLike → GenIterableLike
-
def
last: T
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
lastIndexOf[B >: T](elem: B, end: Int): Int
- Definition Classes
- GenSeqLike
-
def
lastIndexOf[B >: T](elem: B): Int
- Definition Classes
- GenSeqLike
-
def
lastIndexOfSlice[B >: T](that: GenSeq[B], end: Int): Int
- Definition Classes
- SeqLike
-
def
lastIndexOfSlice[B >: T](that: GenSeq[B]): Int
- Definition Classes
- SeqLike
-
macro
def
lastIndexWhere(p: (T) ⇒ Bool): UInt
Outputs the index of the last element for which p outputs true.
Outputs the index of the last element for which p outputs true.
- Definition Classes
- VecLike
-
def
lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int
- Definition Classes
- SeqLike → GenSeqLike
-
def
lastIndexWhere(p: (T) ⇒ Boolean): Int
- Definition Classes
- GenSeqLike
-
def
lastOption: Option[T]
- Definition Classes
- TraversableLike → GenTraversableLike
-
val
length: Int
- Definition Classes
- Vec → SeqLike → GenSeqLike
-
def
lengthCompare(len: Int): Int
- Definition Classes
- SeqLike
-
def
lift: (Int) ⇒ Option[T]
- Definition Classes
- PartialFunction
-
def
litOption(): Option[BigInt]
Return an Aggregate's literal value if it is a literal, None otherwise.
-
def
litValue(): BigInt
Returns the literal value if this is a literal that is representable as bits, otherwise crashes.
Returns the literal value if this is a literal that is representable as bits, otherwise crashes.
- Definition Classes
- Data
-
def
map[B, That](f: (T) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
- Definition Classes
- TraversableLike → GenTraversableLike → FilterMonadic
-
def
max[B >: T](implicit cmp: Ordering[B]): T
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
maxBy[B](f: (T) ⇒ B)(implicit cmp: Ordering[B]): T
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
min[B >: T](implicit cmp: Ordering[B]): T
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
minBy[B](f: (T) ⇒ B)(implicit cmp: Ordering[B]): T
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
mkString: String
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
mkString(sep: String): String
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
mkString(start: String, sep: String, end: String): String
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
newBuilder: Builder[T, IndexedSeq[T]]
- Attributes
- protected[this]
- Definition Classes
- GenericTraversableTemplate → HasNewBuilder
-
def
nonEmpty: Boolean
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
macro
def
onlyIndexWhere(p: (T) ⇒ Bool): UInt
Outputs the index of the element for which p outputs true, assuming that the there is exactly one such element.
Outputs the index of the element for which p outputs true, assuming that the there is exactly one such element.
The implementation may be more efficient than a priority mux, but incorrect results are possible if there is not exactly one true element.
- Definition Classes
- VecLike
- Note
the assumption that there is only one element for which p outputs true is NOT checked (useful in cases where the condition doesn't always hold, but the results are not used in those cases)
-
def
orElse[A1 <: Int, B1 >: T](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
- Definition Classes
- PartialFunction
-
def
padTo[B >: T, That](len: Int, elem: B)(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
- Definition Classes
- SeqLike → GenSeqLike
-
def
par: ParSeq[T]
- Definition Classes
- Parallelizable
-
def
parCombiner: Combiner[T, ParSeq[T]]
- Attributes
- protected[this]
- Definition Classes
- SeqLike → TraversableLike → Parallelizable
-
def
parentModName: String
- Definition Classes
- HasId → InstanceId
-
def
parentPathName: String
- Definition Classes
- HasId → InstanceId
-
def
partition(p: (T) ⇒ Boolean): (IndexedSeq[T], IndexedSeq[T])
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
patch[B >: T, That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
- Definition Classes
- SeqLike → GenSeqLike
-
def
pathName: String
- Definition Classes
- HasId → InstanceId
-
def
permutations: Iterator[IndexedSeq[T]]
- Definition Classes
- SeqLike
-
def
prefixLength(p: (T) ⇒ Boolean): Int
- Definition Classes
- GenSeqLike
-
def
product[B >: T](implicit num: Numeric[B]): B
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
reduce[A1 >: T](op: (A1, A1) ⇒ A1): A1
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
reduceLeft[B >: T](op: (B, T) ⇒ B): B
- Definition Classes
- TraversableOnce
-
def
reduceLeftOption[B >: T](op: (B, T) ⇒ B): Option[B]
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
reduceOption[A1 >: T](op: (A1, A1) ⇒ A1): Option[A1]
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
reduceRight[B >: T](op: (T, B) ⇒ B): B
- Definition Classes
- IterableLike → TraversableOnce → GenTraversableOnce
-
def
reduceRightOption[B >: T](op: (T, B) ⇒ B): Option[B]
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
macro
def
reduceTree(redOp: (T, T) ⇒ T, layerOp: (T) ⇒ T): T
A reduce operation in a tree like structure instead of sequentially
A reduce operation in a tree like structure instead of sequentially
A pipelined adder tree
val sumOut = inputNums.reduceTree( (a: T, b: T) => RegNext(a + b), (a: T) => RegNext(a) )
Example: -
macro
def
reduceTree(redOp: (T, T) ⇒ T): T
A reduce operation in a tree like structure instead of sequentially
A reduce operation in a tree like structure instead of sequentially
An adder tree
val sumOut = inputNums.reduceTree((a: T, b: T) => (a + b))
Example: -
def
repr: IndexedSeq[T]
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
reverse: IndexedSeq[T]
- Definition Classes
- SeqLike → GenSeqLike
-
def
reverseIterator: Iterator[T]
- Definition Classes
- SeqLike
-
def
reverseMap[B, That](f: (T) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
- Definition Classes
- SeqLike → GenSeqLike
-
def
reversed: List[T]
- Attributes
- protected[this]
- Definition Classes
- TraversableOnce
-
def
runWith[U](action: (T) ⇒ U): (Int) ⇒ Boolean
- Definition Classes
- PartialFunction
-
def
sameElements[B >: T](that: GenIterable[B]): Boolean
- Definition Classes
- IterableLike → GenIterableLike
-
def
scan[B >: T, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[IndexedSeq[T], B, That]): That
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
scanLeft[B, That](z: B)(op: (B, T) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
scanRight[B, That](z: B)(op: (T, B) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
- Definition Classes
- TraversableLike → GenTraversableLike
- Annotations
- @migration
- Migration
(Changed in version 2.9.0) The behavior of
scanRight
has changed. The previous behavior can be reproduced with scanRight.reverse.
-
def
segmentLength(p: (T) ⇒ Boolean, from: Int): Int
- Definition Classes
- SeqLike → GenSeqLike
-
def
seq: IndexedSeq[T]
- Definition Classes
- IndexedSeq → IndexedSeqLike → Seq → GenSeq → GenSeqLike → Iterable → GenIterable → Traversable → GenTraversable → Parallelizable → TraversableOnce → GenTraversableOnce
-
def
size: Int
- Definition Classes
- SeqLike → GenTraversableLike → TraversableOnce → GenTraversableOnce
-
def
sizeHintIfCheap: Int
- Attributes
- protected[collection]
- Definition Classes
- IndexedSeqLike → GenTraversableOnce
-
def
slice(from: Int, until: Int): IndexedSeq[T]
- Definition Classes
- IterableLike → TraversableLike → GenTraversableLike
-
def
sliding(size: Int, step: Int): Iterator[IndexedSeq[T]]
- Definition Classes
- IterableLike
-
def
sliding(size: Int): Iterator[IndexedSeq[T]]
- Definition Classes
- IterableLike
-
def
sortBy[B](f: (T) ⇒ B)(implicit ord: Ordering[B]): IndexedSeq[T]
- Definition Classes
- SeqLike
-
def
sortWith(lt: (T, T) ⇒ Boolean): IndexedSeq[T]
- Definition Classes
- SeqLike
-
def
sorted[B >: T](implicit ord: Ordering[B]): IndexedSeq[T]
- Definition Classes
- SeqLike
-
def
span(p: (T) ⇒ Boolean): (IndexedSeq[T], IndexedSeq[T])
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
splitAt(n: Int): (IndexedSeq[T], IndexedSeq[T])
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
startsWith[B](that: GenSeq[B], offset: Int): Boolean
- Definition Classes
- SeqLike → GenSeqLike
-
def
startsWith[B](that: GenSeq[B]): Boolean
- Definition Classes
- GenSeqLike
-
def
stringPrefix: String
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
suggestName(seed: ⇒ String): Vec.this.type
Takes the first seed suggested.
Takes the first seed suggested. Multiple calls to this function will be ignored. If the final computed name conflicts with another name, it may get uniquified by appending a digit at the end.
Is a higher priority than autoSeed, in that regardless of whether autoSeed was called, suggestName will always take precedence.
- seed
The seed for the name of this component
- returns
this object
- Definition Classes
- HasId
-
def
sum[B >: T](implicit num: Numeric[B]): B
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
tail: IndexedSeq[T]
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
tails: Iterator[IndexedSeq[T]]
- Definition Classes
- TraversableLike
-
def
take(n: Int): IndexedSeq[T]
- Definition Classes
- IterableLike → TraversableLike → GenTraversableLike
-
def
takeRight(n: Int): IndexedSeq[T]
- Definition Classes
- IterableLike
-
def
takeWhile(p: (T) ⇒ Boolean): IndexedSeq[T]
- Definition Classes
- IterableLike → TraversableLike → GenTraversableLike
-
def
thisCollection: IndexedSeq[T]
- Attributes
- protected[this]
- Definition Classes
- IndexedSeqLike → SeqLike → IterableLike → TraversableLike
-
def
to[Col[_]](implicit cbf: CanBuildFrom[Nothing, T, Col[T]]): Col[T]
- Definition Classes
- TraversableLike → TraversableOnce → GenTraversableOnce
-
final
def
toAbsoluteTarget: ReferenceTarget
Returns a FIRRTL IsMember that refers to the absolute path to this object in the elaborated hardware graph
Returns a FIRRTL IsMember that refers to the absolute path to this object in the elaborated hardware graph
- Definition Classes
- NamedComponent → InstanceId
-
def
toArray[B >: T](implicit arg0: ClassTag[B]): Array[B]
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
toBuffer[A1 >: T]: Buffer[A1]
- Definition Classes
- IndexedSeqLike → TraversableOnce → GenTraversableOnce
-
def
toCollection(repr: IndexedSeq[T]): IndexedSeq[T]
- Attributes
- protected[this]
- Definition Classes
- IndexedSeqLike → SeqLike → IterableLike → TraversableLike
-
def
toIndexedSeq: IndexedSeq[T]
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
toIterable: Iterable[T]
- Definition Classes
- IterableLike → TraversableOnce → GenTraversableOnce
-
def
toIterator: Iterator[T]
- Definition Classes
- IterableLike → TraversableLike → GenTraversableOnce
- Annotations
- @deprecatedOverriding( ... , "2.11.0" )
-
def
toList: List[T]
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
toMap[T, U](implicit ev: <:<[T, (T, U)]): Map[T, U]
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
final
def
toNamed: ComponentName
Returns a FIRRTL ComponentName that references this object
Returns a FIRRTL ComponentName that references this object
- Definition Classes
- NamedComponent → InstanceId
- Note
Should not be called until circuit elaboration is complete
-
def
toPrintable: Printable
Default "pretty-print" implementation Analogous to printing a Seq Results in "Vec(elt0, elt1, ...)"
-
def
toSeq: Seq[T]
- Definition Classes
- SeqLike → GenSeqLike → TraversableOnce → GenTraversableOnce
-
def
toSet[B >: T]: Set[B]
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
toStream: Stream[T]
- Definition Classes
- IterableLike → TraversableLike → GenTraversableOnce
-
def
toString(): String
- Definition Classes
- Vec → SeqLike → TraversableLike → Function1 → AnyRef → Any
-
final
def
toTarget: ReferenceTarget
Returns a FIRRTL ReferenceTarget that references this object
Returns a FIRRTL ReferenceTarget that references this object
- Definition Classes
- NamedComponent → InstanceId
- Note
Should not be called until circuit elaboration is complete
-
def
toTraversable: Traversable[T]
- Definition Classes
- TraversableLike → TraversableOnce → GenTraversableOnce
- Annotations
- @deprecatedOverriding( ... , "2.11.0" )
-
def
toVector: Vector[T]
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
transpose[B](implicit asTraversable: (T) ⇒ GenTraversableOnce[B]): IndexedSeq[IndexedSeq[B]]
- Definition Classes
- GenericTraversableTemplate
- Annotations
- @migration
- Migration
(Changed in version 2.9.0)
transpose
throws anIllegalArgumentException
if collections are not uniformly sized.
-
def
union[B >: T, That](that: GenSeq[B])(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
- Definition Classes
- SeqLike → GenSeqLike
-
def
unzip[A1, A2](implicit asPair: (T) ⇒ (A1, A2)): (IndexedSeq[A1], IndexedSeq[A2])
- Definition Classes
- GenericTraversableTemplate
-
def
unzip3[A1, A2, A3](implicit asTriple: (T) ⇒ (A1, A2, A3)): (IndexedSeq[A1], IndexedSeq[A2], IndexedSeq[A3])
- Definition Classes
- GenericTraversableTemplate
-
def
updated[B >: T, That](index: Int, elem: B)(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
- Definition Classes
- SeqLike → GenSeqLike
-
def
view(from: Int, until: Int): SeqView[T, IndexedSeq[T]]
- Definition Classes
- SeqLike → IterableLike → TraversableLike
-
def
view: SeqView[T, IndexedSeq[T]]
- Definition Classes
- SeqLike → IterableLike → TraversableLike
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
final
def
widthOption: Option[Int]
Returns Some(width) if the width is known, else None.
Returns Some(width) if the width is known, else None.
- Definition Classes
- Data
-
def
withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, IndexedSeq[T]]
- Definition Classes
- TraversableLike → FilterMonadic
-
def
zip[A1 >: T, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[IndexedSeq[T], (A1, B), That]): That
- Definition Classes
- IterableLike → GenIterableLike
-
def
zipAll[B, A1 >: T, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[IndexedSeq[T], (A1, B), That]): That
- Definition Classes
- IterableLike → GenIterableLike
-
def
zipWithIndex[A1 >: T, That](implicit bf: CanBuildFrom[IndexedSeq[T], (A1, Int), That]): That
- Definition Classes
- IterableLike → GenIterableLike
Deprecated Value Members
-
def
/:[B](z: B)(op: (B, T) ⇒ B): B
- Definition Classes
- TraversableOnce → GenTraversableOnce
- Annotations
- @deprecated
- Deprecated
(Since version 2.12.10) Use foldLeft instead of /:
-
def
:\[B](z: B)(op: (T, B) ⇒ B): B
- Definition Classes
- TraversableOnce → GenTraversableOnce
- Annotations
- @deprecated
- Deprecated
(Since version 2.12.10) Use foldRight instead of :\
-
def
litArg(): Option[LitArg]
- Definition Classes
- Data
- Annotations
- @deprecated
- Deprecated
(Since version 3.2) litArg is deprecated, use litOption or litTo*Option
Inherited from VecLike[T]
Inherited from IndexedSeq[T]
Inherited from IndexedSeqLike[T, IndexedSeq[T]]
Inherited from Seq[T]
Inherited from SeqLike[T, IndexedSeq[T]]
Inherited from GenSeq[T]
Inherited from GenSeqLike[T, IndexedSeq[T]]
Inherited from Iterable[T]
Inherited from IterableLike[T, IndexedSeq[T]]
Inherited from Equals
Inherited from GenIterable[T]
Inherited from GenIterableLike[T, IndexedSeq[T]]
Inherited from Traversable[T]
Inherited from GenTraversable[T]
Inherited from GenericTraversableTemplate[T, IndexedSeq]
Inherited from TraversableLike[T, IndexedSeq[T]]
Inherited from GenTraversableLike[T, IndexedSeq[T]]
Inherited from Parallelizable[T, ParSeq[T]]
Inherited from TraversableOnce[T]
Inherited from GenTraversableOnce[T]
Inherited from FilterMonadic[T, IndexedSeq[T]]
Inherited from HasNewBuilder[T, IndexedSeq[T] @scala.annotation.unchecked.uncheckedVariance]
Inherited from PartialFunction[Int, T]
Inherited from (Int) ⇒ T
Inherited from Aggregate
Inherited from Data
Inherited from SourceInfoDoc
Inherited from NamedComponent
Inherited from HasId
Inherited from internal.InstanceId
Inherited from AnyRef
Inherited from Any
Connect
Utilities for connecting hardware components