Apply scalafmt

Command:
sbt scalafmtAll

1 files changed, 26 insertions, 24 deletions

diff --git a/core/src/main/scala/chisel3/Num.scala b/core/src/main/scala/chisel3/Num.scala
index 219e18f4..c7e0721f 100644
--- a/core/src/main/scala/chisel3/Num.scala
+++ b/core/src/main/scala/chisel3/Num.scala
@@ -8,7 +8,6 @@ import chisel3.internal.firrtl.{BinaryPoint, KnownBinaryPoint}
 import scala.language.experimental.macros
 import chisel3.internal.sourceinfo.{SourceInfo, SourceInfoTransform}
 
-
 // REVIEW TODO: Further discussion needed on what Num actually is.
 
 /** Abstract trait defining operations available on numeric-like hardware data types.
@@ -43,10 +42,10 @@ trait Num[T <: Data] {
     * $maxWidth
     * @group Arithmetic
     */
-  final def + (that: T): T = macro SourceInfoTransform.thatArg
+  final def +(that: T): T = macro SourceInfoTransform.thatArg
 
   /** @group SourceInfoTransformMacro */
-  def do_+ (that: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): T
+  def do_+(that: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): T
 
   /** Multiplication operator
     *
@@ -56,10 +55,10 @@ trait Num[T <: Data] {
     * $singleCycleMul
     * @group Arithmetic
     */
-  final def * (that: T): T = macro SourceInfoTransform.thatArg
+  final def *(that: T): T = macro SourceInfoTransform.thatArg
 
   /** @group SourceInfoTransformMacro */
-  def do_* (that: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): T
+  def do_*(that: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): T
 
   /** Division operator
     *
@@ -69,10 +68,10 @@ trait Num[T <: Data] {
     * @todo full rules
     * @group Arithmetic
     */
-  final def / (that: T): T = macro SourceInfoTransform.thatArg
+  final def /(that: T): T = macro SourceInfoTransform.thatArg
 
   /** @group SourceInfoTransformMacro */
-  def do_/ (that: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): T
+  def do_/(that: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): T
 
   /** Modulo operator
     *
@@ -81,10 +80,10 @@ trait Num[T <: Data] {
     * $singleCycleDiv
     * @group Arithmetic
     */
-  final def % (that: T): T = macro SourceInfoTransform.thatArg
+  final def %(that: T): T = macro SourceInfoTransform.thatArg
 
   /** @group SourceInfoTransformMacro */
-  def do_% (that: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): T
+  def do_%(that: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): T
 
   /** Subtraction operator
     *
@@ -93,10 +92,10 @@ trait Num[T <: Data] {
     * $maxWidthPlusOne
     * @group Arithmetic
     */
-  final def - (that: T): T = macro SourceInfoTransform.thatArg
+  final def -(that: T): T = macro SourceInfoTransform.thatArg
 
   /** @group SourceInfoTransformMacro */
-  def do_- (that: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): T
+  def do_-(that: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): T
 
   /** Less than operator
     *
@@ -104,10 +103,10 @@ trait Num[T <: Data] {
     * @return a hardware [[Bool]] asserted if this $coll is less than `that`
     * @group Comparison
     */
-  final def < (that: T): Bool = macro SourceInfoTransform.thatArg
+  final def <(that: T): Bool = macro SourceInfoTransform.thatArg
 
   /** @group SourceInfoTransformMacro */
-  def do_< (that: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): Bool
+  def do_<(that: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): Bool
 
   /** Less than or equal to operator
     *
@@ -115,10 +114,10 @@ trait Num[T <: Data] {
     * @return a hardware [[Bool]] asserted if this $coll is less than or equal to `that`
     * @group Comparison
     */
-  final def <= (that: T): Bool = macro SourceInfoTransform.thatArg
+  final def <=(that: T): Bool = macro SourceInfoTransform.thatArg
 
   /** @group SourceInfoTransformMacro */
-  def do_<= (that: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): Bool
+  def do_<=(that: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): Bool
 
   /** Greater than operator
     *
@@ -126,10 +125,10 @@ trait Num[T <: Data] {
     * @return a hardware [[Bool]] asserted if this $coll is greater than `that`
     * @group Comparison
     */
-  final def > (that: T): Bool = macro SourceInfoTransform.thatArg
+  final def >(that: T): Bool = macro SourceInfoTransform.thatArg
 
   /** @group SourceInfoTransformMacro */
-  def do_> (that: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): Bool
+  def do_>(that: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): Bool
 
   /** Greater than or equal to operator
     *
@@ -137,10 +136,10 @@ trait Num[T <: Data] {
     * @return a hardware [[Bool]] asserted if this $coll is greather than or equal to `that`
     * @group Comparison
     */
-  final def >= (that: T): Bool = macro SourceInfoTransform.thatArg
+  final def >=(that: T): Bool = macro SourceInfoTransform.thatArg
 
   /** @group SourceInfoTransformMacro */
-  def do_>= (that: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): Bool
+  def do_>=(that: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): Bool
 
   /** Absolute value operator
     *
@@ -150,7 +149,10 @@ trait Num[T <: Data] {
     */
   final def abs: T = macro SourceInfoTransform.noArg
 
-  @deprecated("Calling this function with an empty argument list is invalid in Scala 3. Use the form without parentheses instead", "Chisel 3.5")
+  @deprecated(
+    "Calling this function with an empty argument list is invalid in Scala 3. Use the form without parentheses instead",
+    "Chisel 3.5"
+  )
   final def abs(dummy: Int*): T = macro SourceInfoTransform.noArgDummy
 
   /** @group SourceInfoTransformMacro */
@@ -189,7 +191,6 @@ object Num extends NumObject
   * BigInts and Double and BigDecimal
   * For backwards compatibility this is used with FixedPoint and Interval objects
   * but is better used with the Num Object
-  *
   */
 trait NumObject {
   val MaxBitsBigIntToBigDecimal = 108
@@ -254,7 +255,7 @@ trait NumObject {
     * @return
     */
   def toDouble(i: BigInt, binaryPoint: Int): Double = {
-    if(i.bitLength >= 54) {
+    if (i.bitLength >= 54) {
       throw new ChiselException(
         s"BigInt $i with bitlength ${i.bitLength} is too big, precision lost with > $MaxBitsBigIntToDouble bits"
       )
@@ -275,7 +276,8 @@ trait NumObject {
       case KnownBinaryPoint(n) => toDouble(value, n)
       case x =>
         throw new ChiselException(s"Error converting BigDecimal $value to BigInt, binary point must be known, not $x")
-    }  }
+    }
+  }
 
   /**
     * converts a bigInt with the given binaryPoint into the BigDecimal representation
@@ -284,7 +286,7 @@ trait NumObject {
     * @return
     */
   def toBigDecimal(value: BigInt, binaryPoint: Int): BigDecimal = {
-    if(value.bitLength > MaxBitsBigIntToBigDecimal) {
+    if (value.bitLength > MaxBitsBigIntToBigDecimal) {
       throw new ChiselException(
         s"BigInt $value with bitlength ${value.bitLength} is too big, precision lost with > $MaxBitsBigIntToBigDecimal bits"
       )