class Vec[T <: Data] extends MultiData with IndexedSeq[T]
A Vec
is a composite type that defines a group of indexed signals (of any SpinalHDL basic type) under a single name
val myVecOfSInt = Vec(SInt(8 bits), 2)
- See also
- Alphabetic
- By Inheritance
- Vec
- IndexedSeq
- IndexedSeqOps
- Seq
- Equals
- SeqOps
- PartialFunction
- Function1
- Iterable
- IterableFactoryDefaults
- IterableOps
- IterableOnceOps
- IterableOnce
- MultiData
- Data
- InComponent
- OverridedEqualsHashCode
- SpinalTagReady
- Assignable
- NameableByComponent
- Nameable
- OwnableRef
- ContextUser
- ScalaLocated
- GlobalDataUser
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- abstract type RefOwnerType
- Definition Classes
- OwnableRef
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def ##(right: Data): Bits
Concatenation between two signals
Concatenation between two signals
- Definition Classes
- Data
- final def ##: Int
- Definition Classes
- AnyRef → Any
- def #*(count: Int): Bits
- Definition Classes
- Data
- final def ++[B >: T](suffix: IterableOnce[B]): IndexedSeq[B]
- Definition Classes
- IterableOps
- Annotations
- @inline()
- final def ++:[B >: T](prefix: IterableOnce[B]): IndexedSeq[B]
- Definition Classes
- SeqOps → IterableOps
- Annotations
- @inline()
- final def +:[B >: T](elem: B): IndexedSeq[B]
- Definition Classes
- SeqOps
- Annotations
- @inline()
- final def :+[B >: T](elem: B): IndexedSeq[B]
- Definition Classes
- SeqOps
- Annotations
- @inline()
- final def :++[B >: T](suffix: IterableOnce[B]): IndexedSeq[B]
- Definition Classes
- SeqOps
- Annotations
- @inline()
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def IFparent: Data
- Definition Classes
- Data
- var _dataType: HardType[T]
- val _spinalTags: LinkedHashSet[SpinalTag]
- Definition Classes
- SpinalTagReady
- def access(address: UInt): T
- def addAttribute(attribute: Attribute): Vec.this.type
- Definition Classes
- Data → SpinalTagReady
- def addAttribute(name: String, value: Int): Vec.this.type
- Definition Classes
- SpinalTagReady
- def addAttribute(name: String, value: String): Vec.this.type
- Definition Classes
- SpinalTagReady
- def addAttribute(name: String): Vec.this.type
- Definition Classes
- SpinalTagReady
- final def addString(b: StringBuilder): b.type
- Definition Classes
- IterableOnceOps
- Annotations
- @inline()
- final def addString(b: StringBuilder, sep: String): b.type
- Definition Classes
- IterableOnceOps
- Annotations
- @inline()
- def addString(b: StringBuilder, start: String, sep: String, end: String): b.type
- Definition Classes
- IterableOnceOps
- def addTag[T <: SpinalTag](spinalTag: T): Vec.this.type
- Definition Classes
- MultiData → SpinalTagReady
- def addTags(h: SpinalTag, tail: SpinalTag*): Vec.this.type
- Definition Classes
- SpinalTagReady
- def addTags[T <: SpinalTag](tags: Iterable[T]): Vec.this.type
- Definition Classes
- SpinalTagReady
- def allowDirectionLessIo(): Vec.this.type
Allow a signal of an io
Bundle
to be directionless.Allow a signal of an io
Bundle
to be directionless.- Definition Classes
- Data
- See also
- def allowOverride(): Vec.this.type
Allow a signal to be overridden.
Allow a signal to be overridden.
- Definition Classes
- Data
- See also
- def allowPartialyAssigned(): Vec.this.type
Allow a register to be partially assigned
Allow a register to be partially assigned
- Definition Classes
- Data
- def allowPruning(): Vec.this.type
- Definition Classes
- Data
- def allowSimplifyIt(): Vec.this.type
- Definition Classes
- Data
- def allowUnsetRegToAvoidLatch(): Vec.this.type
Allow a register to have only an init (no assignments)
Allow a register to have only an init (no assignments)
- Definition Classes
- Data
- See also
- def andThen[C](k: PartialFunction[T, C]): PartialFunction[Int, C]
- Definition Classes
- PartialFunction
- def andThen[C](k: (T) => C): PartialFunction[Int, C]
- Definition Classes
- PartialFunction → Function1
- def appended[B >: T](elem: B): IndexedSeq[B]
- Definition Classes
- SeqOps
- def appendedAll[B >: T](suffix: IterableOnce[B]): IndexedSeq[B]
- Definition Classes
- SeqOps
- def apply(address: UInt): T
Access an element of the vector by an
UInt
index - def apply(idx: Int): T
Access an element of the vector by an
Int
indexAccess an element of the vector by an
Int
index- Definition Classes
- Vec → SeqOps → Function1
- def applyOrElse[A1 <: Int, B1 >: T](x: A1, default: (A1) => B1): B1
- Definition Classes
- PartialFunction
- def as[T <: Data](dataType: HardType[T]): T
- Definition Classes
- Data
- def asBits: Bits
Cast signal to Bits
- def asData: Data
- Definition Classes
- Data
- def asInOut(): Vec.this.type
Set a signal as
inout
- def asInput(): Vec.this.type
Set a data as input
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def asOutput(): Vec.this.type
Set a data as output
- def assignDontCare(): Vec.this.type
- Definition Classes
- Data
- def assignDontCareToUnasigned(): Vec.this.type
- Definition Classes
- Data
- def assignFormalRandom(kind: RandomExpKind): Unit
- final def assignFrom(that: AnyRef, target: AnyRef = this)(implicit loc: Location): Unit
- Definition Classes
- Data
- def assignFromBits(bits: Bits, hi: Int, lo: Int): Unit
- def assignFromBits(bits: Bits): Unit
- def assignFromBits(bits: Bits, offset: Int, bitCount: BitCount): Unit
- Definition Classes
- Data
- def assignFromImpl(that: AnyRef, target: AnyRef, kind: AnyRef)(implicit loc: Location): Unit
- Attributes
- protected
- Definition Classes
- Vec → Assignable
- def assignUnassignedByName(that: MultiData): Unit
- Definition Classes
- MultiData
- def canEqual(that: Any): Boolean
- Definition Classes
- Seq → Equals
- def className: String
- Attributes
- protected[this]
- Definition Classes
- Iterable
- def clearAll(): Vec.this.type
- Definition Classes
- Data
- def clone(): Vec.this.type
- final def coll: Vec.this.type
- Attributes
- protected
- Definition Classes
- Iterable → IterableOps
- def collect[B](pf: PartialFunction[T, B]): IndexedSeq[B]
- Definition Classes
- IterableOps → IterableOnceOps
- def collectFirst[B](pf: PartialFunction[T, B]): Option[B]
- Definition Classes
- IterableOnceOps
- def combinations(n: Int): Iterator[IndexedSeq[T]]
- Definition Classes
- SeqOps
- def component: Component
- Definition Classes
- ContextUser
- def compose[R](k: PartialFunction[R, Int]): PartialFunction[R, T]
- Definition Classes
- PartialFunction
- def compose[A](g: (A) => Int): (A) => T
- Definition Classes
- Function1
- Annotations
- @unspecialized()
- final def compositAssignFrom(that: AnyRef, target: AnyRef, kind: AnyRef)(implicit loc: Location): Unit
- Definition Classes
- Assignable
- val compositeAssign: Assignable
- Definition Classes
- Assignable
- final def concat[B >: T](suffix: IterableOnce[B]): IndexedSeq[B]
- Definition Classes
- SeqOps → IterableOps
- Annotations
- @inline()
- def contains[A1 >: T](elem: A1): Boolean
- Definition Classes
- SeqOps
- def containsSlice[B >: T](that: Seq[B]): Boolean
- Definition Classes
- SeqOps
- def copyDirectionOfImpl(that: Data): Vec.this.type
- def copyToArray[B >: T](xs: Array[B], start: Int, len: Int): Int
- Definition Classes
- IterableOnceOps
- def copyToArray[B >: T](xs: Array[B], start: Int): Int
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecatedOverriding()
- def copyToArray[B >: T](xs: Array[B]): Int
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecatedOverriding()
- def corresponds[B](that: Seq[B])(p: (T, B) => Boolean): Boolean
- Definition Classes
- SeqOps
- def corresponds[B](that: IterableOnce[B])(p: (T, B) => Boolean): Boolean
- Definition Classes
- IterableOnceOps
- def count(p: (T) => Boolean): Int
- Definition Classes
- IterableOnceOps
- def dataType: HardType[T]
- def diff[B >: T](that: Seq[B]): IndexedSeq[T]
- Definition Classes
- SeqOps
- def dirString(): String
- Definition Classes
- Data
- def distinct: IndexedSeq[T]
- Definition Classes
- SeqOps
- def distinctBy[B](f: (T) => B): IndexedSeq[T]
- Definition Classes
- SeqOps
- def dontSimplifyIt(): Vec.this.type
- Definition Classes
- Data
- def drop(n: Int): IndexedSeq[T]
- Definition Classes
- IndexedSeqOps → IterableOps → IterableOnceOps
- def dropRight(n: Int): IndexedSeq[T]
- Definition Classes
- IndexedSeqOps → IterableOps
- def dropWhile(p: (T) => Boolean): IndexedSeq[T]
- Definition Classes
- IterableOps → IterableOnceOps
- def elementWise: ElementWiseExtractor[Int, T]
- Definition Classes
- PartialFunction
- def elements: ArrayBuffer[(String, Data)]
- def elementsString: String
- Definition Classes
- MultiData
- def empty: IndexedSeq[T]
- Definition Classes
- IterableFactoryDefaults → IterableOps
- def endsWith[B >: T](that: Iterable[B]): Boolean
- Definition Classes
- SeqOps
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(that: Any): Boolean
- Definition Classes
- Vec → Seq → Equals → OverridedEqualsHashCode → AnyRef → Any
- def exists(p: (T) => Boolean): Boolean
- Definition Classes
- IterableOnceOps
- def existsTag(cond: (SpinalTag) => Boolean): Boolean
- Definition Classes
- SpinalTagReady
- def filter(pred: (T) => Boolean): IndexedSeq[T]
- Definition Classes
- IterableOps → IterableOnceOps
- def filterNot(pred: (T) => Boolean): IndexedSeq[T]
- Definition Classes
- IterableOps → IterableOnceOps
- def filterTag(cond: (SpinalTag) => Boolean): Iterable[SpinalTag]
- Definition Classes
- SpinalTagReady
- def find(p: (T) => Boolean): Option[T]
- Definition Classes
- IterableOnceOps
- def find(name: String): Data
- Definition Classes
- MultiData
- def findLast(p: (T) => Boolean): Option[T]
- Definition Classes
- SeqOps
- def findTag(cond: (SpinalTag) => Boolean): Option[SpinalTag]
- Definition Classes
- SpinalTagReady
- def flatMap[B](f: (T) => IterableOnce[B]): IndexedSeq[B]
- Definition Classes
- IterableOps → IterableOnceOps
- def flatten[B](implicit asIterable: (T) => IterableOnce[B]): IndexedSeq[B]
- Definition Classes
- IterableOps → IterableOnceOps
- def flatten: Seq[BaseType]
- def flattenForeach(body: (BaseType) => Unit): Unit
- def flattenLocalName: Seq[String]
- def flip(): Vec.this.type
Flip the direction of the signal.
- def fold[A1 >: T](z: A1)(op: (A1, A1) => A1): A1
- Definition Classes
- IterableOnceOps
- def foldLeft[B](z: B)(op: (B, T) => B): B
- Definition Classes
- IterableOnceOps
- def foldRight[B](z: B)(op: (T, B) => B): B
- Definition Classes
- IndexedSeqOps → IterableOnceOps
- def forall(p: (T) => Boolean): Boolean
- Definition Classes
- IterableOnceOps
- def foreach[U](f: (T) => U): Unit
- Definition Classes
- IterableOnceOps
- def foreachReflectableNameables(doThat: (Any) => Unit): Unit
- Definition Classes
- Nameable
- def foreachTag(body: (SpinalTag) => Unit): Unit
- Definition Classes
- SpinalTagReady
- def freeze(): Vec.this.type
- def fromSpecific(coll: IterableOnce[T]): IndexedSeq[T]
- Attributes
- protected
- Definition Classes
- IterableFactoryDefaults → IterableOps
- def getAheadValue(): Vec.this.type
For a register, get the value it will have at the next clock, as a combinational signal.
For a register, get the value it will have at the next clock, as a combinational signal.
- Definition Classes
- Data
- def getBitsWidth: Int
Return the width of the data
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @HotSpotIntrinsicCandidate() @native()
- def getComponent(): Component
- Definition Classes
- Data → InComponent → NameableByComponent
- def getComponents(): Seq[Component]
Get current component with all parents
Get current component with all parents
- Definition Classes
- InComponent
- def getDirection: IODirection
- Definition Classes
- Data
- def getDisplayName(): String
- Definition Classes
- Nameable
- def getInstanceCounter: Int
- Definition Classes
- ContextUser
- def getMode: Byte
- Attributes
- protected
- Definition Classes
- Nameable
- def getMuxType[T <: Data](list: TraversableOnce[T]): HardType[T]
- Definition Classes
- Data
- def getName(default: String): String
- Definition Classes
- NameableByComponent → Nameable
- def getName(): String
- Definition Classes
- NameableByComponent → Nameable
- def getPartialName(): String
- Definition Classes
- Nameable
- def getPath(from: Component, to: Component): Seq[Component]
- Definition Classes
- NameableByComponent
- def getRealSource: Any
- Definition Classes
- Assignable
- def getRealSourceNoRec: Any
- Definition Classes
- Data → Assignable
- def getRefOwnersChain(): List[Any]
- Definition Classes
- OwnableRef
- def getRootParent: Data
- Definition Classes
- Data
- def getRtlPath(separator: String = "/"): String
- Definition Classes
- Data
- def getScalaLocationLong: String
- Definition Classes
- ScalaLocated
- def getScalaLocationShort: String
- Definition Classes
- ScalaLocated
- def getScalaTrace(): Throwable
- Definition Classes
- ScalaLocated
- def getTag[T <: SpinalTag](clazz: Class[T]): Option[T]
- Definition Classes
- SpinalTagReady
- def getTags(): LinkedHashSet[SpinalTag]
- Definition Classes
- SpinalTagReady
- def getZero: Vec.this.type
Create a signal set to 0
- val globalData: GlobalData
- Definition Classes
- GlobalDataUser
- def groupBy[K](f: (T) => K): Map[K, IndexedSeq[T]]
- Definition Classes
- IterableOps
- def groupMap[K, B](key: (T) => K)(f: (T) => B): Map[K, IndexedSeq[B]]
- Definition Classes
- IterableOps
- def groupMapReduce[K, B](key: (T) => K)(f: (T) => B)(reduce: (B, B) => B): Map[K, B]
- Definition Classes
- IterableOps
- def grouped(size: Int): Iterator[IndexedSeq[T]]
- Definition Classes
- IterableOps
- def hasTag[T <: SpinalTag](clazz: Class[T]): Boolean
- Definition Classes
- SpinalTagReady
- def hasTag(spinalTag: SpinalTag): Boolean
- Definition Classes
- SpinalTagReady
- def hashCode(): Int
- Definition Classes
- Vec → Seq → OverridedEqualsHashCode → AnyRef → Any
- def head: T
- Definition Classes
- IndexedSeqOps → IterableOps
- def headOption: Option[T]
- Definition Classes
- IndexedSeqOps → IterableOps
- def indexOf[B >: T](elem: B): Int
- Definition Classes
- SeqOps
- Annotations
- @deprecatedOverriding()
- def indexOf[B >: T](elem: B, from: Int): Int
- Definition Classes
- SeqOps
- def indexOfSlice[B >: T](that: Seq[B]): Int
- Definition Classes
- SeqOps
- Annotations
- @deprecatedOverriding()
- def indexOfSlice[B >: T](that: Seq[B], from: Int): Int
- Definition Classes
- SeqOps
- def indexWhere(p: (T) => Boolean): Int
- Definition Classes
- SeqOps
- Annotations
- @deprecatedOverriding()
- def indexWhere(p: (T) => Boolean, from: Int): Int
- Definition Classes
- SeqOps
- def indices: Range
- Definition Classes
- SeqOps
- def init: IndexedSeq[T]
- Definition Classes
- IterableOps
- final def initFrom(that: AnyRef, target: AnyRef = this): Unit
- Definition Classes
- Data
- def inits: Iterator[IndexedSeq[T]]
- Definition Classes
- IterableOps
- def instanceAttributes(language: Language): Iterable[Attribute]
- Definition Classes
- SpinalTagReady
- def instanceAttributes: Iterable[Attribute]
- Definition Classes
- SpinalTagReady
- def intersect[B >: T](that: Seq[B]): IndexedSeq[T]
- Definition Classes
- SeqOps
- def isAnalog: Boolean
- Definition Classes
- Data
- def isComb: Boolean
- Definition Classes
- Data
- def isCompletelyUnnamed: Boolean
- Definition Classes
- Nameable
- def isDefinedAt(idx: Int): Boolean
- Definition Classes
- SeqOps
- def isDirectionLess: Boolean
- Definition Classes
- Data
- def isEmpty: Boolean
- Definition Classes
- SeqOps → IterableOnceOps
- def isEmptyOfTag: Boolean
- Definition Classes
- SpinalTagReady
- def isInOut: Boolean
- Definition Classes
- Data
- def isInput: Boolean
- Definition Classes
- Data
- def isInputOrInOut: Boolean
- Definition Classes
- Data
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- final def isNamed: Boolean
- Definition Classes
- Nameable
- def isOutput: Boolean
- Definition Classes
- Data
- def isOutputOrInOut: Boolean
- Definition Classes
- Data
- def isPriorityApplicable(namePriority: Byte): Boolean
- Definition Classes
- Nameable
- def isReg: Boolean
- Definition Classes
- Data
- def isRegOnAssign: Boolean
- Definition Classes
- Data
- def isTraversableAgain: Boolean
- Definition Classes
- IterableOps → IterableOnceOps
- def isUnnamed: Boolean
- Definition Classes
- NameableByComponent → Nameable
- def iterableFactory: SeqFactory[IndexedSeq]
- Definition Classes
- IndexedSeq → Seq → Iterable → IterableOps
- def iterator: Iterator[T]
- Definition Classes
- IndexedSeqOps → IterableOnce
- def knownSize: Int
- Definition Classes
- IndexedSeqOps → IterableOnce
- def last: T
- Definition Classes
- IndexedSeqOps → IterableOps
- def lastIndexOf[B >: T](elem: B, end: Int): Int
- Definition Classes
- SeqOps
- def lastIndexOfSlice[B >: T](that: Seq[B]): Int
- Definition Classes
- SeqOps
- Annotations
- @deprecatedOverriding()
- def lastIndexOfSlice[B >: T](that: Seq[B], end: Int): Int
- Definition Classes
- SeqOps
- def lastIndexWhere(p: (T) => Boolean): Int
- Definition Classes
- SeqOps
- Annotations
- @deprecatedOverriding()
- def lastIndexWhere(p: (T) => Boolean, end: Int): Int
- Definition Classes
- SeqOps
- def lastOption: Option[T]
- Definition Classes
- IterableOps
- def lazyZip[B](that: Iterable[B]): LazyZip2[T, B, Vec.this.type]
- Definition Classes
- Iterable
- def length: Int
- Definition Classes
- Vec → SeqOps
- final def lengthCompare(that: Iterable[_]): Int
- Definition Classes
- IndexedSeqOps → SeqOps
- final def lengthCompare(len: Int): Int
- Definition Classes
- IndexedSeqOps → SeqOps
- final def lengthIs: SizeCompareOps
- Definition Classes
- SeqOps
- Annotations
- @inline()
- def lift: (Int) => Option[T]
- Definition Classes
- PartialFunction
- def map[B](f: (T) => B): IndexedSeq[B]
- Definition Classes
- IndexedSeqOps → IterableOps → IterableOnceOps
- def max[B >: T](implicit ord: Ordering[B]): T
- Definition Classes
- IterableOnceOps
- def maxBy[B](f: (T) => B)(implicit ord: Ordering[B]): T
- Definition Classes
- IterableOnceOps
- def maxByOption[B](f: (T) => B)(implicit ord: Ordering[B]): Option[T]
- Definition Classes
- IterableOnceOps
- def maxOption[B >: T](implicit ord: Ordering[B]): Option[T]
- Definition Classes
- IterableOnceOps
- def min[B >: T](implicit ord: Ordering[B]): T
- Definition Classes
- IterableOnceOps
- def minBy[B](f: (T) => B)(implicit ord: Ordering[B]): T
- Definition Classes
- IterableOnceOps
- def minByOption[B](f: (T) => B)(implicit ord: Ordering[B]): Option[T]
- Definition Classes
- IterableOnceOps
- def minOption[B >: T](implicit ord: Ordering[B]): Option[T]
- Definition Classes
- IterableOnceOps
- final def mkString: String
- Definition Classes
- IterableOnceOps
- Annotations
- @inline()
- final def mkString(sep: String): String
- Definition Classes
- IterableOnceOps
- Annotations
- @inline()
- final def mkString(start: String, sep: String, end: String): String
- Definition Classes
- IterableOnceOps
- val name: String
- Definition Classes
- Nameable
- val nameableRef: Nameable
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def newSpecificBuilder: Builder[T, IndexedSeq[T]]
- Attributes
- protected
- Definition Classes
- IterableFactoryDefaults → IterableOps
- def noBackendCombMerge(): Vec.this.type
Put the combinatorial logic driving this signal in a separate process
Put the combinatorial logic driving this signal in a separate process
- Definition Classes
- Data
- def noCombLoopCheck(): Vec.this.type
Disable combinatorial loop checking for this Data
Disable combinatorial loop checking for this Data
- Definition Classes
- Data
- See also
- def nonEmpty: Boolean
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecatedOverriding()
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @HotSpotIntrinsicCandidate() @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @HotSpotIntrinsicCandidate() @native()
- def occCounts[B](sq: Seq[B]): Map[B, Int]
- Attributes
- protected[collection]
- Definition Classes
- SeqOps
- def onEachAttributes(doIt: (Attribute) => Unit): Unit
- Definition Classes
- SpinalTagReady
- def oneHotAccess(oneHot: Bits): T
Access an element of the vector by a
oneHot
value - def orElse[A1 <: Int, B1 >: T](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
- Definition Classes
- PartialFunction
- def overrideLocalName(name: String): Vec.this.type
- Definition Classes
- Nameable
- def padTo[B >: T](len: Int, elem: B): IndexedSeq[B]
- Definition Classes
- SeqOps
- val parent: Data
- Definition Classes
- Data
- val parentScope: ScopeStatement
- Definition Classes
- ContextUser
- def partition(p: (T) => Boolean): (IndexedSeq[T], IndexedSeq[T])
- Definition Classes
- IterableOps
- def partitionMap[A1, A2](f: (T) => Either[A1, A2]): (IndexedSeq[A1], IndexedSeq[A2])
- Definition Classes
- IterableOps
- def patch[B >: T](from: Int, other: IterableOnce[B], replaced: Int): IndexedSeq[B]
- Definition Classes
- SeqOps
- def permutations: Iterator[IndexedSeq[T]]
- Definition Classes
- SeqOps
- def prepended[B >: T](elem: B): IndexedSeq[B]
- Definition Classes
- IndexedSeqOps → SeqOps
- def prependedAll[B >: T](prefix: IterableOnce[B]): IndexedSeq[B]
- Definition Classes
- SeqOps
- def product[B >: T](implicit num: Numeric[B]): B
- Definition Classes
- IterableOnceOps
- def pull(propagateName: Boolean): Vec.this.type
- Definition Classes
- Data
- def pull(): Vec.this.type
Pull a signal to the top level (use for debugging)
Pull a signal to the top level (use for debugging)
- Definition Classes
- Data
- def purify(): Vec.this.type
- Definition Classes
- Data
- def randBoot(u: Unit): Vec.this.type
Useful for register that doesn't need a reset value in RTL, but need a random value for simulation (avoid x-propagation)
Useful for register that doesn't need a reset value in RTL, but need a random value for simulation (avoid x-propagation)
- Definition Classes
- Data
- def range: Range
- def read(address: UInt): T
- def reduce[B >: T](op: (B, B) => B): B
- Definition Classes
- IterableOnceOps
- def reduceLeft[B >: T](op: (B, T) => B): B
- Definition Classes
- IterableOnceOps
- def reduceLeftOption[B >: T](op: (B, T) => B): Option[B]
- Definition Classes
- IterableOnceOps
- def reduceOption[B >: T](op: (B, B) => B): Option[B]
- Definition Classes
- IterableOnceOps
- def reduceRight[B >: T](op: (T, B) => B): B
- Definition Classes
- IterableOnceOps
- def reduceRightOption[B >: T](op: (T, B) => B): Option[B]
- Definition Classes
- IterableOnceOps
- val refOwner: RefOwnerType
- Definition Classes
- OwnableRef
- Annotations
- @DontName()
- def reflectNames(): Unit
- Definition Classes
- Nameable
- def removeAssignments(data: Boolean = true, init: Boolean = true, initial: Boolean = true): Vec.this.type
- Definition Classes
- Data
- def removeDataAssignments(): Vec.this.type
- Definition Classes
- Data
- def removeInitAssignments(): Vec.this.type
- Definition Classes
- Data
- def removeTag(spinalTag: SpinalTag): Vec.this.type
- Definition Classes
- SpinalTagReady
- def removeTags(tags: Iterable[SpinalTag]): Vec.this.type
- Definition Classes
- SpinalTagReady
- def resized: Vec.this.type
Return a version of the signal which is allowed to be automatically resized where needed.
Return a version of the signal which is allowed to be automatically resized where needed.
The resize operation is deferred until the point of assignment later. The resize may widen or truncate, retaining the LSB.
- Definition Classes
- Data
- See also
- def reverse: IndexedSeq[T]
- Definition Classes
- IndexedSeqOps → SeqOps
- def reverseIterator: Iterator[T]
- Definition Classes
- IndexedSeqOps → SeqOps
- def reversed: Iterable[T]
- Attributes
- protected
- Definition Classes
- IndexedSeqOps → IterableOnceOps
- def rootIF(): Interface
root interface
root interface
- Definition Classes
- Data
- def rootIFList(): List[Interface]
- Definition Classes
- Data
- def rootIFrec(now: Data, lastRoot: List[Interface]): List[Interface]
- Definition Classes
- Data
- def runWith[U](action: (T) => U): (Int) => Boolean
- Definition Classes
- PartialFunction
- def sameElements[B >: T](that: IterableOnce[B]): Boolean
- Definition Classes
- SeqOps
- val scalaTrace: Throwable
- Definition Classes
- ScalaLocated
- def scan[B >: T](z: B)(op: (B, B) => B): IndexedSeq[B]
- Definition Classes
- IterableOps
- def scanLeft[B](z: B)(op: (B, T) => B): IndexedSeq[B]
- Definition Classes
- IterableOps → IterableOnceOps
- def scanRight[B](z: B)(op: (T, B) => B): IndexedSeq[B]
- Definition Classes
- IterableOps
- def search[B >: T](elem: B, from: Int, to: Int)(implicit ord: Ordering[B]): SearchResult
- Definition Classes
- IndexedSeqOps → SeqOps
- def search[B >: T](elem: B)(implicit ord: Ordering[B]): SearchResult
- Definition Classes
- IndexedSeqOps → SeqOps
- def segmentLength(p: (T) => Boolean, from: Int): Int
- Definition Classes
- SeqOps
- final def segmentLength(p: (T) => Boolean): Int
- Definition Classes
- SeqOps
- def setAll(): Vec.this.type
- Definition Classes
- Data
- def setAsAnalog(): Vec.this.type
- Definition Classes
- Data
- def setAsComb(): Vec.this.type
Set baseType to Combinatorial
- def setAsDirectionLess(): Vec.this.type
Remove the direction (
in
,out
,inout
) to a signal - def setAsReg(): Vec.this.type
Set baseType to reg
- def setCompositeName(nameable: Nameable, postfix: String, namePriority: Byte): Vec.this.type
- Definition Classes
- Nameable
- def setCompositeName(nameable: Nameable, postfix: String, weak: Boolean): Vec.this.type
- Definition Classes
- Nameable
- def setCompositeName(nameable: Nameable, postfix: String): Vec.this.type
- Definition Classes
- Nameable
- def setCompositeName(nameable: Nameable, namePriority: Byte): Vec.this.type
- Definition Classes
- Nameable
- def setCompositeName(nameable: Nameable, weak: Boolean): Vec.this.type
- Definition Classes
- Nameable
- def setCompositeName(nameable: Nameable): Vec.this.type
- Definition Classes
- Nameable
- def setElementsParents(): Vec.this.type
- def setLambdaName(isNameBody: => Boolean)(nameGen: => String): Vec.this.type
- Definition Classes
- Nameable
- def setName(name: String, namePriority: Byte): Vec.this.type
- Definition Classes
- Nameable
- def setName(name: String, weak: Boolean): Vec.this.type
- Definition Classes
- Nameable
- def setName(name: String): Vec.this.type
- Definition Classes
- Nameable
- def setNameAsWeak(): Vec.this.type
- Definition Classes
- Nameable
- def setOutputAsReg(): Vec.this.type
Recursively set baseType to reg only for output
Recursively set baseType to reg only for output
- Definition Classes
- Data
- def setPartialName(name: String, namePriority: Byte, owner: Any): Vec.this.type
- Definition Classes
- Nameable
- def setPartialName(name: String, namePriority: Byte): Vec.this.type
- Definition Classes
- Nameable
- def setPartialName(name: String, weak: Boolean): Vec.this.type
- Definition Classes
- Nameable
- def setPartialName(owner: Nameable, name: String, namePriority: Byte): Vec.this.type
- Definition Classes
- Nameable
- def setPartialName(owner: Nameable, name: String, weak: Boolean): Vec.this.type
- Definition Classes
- Nameable
- def setPartialName(name: String): Vec.this.type
- Definition Classes
- Nameable
- def setPartialName(owner: Nameable, name: String): Vec.this.type
- Definition Classes
- Nameable
- def setPartialName(owner: Nameable): Vec.this.type
- Definition Classes
- Nameable
- def setRefOwner(that: Any): Unit
- Definition Classes
- OwnableRef
- def setScalaLocated(source: ScalaLocated): Vec.this.type
- Definition Classes
- ScalaLocated
- def setWeakName(name: String): Vec.this.type
- Definition Classes
- Nameable
- final def size: Int
- Definition Classes
- SeqOps → IterableOnceOps
- final def sizeCompare(that: Iterable[_]): Int
- Definition Classes
- SeqOps → IterableOps
- final def sizeCompare(otherSize: Int): Int
- Definition Classes
- SeqOps → IterableOps
- final def sizeIs: SizeCompareOps
- Definition Classes
- IterableOps
- Annotations
- @inline()
- def slice(from: Int, until: Int): IndexedSeq[T]
- Definition Classes
- IndexedSeqOps → IterableOps → IterableOnceOps
- def sliding(size: Int, step: Int): Iterator[IndexedSeq[T]]
- Definition Classes
- IterableOps
- def sliding(size: Int): Iterator[IndexedSeq[T]]
- Definition Classes
- IterableOps
- def sortBy[B](f: (T) => B)(implicit ord: Ordering[B]): IndexedSeq[T]
- Definition Classes
- SeqOps
- def sortWith(lt: (T, T) => Boolean): IndexedSeq[T]
- Definition Classes
- SeqOps
- def sorted[B >: T](implicit ord: Ordering[B]): IndexedSeq[T]
- Definition Classes
- SeqOps
- def span(p: (T) => Boolean): (IndexedSeq[T], IndexedSeq[T])
- Definition Classes
- IterableOps → IterableOnceOps
- def spinalTags: LinkedHashSet[SpinalTag]
- Definition Classes
- SpinalTagReady
- def splitAt(n: Int): (IndexedSeq[T], IndexedSeq[T])
- Definition Classes
- IterableOps → IterableOnceOps
- def startsWith[B >: T](that: IterableOnce[B], offset: Int): Boolean
- Definition Classes
- SeqOps
- def stepper[S <: Stepper[_]](implicit shape: StepperShape[T, S]): S with EfficientSplit
- Definition Classes
- IndexedSeqOps → IterableOnce
- def stringPrefix: String
- Attributes
- protected[this]
- Definition Classes
- IndexedSeq → Seq → Iterable
- def sum[B >: T](implicit num: Numeric[B]): B
- Definition Classes
- IterableOnceOps
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def tail: IndexedSeq[T]
- Definition Classes
- IterableOps
- def tails: Iterator[IndexedSeq[T]]
- Definition Classes
- IterableOps
- def take(n: Int): IndexedSeq[T]
- Definition Classes
- IndexedSeqOps → IterableOps → IterableOnceOps
- def takeRight(n: Int): IndexedSeq[T]
- Definition Classes
- IndexedSeqOps → IterableOps
- def takeWhile(p: (T) => Boolean): IndexedSeq[T]
- Definition Classes
- IterableOps → IterableOnceOps
- def tapEach[U](f: (T) => U): IndexedSeq[T]
- Definition Classes
- IterableOps → IterableOnceOps
- def to[C1](factory: Factory[T, C1]): C1
- Definition Classes
- IterableOnceOps
- def toArray[B >: T](implicit arg0: ClassTag[B]): Array[B]
- Definition Classes
- IterableOnceOps
- final def toBuffer[B >: T]: Buffer[B]
- Definition Classes
- IterableOnceOps
- Annotations
- @inline()
- def toIndexedSeq: IndexedSeq[T]
- Definition Classes
- IterableOnceOps
- def toIo(): Vec.this.type
- Definition Classes
- Data
- def toList: List[T]
- Definition Classes
- IterableOnceOps
- def toMap[K, V](implicit ev: <:<[T, (K, V)]): Map[K, V]
- Definition Classes
- IterableOnceOps
- def toMuxInput[T <: Data](muxOutput: T): T
- Definition Classes
- Data
- def toSeq: Seq[T]
- Definition Classes
- IterableOnceOps
- def toSet[B >: T]: Set[B]
- Definition Classes
- IterableOnceOps
- def toString(): String
- def toVector: Vector[T]
- Definition Classes
- IterableOnceOps
- def transpose[B](implicit asIterable: (T) => Iterable[B]): IndexedSeq[IndexedSeq[B]]
- Definition Classes
- IterableOps
- def unapply(a: Int): Option[T]
- Definition Classes
- PartialFunction
- def unfreeze(): Vec.this.type
- def unsetName(): Vec.this.type
- Definition Classes
- Nameable
- def unzip[A1, A2](implicit asPair: (T) => (A1, A2)): (IndexedSeq[A1], IndexedSeq[A2])
- Definition Classes
- IterableOps
- def unzip3[A1, A2, A3](implicit asTriple: (T) => (A1, A2, A3)): (IndexedSeq[A1], IndexedSeq[A2], IndexedSeq[A3])
- Definition Classes
- IterableOps
- def updated[B >: T](index: Int, elem: B): IndexedSeq[B]
- Definition Classes
- SeqOps
- val vec: Vector[T]
- def view: IndexedSeqView[T]
- Definition Classes
- IndexedSeqOps → SeqOps → IterableOps
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- def withFilter(p: (T) => Boolean): WithFilter[T, [_]IndexedSeq[_]]
- Definition Classes
- IterableOps
- def wrapNext(): Vec.this.type
- Definition Classes
- Data
- def zip[B](that: IterableOnce[B]): IndexedSeq[(T, B)]
- Definition Classes
- IterableOps
- def zipAll[A1 >: T, B](that: Iterable[B], thisElem: A1, thatElem: B): IndexedSeq[(A1, B)]
- Definition Classes
- IterableOps
- def zipByName(that: MultiData, rec: ArrayBuffer[(BaseType, BaseType)] = ArrayBuffer()): ArrayBuffer[(BaseType, BaseType)]
- Definition Classes
- MultiData
- def zipWithIndex: IndexedSeq[(T, Int)]
- Definition Classes
- IterableOps → IterableOnceOps
Deprecated Value Members
- final def /:[B](z: B)(op: (B, T) => B): B
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 2.13.0) Use foldLeft instead of /:
- final def :\[B](z: B)(op: (T, B) => B): B
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 2.13.0) Use foldRight instead of :\
- def aggregate[B](z: => B)(seqop: (B, T) => B, combop: (B, B) => B): B
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0)
aggregate
is not relevant for sequential collections. UsefoldLeft(z)(seqop)
instead.
- def asDirectionLess(): Vec.this.type
- Definition Classes
- Data
- Annotations
- @deprecated
- Deprecated
(Since version ???) use setAsDirectionLess instead
- def companion: IterableFactory[[_]IndexedSeq[_]]
- Definition Classes
- IterableOps
- Annotations
- @deprecated @deprecatedOverriding() @inline()
- Deprecated
(Since version 2.13.0) Use iterableFactory instead
- final def copyToBuffer[B >: T](dest: Buffer[B]): Unit
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 2.13.0) Use
dest ++= coll
instead
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable]) @Deprecated
- Deprecated
(Since version 9)
- def genIf(cond: Boolean): Vec.this.type
Generate this if condition is true
Generate this if condition is true
- Definition Classes
- Data
- Annotations
- @deprecated
- Deprecated
does not work with <>, use 'someBool generate Type()' or 'if(condition) Type() else null' instead
- def hasDefiniteSize: Boolean
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Check .knownSize instead of .hasDefiniteSize for more actionable information (see scaladoc for details)
- final def prefixLength(p: (T) => Boolean): Int
- Definition Classes
- SeqOps
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 2.13.0) Use segmentLength instead of prefixLength
- final def repr: IndexedSeq[T]
- Definition Classes
- IterableOps
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use coll instead of repr in a collection implementation, use the collection value itself from the outside
- def reverseMap[B](f: (T) => B): IndexedSeq[B]
- Definition Classes
- SeqOps
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use .reverseIterator.map(f).to(...) instead of .reverseMap(f)
- def seq: Vec.this.type
- Definition Classes
- Iterable
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Iterable.seq always returns the iterable itself
- final def toIterable: Vec.this.type
- Definition Classes
- Iterable → IterableOps
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.7) toIterable is internal and will be made protected; its name is similar to
toList
ortoSeq
, but it doesn't copy non-immutable collections
- final def toIterator: Iterator[T]
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 2.13.0) Use .iterator instead of .toIterator
- final def toStream: Stream[T]
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 2.13.0) Use .to(LazyList) instead of .toStream
- final def toTraversable: Traversable[T]
- Definition Classes
- IterableOps
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) toTraversable is internal and will be made protected; its name is similar to
toList
ortoSeq
, but it doesn't copy non-immutable collections
- final def union[B >: T](that: Seq[B]): IndexedSeq[B]
- Definition Classes
- SeqOps
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 2.13.0) Use
concat
instead
- def view(from: Int, until: Int): IndexedSeqView[T]
- Definition Classes
- IndexedSeqOps → IterableOps
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use .view.slice(from, until) instead of .view(from, until)