Remove (broken) floating point data types

1 files changed, 0 insertions, 249 deletions

diff --git a/src/main/scala/Chisel/FP.scala b/src/main/scala/Chisel/FP.scala
deleted file mode 100644
index bad62e00..00000000
--- a/src/main/scala/Chisel/FP.scala
+++ /dev/null
@@ -1,249 +0,0 @@
-// See LICENSE for license details.
-
-package Chisel
-import Chisel._
-import Builder.pushOp
-
-/// FLO
-
-case class FloLit(num: Float) extends Arg {
-  def name: String = s"Flo(${num.toString})"
-}
-
-case class DblLit(num: Double) extends Arg {
-  def name: String = s"Dbl(${num.toString})"
-}
-
-object Flo {
-  val Width = 32
-
-  def apply(x: Float): Flo = new Flo(NO_DIR, Some(FloLit(x)))
-  def apply(x: Double): Flo = Flo(x.toFloat)
-  def apply(dir: Direction = null): Flo = new Flo(dir)
-}
-
-object FloPrimOp {
-  val FloNeg = PrimOp("flo-neg")
-  val FloAdd = PrimOp("flo-add")
-  val FloSub = PrimOp("flo-sub")
-  val FloMul = PrimOp("flo-mul")
-  val FloDiv = PrimOp("flo-div")
-  val FloMod = PrimOp("flo-mod")
-  val FloEqual = PrimOp("flo-equal")
-  val FloNotEqual = PrimOp("flo-not-equal")
-  val FloGreater = PrimOp("flo-greater")
-  val FloLess = PrimOp("flo-less")
-  val FloLessEqual = PrimOp("flo-less-equal")
-  val FloGreaterEqual = PrimOp("flo-greater-equal")
-  val FloPow = PrimOp("flo-pow")
-  val FloSin = PrimOp("flo-sin")
-  val FloCos = PrimOp("flo-cos")
-  val FloTan = PrimOp("flo-tan")
-  val FloAsin = PrimOp("flo-asin")
-  val FloAcos = PrimOp("flo-acos")
-  val FloAtan = PrimOp("flo-atan")
-  val FloSqrt = PrimOp("flo-sqrt")
-  val FloFloor = PrimOp("flo-floor")
-  val FloCeil = PrimOp("flo-ceil")
-  val FloRound = PrimOp("flo-round")
-  val FloLog = PrimOp("flo-log")
-  val FloToBits = PrimOp("flo-to-bits")
-  val BitsToFlo = PrimOp("bits-to-flo")
-}
-import FloPrimOp._
-
-sealed abstract class FloBase[T <: Data](dir: Direction, width: Width) extends Element(dir, width) {
-  protected def unop(op: PrimOp): T =
-    pushOp(DefPrim(cloneType, op, this.ref)).asInstanceOf[T]
-  protected def binop(op: PrimOp, other: T): T =
-    pushOp(DefPrim(cloneType, op, this.ref, other.ref)).asInstanceOf[T]
-  protected def compop(op: PrimOp, other: T): Bool =
-    pushOp(DefPrim(Bool(), op, this.ref, other.ref))
-
-  def toUInt: UInt = toBits
-}
-
-class Flo(dir: Direction = NO_DIR, val value:Option[FloLit] = None)
-    extends FloBase[Flo](dir, Width(Flo.Width)) with Num[Flo] {
-  type T = Flo;
-  def floLitValue: Float = value.get.num
-  def cloneTypeWidth(width: Width): this.type = cloneType
-  override def fromBits(n: Bits): this.type =
-    pushOp(DefPrim(cloneType, BitsToFlo, this.ref)).asInstanceOf[this.type]
-  override def toBits: UInt =
-    pushOp(DefPrim(UInt(width=Flo.Width), FloToBits, this.ref))
-  private[Chisel] def toType = "Flo"
-  def cloneType: this.type = new Flo(dir).asInstanceOf[this.type]
-
-  def fromInt(x: Int): Flo =
-    Flo(x.toFloat).asInstanceOf[this.type]
-
-  def unary_-(): Flo = unop(FloNeg)
-  def +  (b: Flo): Flo = binop(FloAdd, b)
-  def -  (b: Flo): Flo = binop(FloSub, b)
-  def *  (b: Flo): Flo = binop(FloMul, b)
-  def /  (b: Flo): Flo = binop(FloDiv, b)
-  def %  (b: Flo): Flo = binop(FloMod, b)
-  def ===(b: Flo): Bool = compop(FloEqual, b)
-  def != (b: Flo): Bool = compop(FloNotEqual, b)
-  def >  (b: Flo): Bool = compop(FloGreater, b)
-  def <  (b: Flo): Bool = compop(FloLess, b)
-  def <= (b: Flo): Bool = compop(FloLessEqual, b)
-  def >= (b: Flo): Bool = compop(FloGreaterEqual, b)
-  def pow (b: Flo): Flo = binop(FloPow, b)
-  def sin: Flo = unop(FloSin)
-  def cos: Flo = unop(FloCos)
-  def tan: Flo = unop(FloTan)
-  def asin: Flo = unop(FloAsin)
-  def acos: Flo = unop(FloAcos)
-  def atan: Flo = unop(FloAtan)
-  def sqrt: Flo = unop(FloSqrt)
-  def floor: Flo = unop(FloFloor)
-  def ceil: Flo = unop(FloCeil)
-  def round: Flo = unop(FloRound)
-  def log: Flo = unop(FloLog)
-}
-
-/// DBL
-
-import java.lang.Double.doubleToLongBits
-
-object Dbl {
-  val Width = 64
-
-  def apply(x: Float): Dbl = Dbl(x.toDouble);
-  def apply(x: Double): Dbl = new Dbl(NO_DIR, Some(DblLit(x)))
-  def apply(dir: Direction = NO_DIR): Dbl = new Dbl(dir)
-}
-
-object DblPrimOp {
-  val DblNeg = PrimOp("dbl-neg")
-  val DblAdd = PrimOp("dbl-add")
-  val DblSub = PrimOp("dbl-sub")
-  val DblMul = PrimOp("dbl-mul")
-  val DblDiv = PrimOp("dbl-div")
-  val DblMod = PrimOp("dbl-mod")
-  val DblEqual = PrimOp("dbl-equal")
-  val DblNotEqual = PrimOp("dbl-not-equal")
-  val DblGreater = PrimOp("dbl-greater")
-  val DblLess = PrimOp("dbl-less")
-  val DblLessEqual = PrimOp("dbl-less-equal")
-  val DblGreaterEqual = PrimOp("dbl-greater-equal")
-  val DblPow = PrimOp("dbl-pow")
-  val DblSin = PrimOp("dbl-sin")
-  val DblCos = PrimOp("dbl-cos")
-  val DblTan = PrimOp("dbl-tan")
-  val DblAsin = PrimOp("dbl-asin")
-  val DblAcos = PrimOp("dbl-acos")
-  val DblAtan = PrimOp("dbl-atan")
-  val DblSqrt = PrimOp("dbl-sqrt")
-  val DblFloor = PrimOp("dbl-floor")
-  val DblCeil = PrimOp("dbl-ceil")
-  val DblRound = PrimOp("dbl-round")
-  val DblLog = PrimOp("dbl-log")
-  val DblToBits = PrimOp("dbl-to-bits")
-  val BitsToDbl = PrimOp("bits-to-dbl")
-}
-import DblPrimOp._
-
-class Dbl(dir: Direction, val value: Option[DblLit] = None) extends FloBase[Dbl](dir, Width(Dbl.Width)) with Num[Dbl] {
-  type T = Dbl;
-  def dblLitValue: Double = value.get.num
-  def cloneTypeWidth(width: Width): this.type = cloneType
-  override def fromBits(n: Bits): this.type =
-    pushOp(DefPrim(cloneType, BitsToDbl, this.ref)).asInstanceOf[this.type]
-  override def toBits: UInt =
-    pushOp(DefPrim(UInt(width=Dbl.Width), DblToBits, this.ref))
-  private[Chisel] def toType = "Dbl"
-  def cloneType: this.type = new Dbl(dir).asInstanceOf[this.type]
-
-  def fromInt(x: Int): this.type =
-    Dbl(x.toDouble).asInstanceOf[this.type]
-
-  def unary_-(): Dbl = unop(DblNeg)
-  def +  (b: Dbl): Dbl = binop(DblAdd, b)
-  def -  (b: Dbl): Dbl = binop(DblSub, b)
-  def *  (b: Dbl): Dbl = binop(DblMul, b)
-  def /  (b: Dbl): Dbl = binop(DblDiv, b)
-  def %  (b: Dbl): Dbl = binop(DblMod, b)
-  def ===(b: Dbl): Bool = compop(DblEqual, b)
-  def != (b: Dbl): Bool = compop(DblNotEqual, b)
-  def >  (b: Dbl): Bool = compop(DblGreater, b)
-  def <  (b: Dbl): Bool = compop(DblLess, b)
-  def <= (b: Dbl): Bool = compop(DblLessEqual, b)
-  def >= (b: Dbl): Bool = compop(DblGreaterEqual, b)
-  def pow (b: Dbl): Dbl = binop(DblPow, b)
-  def sin: Dbl = unop(DblSin)
-  def cos: Dbl = unop(DblCos)
-  def tan: Dbl = unop(DblTan)
-  def asin: Dbl = unop(DblAsin)
-  def acos: Dbl = unop(DblAcos)
-  def atan: Dbl = unop(DblAtan)
-  def sqrt: Dbl = unop(DblSqrt)
-  def floor: Dbl = unop(DblFloor)
-  def ceil: Dbl = unop(DblCeil)
-  def round: Dbl = unop(DblRound)
-  def log: Dbl = unop(DblLog)
-}
-
-object Sin {
-  def apply (x: Flo): Flo = x.sin
-  def apply (x: Dbl): Dbl = x.sin
-}
-
-object Cos {
-  def apply (x: Flo): Flo = x.cos
-  def apply (x: Dbl): Dbl = x.cos
-}
-
-object Tan {
-  def apply (x: Flo): Flo = x.tan
-  def apply (x: Dbl): Dbl = x.tan
-}
-
-object ASin {
-  def apply (x: Flo): Flo = x.asin
-  def apply (x: Dbl): Dbl = x.asin
-}
-
-object ACos {
-  def apply (x: Flo): Flo = x.acos
-  def apply (x: Dbl): Dbl = x.acos
-}
-
-object ATan {
-  def apply (x: Flo): Flo = x.atan
-  def apply (x: Dbl): Dbl = x.atan
-}
-
-object Sqrt {
-  def apply (x: Flo): Flo = x.sqrt
-  def apply (x: Dbl): Dbl = x.sqrt
-}
-
-object Floor {
-  def apply (x: Flo): Flo = x.floor
-  def apply (x: Dbl): Dbl = x.floor
-}
-
-object Ceil {
-  def apply (x: Flo): Flo = x.ceil
-  def apply (x: Dbl): Dbl = x.ceil
-}
-
-object Round {
-  def apply (x: Flo): Flo = x.round
-  def apply (x: Dbl): Dbl = x.round
-}
-
-object Log {
-  def apply (x: Flo): Flo = x.log
-  def apply (x: Dbl): Dbl  = x.log
-  def apply (x: Flo, p: Flo): Flo = Log(x)/Log(p)
-  def apply (x: Dbl, p: Dbl): Dbl = Log(x)/Log(p)
-}
-
-object Pow {
-  def apply (x: Flo, y: Flo): Flo = x.pow(y)
-  def apply (x: Dbl, y: Dbl): Dbl = x.pow(y)
-}