michalkowalczyk

Untitled

Apr 18th, 2021
396
149 days
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1.  
  2. #include "main.h"
  3. #include <stdint.h>
  4. #include <stdio.h>
  5. #include <string.h>
  6. #include <float.h>
  7. #include <stdbool.h>
  8.  
  9.  
  10.  
  11. typedef union {
  12.     float f;
  13.     struct {
  14.         uint32_t mantisa:23;
  15.         uint32_t exponent:8;
  16.         uint32_t sign:1;
  17.     }parts;
  18. }float_cast;
  19.  
  20.  
  21.  
  22.  
  23.  
  24.  
  25. const uint32_t exponent_length = 9;
  26. const uint32_t mantisa_length = 23;
  27.  
  28. const uint32_t sign_b = 0b10000000000000000000000000000000;
  29. const uint32_t exponent_b = 0b01111111100000000000000000000000;
  30. const uint32_t mantisa_b = 0b00000000011111111111111111111111;
  31.  
  32.  
  33.  
  34. float addition(float num1,float num2);
  35. float subtraction(float num1,float num2);
  36. uint32_t multiply(float num1,float num2);
  37. uint32_t divide(float num1,float num2);
  38.  
  39.  
  40.  
  41. int main(void) {
  42.  
  43.  
  44.  
  45.  
  46.  
  47.     float num1 = 8453.00342;
  48.     float num2 = -19.4350023;
  49.  
  50.  
  51.  
  52.  
  53.  
  54.  
  55.  
  56.       trace_printf("Dodawanie: %f\n",addition(num1, num2));
  57.       trace_printf("Odejmowanie: %f\n",subtraction(num1, num2));
  58.  
  59.  
  60.  
  61.       uint32_t result = multiply(num1, num2);
  62.  
  63.  
  64.       float resF;
  65.      memcpy(&resF, &result, 4);
  66.      trace_printf("Mnozenie: %f\n", resF);
  67.  
  68.      result =divide(num1, num2);
  69.      memcpy(&resF, &result, 4);
  70.  
  71.  
  72.       trace_printf("Dzielenie: %f\n",resF );
  73.  
  74.  
  75.  
  76.  
  77.  
  78.     while (1) {
  79.  
  80.     }
  81. }
  82.  
  83.  
  84.  
  85.  
  86.  
  87.  
  88.  
  89.  
  90.  
  91.  
  92. float addition(float num1,float num2)
  93. {
  94.     float_cast a = {.f=num1};
  95.     float_cast b = {.f=num2};
  96.     float_cast result;
  97.  
  98.     if (num1<num2) return addition(num2,num1);
  99.     if (num1<0.0) return -addition(-num1,-num2);
  100.     if (num2<0.0) return subtraction(num1,-num2);
  101.  
  102.     uint32_t man_a=(1<<23)+a.parts.mantisa;
  103.     uint32_t man_b=(1<<23)+b.parts.mantisa;
  104.     int exp_res=a.parts.exponent - b.parts.exponent;
  105.     man_b=man_b>>exp_res;
  106.  
  107.     uint32_t man_res = man_a + man_b;
  108.  
  109.  
  110.     result.parts.sign=0;
  111.     if (man_res&(1<<24)) {
  112.         result.parts.exponent=a.parts.exponent+1;
  113.         result.parts.mantisa=man_res>>1;
  114.     } else {
  115.         result.parts.exponent=b.parts.exponent;
  116.         result.parts.mantisa=man_res;
  117.     }
  118.     return result.f;
  119. }
  120.  
  121. float subtraction(float num1,float num2)
  122. {
  123.     float_cast a={.f=num1};
  124.     float_cast b={.f=num2};
  125.     float_cast result;
  126.  
  127.     if (num1<num2) return -subtraction(num2,num1);
  128.     if (num1<0.0) return -subtraction(-num1,-num2);
  129.     if (num2<0.0) return addition(num1,-num2);
  130.  
  131.     uint32_t man_a=(1<<23)+a.parts.mantisa;
  132.     uint32_t man_b=(1<<23)+b.parts.mantisa;
  133.     int exp_res=a.parts.exponent - b.parts.exponent;
  134.     man_b=man_b>>exp_res;
  135.  
  136.     uint32_t man_res = man_a - man_b;
  137.  
  138.     result.parts.sign=0;
  139.     result.parts.exponent=a.parts.exponent;
  140.     result.parts.mantisa=man_res;
  141.     return result.f;
  142.  
  143.  
  144. }
  145.  
  146.  
  147.  
  148.  
  149. uint32_t multiply(float num1, float num2)
  150. {
  151.     uint32_t a, b;
  152.     memcpy(&a, &num1, 4);
  153.     memcpy(&b, &num2, 4);
  154.  
  155.  
  156.     unsigned char exp1 = ((a & exponent_b) >> mantisa_length);
  157.     unsigned char exp2 = ((b & exponent_b) >> mantisa_length);
  158.  
  159.     uint32_t s = (a & sign_b) ^ (b & sign_b);
  160.     uint32_t exp_res = (((exp1 + exp2) - 127) << mantisa_length) & exponent_b;
  161.  
  162.     uint32_t m1 = (a & mantisa_b) + (1 << 23);
  163.     uint32_t m2 = (b & mantisa_b) + (1 << 23);
  164.  
  165.  
  166.     uint32_t var = 0;
  167.       for (uint32_t i = 0; i < 24; i++) {
  168.           uint32_t bit = (m1 << (8 + i)) & sign_b;
  169.           if (bit) {
  170.               var += m2 >> i;
  171.           }
  172.       }
  173.  
  174.       uint32_t normal_bit;
  175.           for (normal_bit = 0; normal_bit < 9; normal_bit++)
  176.                   {
  177.               uint32_t bit = (var << normal_bit) & sign_b;
  178.               if (bit) {
  179.                   break;
  180.               }
  181.           }
  182.  
  183.  
  184.     exp_res += (8-normal_bit) << mantisa_length;
  185.     var >>= 8-normal_bit;
  186.     return  exp_res + (var & mantisa_b) + s;
  187.  
  188.  
  189.  
  190.  
  191. }
  192.  
  193.  
  194.  
  195. uint32_t divide(float num1,float num2)
  196. {
  197.  
  198.     uint32_t a, b;
  199.     memcpy(&a, &num1, 4);
  200.     memcpy(&b, &num2, 4);
  201.  
  202.     char exp1 = ((a & exponent_b) >> mantisa_length);
  203.     char exp2 = ((b & exponent_b) >> mantisa_length);
  204.  
  205.     uint32_t exp_res = (((exp1 - exp2) + 127) << mantisa_length) & exponent_b;
  206.  
  207.     uint32_t man1 = (a & mantisa_b) + (1 << 23);
  208.     uint32_t man2 = (b & mantisa_b) + (1 << 23);
  209.  
  210.  
  211.  
  212.     uint32_t var = 0;
  213.        uint32_t res = man1;
  214.        for (uint32_t i = 0; i < 24; i++) {
  215.            uint32_t temp = res - (man2 >> i) & sign_b;
  216.            if (!temp) {
  217.                var += 1 << (23 - i);
  218.                res -= man2 >> i;
  219.            }
  220.        }
  221.  
  222.  
  223.  
  224.  
  225.        uint32_t norm_bit;
  226.           for (norm_bit = 0; norm_bit < 24; norm_bit++) {
  227.               uint32_t bit = (var << (norm_bit + 8)) & sign_b;
  228.               if (bit) {
  229.                   break;
  230.               }
  231.           }
  232.  
  233.     exp_res -= (norm_bit) << mantisa_length;
  234.     var <<= norm_bit;
  235.  
  236.     return exp_res + (var&mantisa_b) + ((a & sign_b) ^ (b & sign_b));
  237.  
  238.  
  239. }
  240.  
RAW Paste Data

Adblocker detected! Please consider disabling it...

We've detected AdBlock Plus or some other adblocking software preventing Pastebin.com from fully loading.

We don't have any obnoxious sound, or popup ads, we actively block these annoying types of ads!

Please add Pastebin.com to your ad blocker whitelist or disable your adblocking software.

×