// 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)
}