#include <stdlib.h>
#include <stdio.h>
#include "bfp754.h"

   /* Minimum normalised float */
#define FLT_MIN 1.17549435e-38F
   /* Maximum float */
#define FLT_MAX 3.40282347e+38F

   /* Minimum normalised double */
#define DBL_MIN 2.2250738585072014e-308
   /* Maximum double */
#define DBL_MAX 1.7976931348623157e+308

typedef union {
   float fp;
   unsigned int bits;
} fp32_val_t;

typedef union {
   double fp;
   unsigned long long int bits;
} fp64_val_t;

int main(int argc, char ** argv) {
///////////////////  SINGLE PRECISION TESTS ////////////////////////
   // Single Precision
   fp32_val_t single = {0x0};
   char  str[256] = "";
   char * testStr = &(str[0]);

   // Minimum Positive 32-bit Normal Value
   printf("Min Pos 32-bit Normal:\n");
   single.fp = FLT_MIN;
   __binary32_to_hexstring(testStr,single.fp);
   printf("%e (0x%08X) --> %s\n", single.fp, single.bits, testStr);

   testStr = "0x1.000000P-126";
   single.fp = __binary32_from_hexstring(testStr);
   printf("%s --> %e (0x%08X)\n", testStr, single.fp, single.bits);
   printf("\n");

   // Minimum Negative 32-bit Normal Value
   printf("Min Neg 32-bit Normal:\n");
   single.fp = FLT_MIN * -1.f;
   testStr = &(str[0]);
   __binary32_to_hexstring(testStr,single.fp);
   printf("%e (0x%08X) --> %s\n", single.fp, single.bits, testStr);

   testStr = "-0x1.000000P-126";
   single.fp = __binary32_from_hexstring(testStr);
   printf("%s --> %e (0x%08X)\n", testStr, single.fp, single.bits);
   printf("\n");

   // Maximum Positive 32-bit Normal Value
   printf("Max Pos 32-bit Normal:\n");
   single.fp = FLT_MAX;
   testStr = &(str[0]);
   __binary32_to_hexstring(testStr,single.fp);
   printf("%e (0x%08X) --> %s\n", single.fp, single.bits, testStr);

   testStr = "0x1.7FFFFFP127";
   single.fp = __binary32_from_hexstring(testStr);
   printf("%s --> %e (0x%08X)\n", testStr, single.fp, single.bits);
   testStr = "0x1.FFFFFEP127";
   single.fp = __binary32_from_hexstring(testStr);
   printf("%s --> %e (0x%08X)\n", testStr, single.fp, single.bits);

   printf("\n");

   // Maximum Negative 32-bit Normal Value
   printf("Max Neg 32-bit Normal:\n");
   single.fp = FLT_MAX * -1.f;
   testStr = &(str[0]);
   __binary32_to_hexstring(testStr,single.fp);
   printf("%e (0x%08X) --> %s\n", single.fp, single.bits, testStr);

   testStr = "-0x1.7FFFFFP127";
   single.fp = __binary32_from_hexstring(testStr);
   printf("%s --> %e (0x%08X)\n", testStr, single.fp, single.bits);
   testStr = "-0x1.FFFFFEP127";
   single.fp = __binary32_from_hexstring(testStr);
   printf("%s --> %e (0x%08X)\n", testStr, single.fp, single.bits);
   printf("\n");

   // Minimum Positive 32-bit SubNormal Value
   printf("Min Pos 32-bit SubNormal:\n");
   single.fp = 1.40129846e-45;
   testStr = &(str[0]);
   __binary32_to_hexstring(testStr,single.fp);
   printf("%e (0x%08X) --> %s\n", single.fp, single.bits, testStr);

   testStr = "0x0.000001P-127";
   single.fp = __binary32_from_hexstring(testStr);
   printf("%s --> %e (0x%08X)\n", testStr, single.fp, single.bits);
   testStr = "0x0.000002P-126";
   single.fp = __binary32_from_hexstring(testStr);
   printf("%s --> %e (0x%08X)\n", testStr, single.fp, single.bits);
   printf("\n");

   // Minimum Negative 32-bit SubNormal Value
   printf("Min Neg 32-bit SubNormal:\n");
   single.fp = -1.40129846e-45;
   testStr = &(str[0]);
   __binary32_to_hexstring(testStr,single.fp);
   printf("%e (0x%08X) --> %s\n", single.fp, single.bits, testStr);

   testStr = "-0x0.000001P-127";
   single.fp = __binary32_from_hexstring(testStr);
   printf("%s --> %e (0x%08X)\n", testStr, single.fp, single.bits);
   testStr = "-0x0.000002P-126";
   single.fp = __binary32_from_hexstring(testStr);
   printf("%s --> %e (0x%08X)\n", testStr, single.fp, single.bits);
   testStr = "-0x0.2P-126";
   single.fp = __binary32_from_hexstring(testStr);
   printf("%s --> %e (0x%08X)\n", testStr, single.fp, single.bits);
   printf("\n");

   // Maximum Positive 32-bit SubNormal Value
   printf("Max Pos 32-bit SubNormal:\n");
   single.fp = 1.17549421e-38;
   testStr = &(str[0]);
   __binary32_to_hexstring(testStr,single.fp);
   printf("%e (0x%08X) --> %s\n", single.fp, single.bits, testStr);

   testStr = "0x0.7FFFFFP-127";
   single.fp = __binary32_from_hexstring(testStr);
   printf("%s --> %e (0x%08X)\n", testStr, single.fp, single.bits);
   testStr = "0x0.FFFFFEP-126";
   single.fp = __binary32_from_hexstring(testStr);
   printf("%s --> %e (0x%08X)\n", testStr, single.fp, single.bits);
   printf("\n");

   // Maximum Negative 32-bit SubNormal Value
   printf("Max Neg 32-bit SubNormal:\n");
   single.fp = -1.17549421e-38;
   testStr = &(str[0]);
   __binary32_to_hexstring(testStr,single.fp);
   printf("%e (0x%08X) --> %s\n", single.fp, single.bits, testStr);

   testStr = "-0x0.7FFFFFP-127";
   single.fp = __binary32_from_hexstring(testStr);
   printf("%s --> %e (0x%08X)\n", testStr, single.fp, single.bits);
   testStr = "-0x0.FFFFFEP-126";
   single.fp = __binary32_from_hexstring(testStr);
   printf("%s --> %e (0x%08X)\n", testStr, single.fp, single.bits);
   printf("\n");

///////////////////  DOUBLE PRECISION TESTS ////////////////////////

   // Double Precision
   fp64_val_t doub = {0x0};

   // Minimum Positive 64-bit Normal Value
   printf("Min Pos 64-bit Normal:\n");
   doub.fp = DBL_MIN;
   testStr = &(str[0]);
   __binary64_to_hexstring(testStr,doub.fp);
   printf("%e (0x%016lX) --> %s\n", doub.fp, doub.bits, testStr);

   testStr = "0x1.0000000000000P-1022";
   doub.fp = __binary64_from_hexstring(testStr);
   printf("%s --> %e (0x%016lX)\n", testStr, doub.fp, doub.bits);
   printf("\n");

   // Minimum Negative 64-bit Normal Value
   printf("Min Neg 64-bit Normal:\n");
   doub.fp = DBL_MIN * -1.f;
   testStr = &(str[0]);
   __binary64_to_hexstring(testStr,doub.fp);
   printf("%e (0x%016lX) --> %s\n", doub.fp, doub.bits, testStr);

   testStr = "-0x1.0000000000000P-1022";
   doub.fp = __binary64_from_hexstring(testStr);
   printf("%s --> %e (0x%016lX)\n", testStr, doub.fp, doub.bits);
   printf("\n");

   // Maximum Positive 64-bit Normal Value
   printf("Max Pos 64-bit Normal:\n");
   doub.fp = DBL_MAX;
   testStr = &(str[0]);
   __binary64_to_hexstring(testStr,doub.fp);
   printf("%e (0x%016lX) --> %s\n", doub.fp, doub.bits, testStr);

   testStr = "0x1.FFFFFFFFFFFFFP1023";
   doub.fp = __binary64_from_hexstring(testStr);
   printf("%s --> %e (0x%016lX)\n", testStr, doub.fp, doub.bits);

   printf("\n");

   // Maximum Negative 64-bit Normal Value
   printf("Max Neg 64-bit Normal:\n");
   doub.fp = DBL_MAX * -1.f;
   testStr = &(str[0]);
   __binary64_to_hexstring(testStr,doub.fp);
   printf("%e (0x%016lX) --> %s\n", doub.fp, doub.bits, testStr);

   testStr = "-0x1.FFFFFFFFFFFFFP1023";
   doub.fp = __binary64_from_hexstring(testStr);
   printf("%s --> %e (0x%016lX)\n", testStr, doub.fp, doub.bits);
   printf("\n");

   // Minimum Positive 64-bit SubNormal Value
   printf("Min Pos 64-bit SubNormal:\n");
   doub.fp = 4.9406564584124654e-324;
   testStr = &(str[0]);
   __binary64_to_hexstring(testStr,doub.fp);
   printf("%e (0x%016lX) --> %s\n", doub.fp, doub.bits, testStr);

   testStr = "0x0.0000000000001P-1022";
   doub.fp = __binary64_from_hexstring(testStr);
   printf("%s --> %e (0x%016lX)\n", testStr, doub.fp, doub.bits);
   testStr = "0x0.0000000000001P-1021";
   doub.fp = __binary64_from_hexstring(testStr);
   printf("%s --> %e (0x%016lX)\n", testStr, doub.fp, doub.bits);
   printf("\n");

   // Minimum Negative 64-bit SubNormal Value
   printf("Min Neg 64-bit SubNormal:\n");
   doub.fp = -4.9406564584124654e-324;
   testStr = &(str[0]);
   __binary64_to_hexstring(testStr,doub.fp);
   printf("%e (0x%016lX) --> %s\n", doub.fp, doub.bits, testStr);

   testStr = "-0x0.0000000000001P-1022";
   doub.fp = __binary64_from_hexstring(testStr);
   printf("%s --> %e (0x%016lX)\n", testStr, doub.fp, doub.bits);
   testStr = "-0x0.0000000000001P-1021";
   doub.fp = __binary64_from_hexstring(testStr);
   printf("%s --> %e (0x%016lX)\n", testStr, doub.fp, doub.bits);

   // Maximum Positive 64-bit SubNormal Value
   printf("Max Pos 64-bit SubNormal:\n");
   doub.fp = 2.2250738585072009e-308;
   testStr = &(str[0]);
   __binary64_to_hexstring(testStr,doub.fp);
   printf("%e (0x%016lX) --> %s\n", doub.fp, doub.bits, testStr);

   testStr = "0x0.FFFFFFFFFFFFFP-1022";
   doub.fp = __binary64_from_hexstring(testStr);
   printf("%s --> %e (0x%016lX)\n", testStr, doub.fp, doub.bits);
   testStr = "0x0.FFFFFFFFFFFFFP-1021";
   doub.fp = __binary64_from_hexstring(testStr);
   printf("%s --> %e (0x%016lX)\n", testStr, doub.fp, doub.bits);
   printf("\n");

   // Maximum Negative 64-bit SubNormal Value
   printf("Max Neg 64-bit SubNormal:\n");
   doub.fp = -2.2250738585072009e-308;
   testStr = &(str[0]);
   __binary64_to_hexstring(testStr,doub.fp);
   printf("%e (0x%016lX) --> %s\n", doub.fp, doub.bits, testStr);

   testStr = "-0x0.FFFFFFFFFFFFFP-1022";
   doub.fp = __binary64_from_hexstring(testStr);
   printf("%s --> %e (0x%016lX)\n", testStr, doub.fp, doub.bits);
   testStr = "-0x0.FFFFFFFFFFFFFP-1021";
   doub.fp = __binary64_from_hexstring(testStr);
   printf("%s --> %e (0x%016lX)\n", testStr, doub.fp, doub.bits);
   printf("\n");


   return 0;
}