class
Flo extends Bits with Num[Flo]
Instance Constructors
-
new
Flo()
Type Members
-
type
T = Flo
Value Members
-
-
-
final
def
!=(arg0: AnyRef): Boolean
-
final
def
!=(arg0: Any): Boolean
-
def
##[T <: Data](right: T): Flo.this.type
-
-
final
def
##(): Int
-
-
-
def
&(b: Bits): Flo.this.type
-
-
-
-
-
-
-
-
-
def
:=(that: Data): Unit
-
-
def
<<(b: UInt): Flo.this.type
-
-
def
<>(src: Node): Unit
-
final
def
==(arg0: AnyRef): Boolean
-
final
def
==(arg0: Any): Boolean
-
-
def
===[T <: Data](right: T): Bool
-
-
-
-
def
^(b: Bits): Flo.this.type
-
def
^^(src: Node): Unit
-
val
_id: Int
-
def
_isComplementOf(x: Node): Boolean
-
def
acos: Flo
-
def
addConsumers(): Unit
-
def
andR(): Bool
-
final
def
apply(range: (Int, Int)): UInt
-
final
def
apply(hi: UInt, lo: UInt): UInt
-
final
def
apply(hi: Int, lo: Int): UInt
-
final
def
apply(bit: UInt): Bool
-
final
def
apply(bit: Int): Bool
-
def
apply(name: String): Data
-
def
asDirectionless(): Flo.this.type
-
def
asInput(): Flo.this.type
-
final
def
asInstanceOf[T0]: T0
-
def
asOutput(): Flo.this.type
-
final
def
asTypeFor(node: Node): Flo.this.type
-
def
asin: Flo
-
def
assign(src: Node): Unit
-
def
atan: Flo
-
def
bitSet(off: UInt, dat: UInt): Flo.this.type
-
def
canCSE: Boolean
-
def
ceil: Flo
-
lazy val
chiselName: String
-
var
clock: Clock
-
def
clone(): Flo.this.type
-
var
cntrIdx: Int
-
def
colonEquals(that: Bits): Unit
-
def
colonEquals[T <: Data](that: Iterable[T]): Unit
-
def
colonEquals(that: Bundle): Unit
-
var
comp: proc
-
var
component: Module
-
def
componentOf: Module
-
val
consumers: ArrayBuffer[Node]
-
def
cos: Flo
-
var
counter: Bits
-
def
create(dir: IODirection, width: Int): Unit
-
def
dblLitValue: Double
-
def
default: proc
-
def
defaultMissing: Boolean
-
def
defaultRequired: Boolean
-
var
depth: Int
-
-
def
doProcAssign(src: Node, cond: Bool): Unit
-
var
driveRand: Boolean
-
lazy val
emitIndex: Int
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equals(that: Any): Boolean
-
def
equalsForCSE(x: Node): Boolean
-
-
def
extract(b: Bundle): List[Node]
-
def
extract(widths: Array[Int]): List[UInt]
-
def
finalize(): Unit
-
def
flatten: Array[(String, Bits)]
-
def
flip(): Flo.this.type
-
def
floLitValue: Float
-
def
floor: Flo
-
def
forceMatchingWidths: Unit
-
def
fromBits(b: Bits): Flo.this.type
-
def
fromInt(x: Int): Flo.this.type
-
def
fromNode(n: Node): Flo.this.type
-
def
gen[T <: Bits](): T
-
final
def
getClass(): Class[_]
-
-
def
getNode: Node
-
def
getWidth(): Int
-
def
hashCode(): Int
-
def
hashCodeForCSE: Int
-
def
illegalAssignment(that: Any): Unit
-
def
infer: Boolean
-
var
inferWidth: (Node) ⇒ Int
-
def
init(n: String, w: Int, ins: Node*): Node
-
def
init(n: String, width: (Node) ⇒ Int, ins: Node*): Node
-
def
initOf(n: String, width: (Node) ⇒ Int, ins: Iterable[Node]): Node
-
val
inputs: ArrayBuffer[Node]
-
def
isByValue: Boolean
-
def
isDirectionless: Boolean
-
lazy val
isInObject: Boolean
-
lazy val
isInVCD: Boolean
-
final
def
isInstanceOf[T0]: Boolean
-
def
isIo: Boolean
-
def
isIo_=(isIo: Boolean): Unit
-
final
def
isLit: Boolean
-
def
isReg: Boolean
-
var
isTypeNode: Boolean
-
def
isUsedByClockHi: Boolean
-
var
isWidthWalked: Boolean
-
val
line: StackTraceElement
-
-
def
litValue(default: BigInt = BigInt(-1)): BigInt
-
def
log: Flo
-
def
matchWidth(w: Int): Node
-
def
max(b: Flo): Flo
-
def
maxNum: BigInt
-
def
maybeFlatten: Seq[Node]
-
def
min(b: Flo): Flo
-
def
minNum: BigInt
-
def
muxes: Seq[Mux]
-
var
name: String
-
-
def
nameIt(path: String, isNamingIo: Boolean): Unit
-
var
named: Boolean
-
final
def
ne(arg0: AnyRef): Boolean
-
final
def
newBinaryOp(right: Bits, opName: String): Flo.this.type
-
final
def
newLogicalOp(right: Bits, opName: String): Bool
-
final
def
newReductionOp(opName: String): Bool
-
final
def
newUnaryOp(opName: String): Flo.this.type
-
def
next: Node
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
def
orR(): Bool
-
var
pName: String
-
-
def
pow(b: Flo): Flo
-
def
printTree(writer: PrintStream, depth: Int = 4, indent: String = ""): Unit
-
def
procAssign(src: Node): Unit
-
var
procAssigned: Boolean
-
var
prune: Boolean
-
def
removeTypeNodes(): Unit
-
def
round: Flo
-
var
sccIndex: Int
-
var
sccLowlink: Int
-
def
setDefault(src: Node): Unit
-
def
setIsTypeNode: Unit
-
def
setName(n: String): Unit
-
def
setPseudoName(path: String, isNamingIo: Boolean): Unit
-
def
setWidth(w: Int): Unit
-
var
shadow: Bits
-
def
sin: Flo
-
def
sqrt: Flo
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
def
tan: Flo
-
def
terminate(): Unit
-
def
toBits(): UInt
-
def
toBool(): Bool
-
def
toBools: Vec[Bool]
-
lazy val
toNode: Node
-
def
toSInt(): SInt
-
def
toString(): String
-
def
toUInt(): UInt
-
def
traceNode(c: Module, stack: Stack[() ⇒ Any]): Any
-
def
traceableNodes: Array[Node]
-
def
unary_-(): Flo
-
def
unary_~(): Flo.this.type
-
def
usesInClockHi(i: Node): Boolean
-
def
verifyMuxes: Unit
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
def
width: Int
-
var
width_: Int
-
def
width_=(w: Int): Unit
-
def
xorR(): Bool
-
def
|(b: Bits): Flo.this.type
Inherited from AnyRef
Inherited from Any