sealed
class
Vec[T <: Data] extends Aggregate with VecLike[T]
Value Members
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
-
def
++:[B >: T, That](that: Traversable[B])(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
-
-
def
+:[B >: T, That](elem: B)(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
-
def
/:[B](z: B)(op: (B, T) ⇒ B): B
-
def
:+[B >: T, That](elem: B)(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
-
def
:=(that: Vec[T])(implicit sourceInfo: SourceInfo, moduleCompileOptions: CompileOptions): Unit
-
def
:=(that: Seq[T])(implicit sourceInfo: SourceInfo, moduleCompileOptions: CompileOptions): Unit
-
final
def
:=(that: Data)(implicit sourceInfo: SourceInfo, connectionCompileOptions: CompileOptions): Unit
-
def
:\[B](z: B)(op: (T, B) ⇒ B): B
-
def
<>(that: Vec[T])(implicit sourceInfo: SourceInfo, moduleCompileOptions: CompileOptions): Unit
-
def
<>(that: Seq[T])(implicit sourceInfo: SourceInfo, moduleCompileOptions: CompileOptions): Unit
-
final
def
<>(that: Data)(implicit sourceInfo: SourceInfo, connectionCompileOptions: CompileOptions): Unit
-
final
def
==(arg0: Any): Boolean
-
def
addString(b: StringBuilder): StringBuilder
-
def
addString(b: StringBuilder, sep: String): StringBuilder
-
def
addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
-
def
aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B
-
-
def
apply(idx: Int): T
-
macro
def
apply(p: UInt): T
-
def
applyOrElse[A1 <: Int, B1 >: T](x: A1, default: (A1) ⇒ B1): B1
-
final
def
asInstanceOf[T0]: T0
-
macro
def
asTypeOf[T <: Data](that: T): T
-
final macro
def
asUInt(): UInt
-
def
canEqual(that: Any): Boolean
-
def
chiselCloneType(implicit compileOptions: CompileOptions): Vec.this.type
-
def
clone(): AnyRef
-
def
cloneType: Vec.this.type
-
-
-
-
-
def
compose[A](g: (A) ⇒ Int): (A) ⇒ T
-
macro
def
contains(x: T)(implicit ev: <:<[T, UInt]): Bool
-
def
contains[A1 >: T](elem: A1): Boolean
-
def
containsSlice[B](that: GenSeq[B]): Boolean
-
def
copyToArray[B >: T](xs: Array[B], start: Int, len: Int): Unit
-
def
copyToArray[B >: T](xs: Array[B]): Unit
-
def
copyToArray[B >: T](xs: Array[B], start: Int): Unit
-
def
copyToBuffer[B >: T](dest: Buffer[B]): Unit
-
def
corresponds[B](that: GenSeq[B])(p: (T, B) ⇒ Boolean): Boolean
-
macro
def
count(p: (T) ⇒ Bool): UInt
-
def
count(p: (T) ⇒ Boolean): Int
-
-
-
def
do_apply(p: UInt)(implicit compileOptions: CompileOptions): T
-
def
do_asTypeOf[T <: Data](that: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): T
-
-
def
do_contains(x: T)(implicit sourceInfo: SourceInfo, ev: <:<[T, UInt], compileOptions: CompileOptions): Bool
-
def
do_count(p: (T) ⇒ Bool)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): UInt
-
def
do_exists(p: (T) ⇒ Bool)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): Bool
-
def
do_forall(p: (T) ⇒ Bool)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): Bool
-
def
do_indexWhere(p: (T) ⇒ Bool)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): UInt
-
def
do_lastIndexWhere(p: (T) ⇒ Bool)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): UInt
-
def
do_onlyIndexWhere(p: (T) ⇒ Bool)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): UInt
-
-
-
-
def
endsWith[B](that: GenSeq[B]): Boolean
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equals(that: Any): Boolean
-
macro
def
exists(p: (T) ⇒ Bool): Bool
-
-
-
-
def
finalize(): Unit
-
-
-
-
def
fold[A1 >: T](z: A1)(op: (A1, A1) ⇒ A1): A1
-
def
foldLeft[B](z: B)(op: (B, T) ⇒ B): B
-
def
foldRight[B](z: B)(op: (T, B) ⇒ B): B
-
macro
def
forall(p: (T) ⇒ Bool): Bool
-
-
def
foreach[U](f: (T) ⇒ U): Unit
-
-
final
def
getClass(): Class[_]
-
def
getElements: Seq[Data]
-
final
def
getWidth: Int
-
def
groupBy[K](f: (T) ⇒ K): Map[K, IndexedSeq[T]]
-
-
def
hasDefiniteSize: Boolean
-
def
hashCode(): Int
-
def
head: T
-
def
headOption: Option[T]
-
def
indexOf[B >: T](elem: B, from: Int): Int
-
def
indexOf[B >: T](elem: B): Int
-
def
indexOfSlice[B >: T](that: GenSeq[B], from: Int): Int
-
def
indexOfSlice[B >: T](that: GenSeq[B]): Int
-
macro
def
indexWhere(p: (T) ⇒ Bool): UInt
-
def
indexWhere(p: (T) ⇒ Boolean, from: Int): Int
-
def
indexWhere(p: (T) ⇒ Boolean): Int
-
def
indices: Range
-
-
-
def
instanceName: String
-
def
intersect[B >: T](that: GenSeq[B]): IndexedSeq[T]
-
def
isDefinedAt(idx: Int): Boolean
-
-
final
def
isInstanceOf[T0]: Boolean
-
-
final
def
isTraversableAgain: Boolean
-
final
def
isWidthKnown: Boolean
-
def
iterator: Iterator[T]
-
def
last: T
-
def
lastIndexOf[B >: T](elem: B, end: Int): Int
-
def
lastIndexOf[B >: T](elem: B): Int
-
def
lastIndexOfSlice[B >: T](that: GenSeq[B], end: Int): Int
-
def
lastIndexOfSlice[B >: T](that: GenSeq[B]): Int
-
macro
def
lastIndexWhere(p: (T) ⇒ Bool): UInt
-
def
lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int
-
def
lastIndexWhere(p: (T) ⇒ Boolean): Int
-
def
lastOption: Option[T]
-
val
length: Int
-
def
lengthCompare(len: Int): Int
-
-
-
def
litValue(): BigInt
-
def
map[B, That](f: (T) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
-
def
max[B >: T](implicit cmp: Ordering[B]): T
-
def
maxBy[B](f: (T) ⇒ B)(implicit cmp: Ordering[B]): T
-
def
min[B >: T](implicit cmp: Ordering[B]): T
-
def
minBy[B](f: (T) ⇒ B)(implicit cmp: Ordering[B]): T
-
def
mkString: String
-
def
mkString(sep: String): String
-
def
mkString(start: String, sep: String, end: String): String
-
final
def
ne(arg0: AnyRef): Boolean
-
-
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
macro
def
onlyIndexWhere(p: (T) ⇒ Bool): UInt
-
-
def
padTo[B >: T, That](len: Int, elem: B)(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
-
-
def
parCombiner: Combiner[T, ParSeq[T]]
-
def
parentModName: String
-
def
parentPathName: String
-
-
def
patch[B >: T, That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
-
def
pathName: String
-
-
def
prefixLength(p: (T) ⇒ Boolean): Int
-
def
product[B >: T](implicit num: Numeric[B]): B
-
def
reduce[A1 >: T](op: (A1, A1) ⇒ A1): A1
-
def
reduceLeft[B >: T](op: (B, T) ⇒ B): B
-
def
reduceLeftOption[B >: T](op: (B, T) ⇒ B): Option[B]
-
def
reduceOption[A1 >: T](op: (A1, A1) ⇒ A1): Option[A1]
-
def
reduceRight[B >: T](op: (T, B) ⇒ B): B
-
def
reduceRightOption[B >: T](op: (T, B) ⇒ B): Option[B]
-
-
-
def
reverseIterator: Iterator[T]
-
def
reverseMap[B, That](f: (T) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
-
def
reversed: List[T]
-
def
runWith[U](action: (T) ⇒ U): (Int) ⇒ Boolean
-
def
sameElements[B >: T](that: GenIterable[B]): Boolean
-
def
scan[B >: T, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[IndexedSeq[T], B, That]): That
-
def
scanLeft[B, That](z: B)(op: (B, T) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
-
def
scanRight[B, That](z: B)(op: (T, B) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
-
def
segmentLength(p: (T) ⇒ Boolean, from: Int): Int
-
-
def
size: Int
-
-
-
-
def
sortBy[B](f: (T) ⇒ B)(implicit ord: Ordering[B]): IndexedSeq[T]
-
-
def
sorted[B >: T](implicit ord: Ordering[B]): IndexedSeq[T]
-
-
-
def
startsWith[B](that: GenSeq[B], offset: Int): Boolean
-
def
startsWith[B](that: GenSeq[B]): Boolean
-
def
stringPrefix: String
-
def
suggestName(name: ⇒ String): Vec.this.type
-
def
sum[B >: T](implicit num: Numeric[B]): B
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
-
-
-
-
-
def
thisCollection: IndexedSeq[T]
-
def
to[Col[_]](implicit cbf: CanBuildFrom[Nothing, T, Col[T]]): Col[T]
-
def
toArray[B >: T](implicit arg0: ClassTag[B]): Array[B]
-
def
toBuffer[A1 >: T]: Buffer[A1]
-
-
def
toIndexedSeq: IndexedSeq[T]
-
def
toIterable: Iterable[T]
-
def
toIterator: Iterator[T]
-
def
toList: List[T]
-
def
toMap[T, U](implicit ev: <:<[T, (T, U)]): Map[T, U]
-
-
def
toSeq: Seq[T]
-
def
toSet[B >: T]: Set[B]
-
def
toStream: Stream[T]
-
def
toString(): String
-
-
def
toVector: Vector[T]
-
-
def
union[B >: T, That](that: GenSeq[B])(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
-
def
unzip[A1, A2](implicit asPair: (T) ⇒ (A1, A2)): (IndexedSeq[A1], IndexedSeq[A2])
-
def
unzip3[A1, A2, A3](implicit asTriple: (T) ⇒ (A1, A2, A3)): (IndexedSeq[A1], IndexedSeq[A2], IndexedSeq[A3])
-
def
updated[B >: T, That](index: Int, elem: B)(implicit bf: CanBuildFrom[IndexedSeq[T], B, That]): That
-
def
view(from: Int, until: Int): SeqView[T, IndexedSeq[T]]
-
def
view: SeqView[T, IndexedSeq[T]]
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
final
def
widthOption: Option[Int]
-
-
def
zip[A1 >: T, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[IndexedSeq[T], (A1, B), That]): That
-
def
zipAll[B, A1 >: T, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[IndexedSeq[T], (A1, B), That]): That
-
def
zipWithIndex[A1 >: T, That](implicit bf: CanBuildFrom[IndexedSeq[T], (A1, Int), That]): That
Inherited from HasNewBuilder[T, IndexedSeq[T] @scala.annotation.unchecked.uncheckedVariance]
Inherited from HasId
Inherited from AnyRef
Inherited from Any
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
type of elements