/*

** Copyright (C) 2018 Martin Brain

**

** See the file LICENSE for licensing information.

*/

/*

** convert.h

**

** Martin Brain

** martin.brain@cs.ox.ac.uk

** 03/02/14

**

** Conversion from unpacked floats in one format to another.

**

*/

#include "symfpu/core/unpackedFloat.h"

#include "symfpu/core/rounder.h"

#ifndef SYMFPU_CONVERT

#define SYMFPU_CONVERT

namespace symfpu {

template <class t>

				      const typename t::fpt &targetFormat,

				      const typename t::rm &roundingMode,

				      const unpackedFloat<t> &input) {

  typedef typename t::bwt bwt;

  //typedef typename t::prop prop;

  //typedef typename t::ubv ubv;

  //typedef typename t::sbv sbv;

  // increased includes equality

  // Format sizes are literal so it is safe to branch on them

    // Fast path strict promotions

  } else {

				unpackedFloat<t>::makeNaN(targetFormat),

				    unpackedFloat<t>::makeInf(targetFormat, input.getSign()),

					unpackedFloat<t>::makeZero(targetFormat, input.getSign()),

					rounded))));

  }

}

template <class t>

				  const typename t::rm &roundingMode,

				  const unpackedFloat<t> &input) {

  typedef typename t::bwt bwt;

  typedef typename t::prop prop;

  typedef typename t::ubv ubv;

  typedef typename t::sbv sbv;

  // Fast path for things that must be integral

  // TODO : fast path the cases that don't round up

  // Otherwise, compute rounding location

				      unpackedSigWidth.extend(1).increment()));

  // Round

		    collaredRoundingPoint.toUnsigned().matchWidth(significand) :

		    collaredRoundingPoint.toUnsigned().extract(significandWidth - 1, 0));

  // Extract is safe because of the collar

								     roundingPoint,

								     prop(false), // TODO : Could actually be exponent >= 0

								     isID));      // The fast-path case so just deactives some code

  // Reconstruct

  // Note this is not in a valid form if significand is all zeros

  // The max is necessary to catch cases when we round up to one from very small numbers

  // The rounder ensures these are zero if they don't round up

				 max<t>(conditionalIncrement<t>(roundedResult.incrementExponent, exponent),

					sbv::zero(exponentWidth)),

				 roundedResult.significand);

			      input,

				  unpackedFloat<t>::makeZero(format, input.getSign()),

				  reconstructed)));

  #if 0

  // increased includes equality

  bool exponentIncreased = unpackedFloat<t>::exponentWidth(sourceFormat) <= unpackedFloat<t>::exponentWidth(targetFormat);

  bool significandIncreased = unpackedFloat<t>::significandWidth(sourceFormat) <= unpackedFloat<t>::significandWidth(targetFormat);

  bwt expExtension = (exponentIncreased) ? unpackedFloat<t>::exponentWidth(targetFormat) - unpackedFloat<t>::exponentWidth(sourceFormat) : 0;

  bwt sigExtension = (significandIncreased) ? unpackedFloat<t>::significandWidth(targetFormat) - unpackedFloat<t>::significandWidth(sourceFormat) : 0;

  unpackedFloat<t> extended(input.extend(expExtension, sigExtension));

  // Format sizes are literal so it is safe to branch on them

  if (exponentIncreased && significandIncreased) {

    // Fast path strict promotions

    POSTCONDITION(extended.valid(targetFormat));

    return extended;

  } else {

    unpackedFloat<t> rounded(rounder(targetFormat, roundingMode, extended));

    unpackedFloat<t> result(ITE(input.getNaN(),

				unpackedFloat<t>::makeNaN(targetFormat),

				ITE(input.getInf(),

				    unpackedFloat<t>::makeInf(targetFormat, input.getSign()),

				    ITE(input.getZero(),

					unpackedFloat<t>::makeZero(targetFormat, input.getSign()),

					rounded))));

    POSTCONDITION(result.valid(targetFormat));

    return result;

  }

  #endif

}

template <class t>

				      const typename t::rm &roundingMode,

				      const typename t::ubv &preInput,

				      const typename t::bwt &decimalPointPosition = 0) {

  typedef typename t::bwt bwt;

  typedef typename t::prop prop;

  typedef typename t::ubv ubv;

  typedef typename t::sbv sbv;

  typedef typename t::fpt fpt;

  // In the case of a 1 bit input(?) extend to 2 bits so that the intermediate float is a sensible format

  // Devise an appropriate format

  // Build

  // Normalise

  // Round (the conversion will catch the cases where no rounding is needed)

 }

template <class t>

				      const typename t::rm &roundingMode,

				      const typename t::sbv &input,

				      const typename t::bwt &decimalPointPosition = 0) {

  typedef typename t::bwt bwt;

  typedef typename t::prop prop;

  typedef typename t::sbv sbv;

  typedef typename t::fpt fpt;

  // Devise an appropriate format

  // Work out the sign

  // Build

  // Normalise

  // Round (the conversion will catch the cases where no rounding is needed)

 }

 // Common conversion code for both convert to sgined and to unsigned.

 // Note that the results will be junk if it is not in bounds, etc.

 // convertFloatToUBV and convertFloatToSBV handle all of that logic.

 template <class t>

						 const typename t::rm &roundingMode,

						 const unpackedFloat<t> &input,

						 const typename t::bwt &targetWidth,

						 const typename t::bwt &decimalPointPosition) {

   typedef typename t::bwt bwt;

   typedef typename t::prop prop;

   typedef typename t::ubv ubv;

   typedef typename t::sbv sbv;

   // TODO : fast path the RTZ / don't need to round case

			    exponentWidth : maxShiftBits);

   // Optimisation : compact the significand in the case targetWidth < significantWidth

   } else {

   }

   // Handle zero

                                                               // targetWidth +1 is for the guard bit

   // Align

					     sbv(workingExponentWidth, decimalPointPosition + 2)),  // +1 to guard, +1 to LSB

			     maxShiftAmount.extend(1)));

					       ).toUnsigned().matchWidth(expandedSignificand));

   // Fixed position round

							     aligned, targetWidth,

							     prop(false), prop(false)));

 }

 // A more compact version for round to zero

 // Only handles normal, subnormal and zero cases, overflow of targetWidth will give junk.

 // Inf, NaN, and overflow must be handled by the caller.

 template <class t>

   significandRounderResult<t> convertFloatToBVRTZ (const typename t::fpt &format,

						    const unpackedFloat<t> &input,

						    const typename t::bwt &targetWidth,

						    const typename t::bwt &decimalPointPosition) {

   typedef typename t::bwt bwt;

   typedef typename t::prop prop;

   typedef typename t::ubv ubv;

   typedef typename t::sbv sbv;

   PRECONDITION(targetWidth > 0);

   PRECONDITION(decimalPointPosition < targetWidth);

   // A working significand of the right length

   ubv significand(input.getSignificand());

   bwt significandWidth(significand.getWidth());

   ubv significantSignificand(significand.extract(significandWidth - 1,

						  ((targetWidth < significandWidth) ? significandWidth - targetWidth : 0)));

   bwt ssWidth(significantSignificand.getWidth());

   // Handle zero and fractional cases

   sbv exponent(input.getExponent());

   bwt exponentWidth(exponent.getWidth());

   prop fraction(input.getExponent() < sbv::zero(exponentWidth));

   ubv zerodSignificand(significantSignificand &

			ITE(input.getZero() || fraction, ubv::zero(ssWidth), ubv::allOnes(ssWidth)));

   ubv expandedSignificand(zerodSignificand.extend(targetWidth - 1)); // Start with the significand in the LSB of output

   // Prepare exponent

   bwt maxShift(targetWidth - 1); // - 1 as we are already at LSB

   bwt maxShiftBits(bitsToRepresent(maxShift)); // Don't care about it being signed

   ubv convertedExponent(exponent.toUnsigned());

   bwt topExtractedBit(((maxShiftBits >  (exponentWidth - 1)) ? exponentWidth : maxShiftBits) - 1);

   ubv shiftBits(convertedExponent.extract(topExtractedBit, 0));

   ubv shiftOperand(shiftBits.matchWidth(expandedSignificand));

   // Align

   ubv shifted(expandedSignificand.modularLeftShift(shiftOperand));

   bwt shiftedWidth(shifted.getWidth());

   // Extract

   ubv result(shifted.extract(shiftedWidth - 1, shiftedWidth - targetWidth));

   return significandRounderResult<t>(result, prop(false));

 }

 // Decimal point position in the bit in the output on the left hand side of the decimal point

 // I.E. if it is positive then it is converting to a fix-point number

 template <class t>

				      const typename t::rm &roundingMode,

				      const unpackedFloat<t> &input,

				      const typename t::bwt &targetWidth,

				      const typename t::ubv &undefValue,

				      const typename t::bwt &decimalPointPosition = 0) {

   typedef typename t::bwt bwt;

   typedef typename t::prop prop;

   typedef typename t::ubv ubv;

   typedef typename t::sbv sbv;

   // Invalid cases

			    exponentWidth : maxExponentBits);

   // Fixed position round

							targetWidth, decimalPointPosition));

   // TODO : fast path negative by converting exp==0 into guard and exp < 0 into sticky

   // Put the result together

		  undefValue,

		  rounded.significand));

 }

  // Decimal point position in the bit in the output on the left hand side of the decimal point

  // I.E. if it is positive then it is converting to a fix-point number

  template <class t>

				       const typename t::rm &roundingMode,

				       const unpackedFloat<t> &input,

				       const typename t::bwt &targetWidth,

				       const typename t::sbv &undefValue,

				       const typename t::bwt &decimalPointPosition = 0) {

   typedef typename t::bwt bwt;

   typedef typename t::prop prop;

   //typedef typename t::ubv ubv;

   typedef typename t::sbv sbv;

   // Invalid cases

			    exponentWidth : maxExponentBits);

   // Fixed position round

   // (It is tempting to think that this could be done with targetWidth - 1 bits but that

   // missed the case of things like -128.05 -> int8_t)

							targetWidth, decimalPointPosition));

   // Put the result together

			(rounded.significand.extract(roundSigWidth - 1,

		  undefValue,

 }

}

#endif