¿Como estáis de aritmética de mas de 32 bits? (En CCS)

[RedPic]

Droky, eres un genio. Te debo una (otra). 

Casi dos años después me he visto en la obligación de retomar este tema, aunque en este caso con 56 bits en vez de 40, y tu solución es la solución.

Efectivamente, he realizado la conversión "directa" de los 32 bits de menor peso, lo he guardado en decimal sobre un string de "resultado" utilizando el sprintf() y después con una tabla de potencias de dos para los bits de mas peso, entre el 33 y el 56, he ido sumando en ASCII exactamente igual que hacíamos en el colegio "con manzanas"     

Como dicen que "de bien nacidos es ser agradecidos" aquí tienes mi agradecimiento público y efusivo. Gracias, gracias, muchas gracias. 

Este es el código:

Nota: Los bits los tengo en un bitsArray y los extraigo uno a uno mediante la función get_array_bit()

Código: C#

1. int8  i,j,d1,d2,r,carry;
2.    int32 first_code;
3.    char  OutPut[19]="000000000000000000";
4.    const char  Pots2[24][19]={      
5.                     "036028797018963968",
6.                     "018014398509481984",
7.                     "009007199254740992",
8.                     "004503599627370496",
9.                     "002251799813685248",
10.                     "001125899906842624",
11.                     "000562949953421312",
12.                     "000281474976710656",
13.                     "000140737488355328",
14.                     "000070368744177664",
15.                     "000035184372088832",
16.                     "000017592186044416",
17.                     "000008796093022208",
18.                     "000004398046511104",
19.                     "000002199023255552",
20.                     "000001099511627776",
21.                     "000000549755813888",
22.                     "000000274877906944",
23.                     "000000137438953472",
24.                     "000000068719476736",
25.                     "000000034359738368",
26.                     "000000017179869184",
27.                     "000000008589934592",
28.                     "000000004294967296"};
29.    
30.    // Primeros 32 bits. conversión directa.
31.    first_code=0;
32.    for(i=55;i>23;i--){
33.      //bit_clear(Code,31-i);
34.      if(get_array_bit(bitsArray,i)==1){
35.        bit_set(first_code,55-i);
36.      }
37.    }
38.    sprintf(OutPut,"%18Lu",first_code);
39.    replace_char(' ','0',OutPut);
40.    printf("<%s>\r\n",OutPut);
41.    // Últimos 24 bits. conversión por sumas sucesivas mediante tabla de potencias de 2.
42.    for(i=0;i<24;i++){
43.       if(get_array_bit(bitsArray,i)==1){
44.          carry = 0;
45.          for(j=17;j>0;j--){
46.             d1=OutPut[j]-'0';
47.             d2=Pots2[i][j]-'0';
48.             r = (int) (d1 + d2) + carry;
49.             carry = 0;
50.             if(r > 9){
51.                r -= 10;
52.                carry = 1;
53.             }
54.             printf("<%u/%u : %u + %u = %u Carry %u>\r\n",i,j,d1,d2,r,carry);
55.             OutPut[j]=r+'0';
56.          }
57.       }
58.    }      
59.    printf("<%s>\r\n",OutPut);

Le he metido printf()´s por medio para poder monitorizar la secuencia completa. Aquí tenéis un ejemplo de su ejecución:

Código: ASM

1. Dados los bits: 10000000001000010100000000000010100000100011011000000100
2. Correspondientes al decimal : 036065355822675460
3. <Bit/ASCII : Sumando1 + Sumando2 = Resultado Carry Acarreo>
4.  
5. <000000000042087940>
6. <0/17 : 0 + 8 = 8 Carry 0>
7. <0/16 : 4 + 6 = 0 Carry 1>
8. <0/15 : 9 + 9 = 9 Carry 1>
9. <0/14 : 7 + 3 = 1 Carry 1>
10. <0/13 : 8 + 6 = 5 Carry 1>
11. <0/12 : 0 + 9 = 0 Carry 1>
12. <0/11 : 2 + 8 = 1 Carry 1>
13. <0/10 : 4 + 1 = 6 Carry 0>
14. <0/9 : 0 + 0 = 0 Carry 0>
15. <0/8 : 0 + 7 = 7 Carry 0>
16. <0/7 : 0 + 9 = 9 Carry 0>
17. <0/6 : 0 + 7 = 7 Carry 0>
18. <0/5 : 0 + 8 = 8 Carry 0>
19. <0/4 : 0 + 2 = 2 Carry 0>
20. <0/3 : 0 + 0 = 0 Carry 0>
21. <0/2 : 0 + 6 = 6 Carry 0>
22. <0/1 : 0 + 3 = 3 Carry 0>
23. <10/17 : 8 + 2 = 0 Carry 1>
24. <10/16 : 0 + 3 = 4 Carry 0>
25. <10/15 : 9 + 8 = 7 Carry 1>
26. <10/14 : 1 + 8 = 0 Carry 1>
27. <10/13 : 5 + 8 = 4 Carry 1>
28. <10/12 : 0 + 0 = 1 Carry 0>
29. <10/11 : 1 + 2 = 3 Carry 0>
30. <10/10 : 6 + 7 = 3 Carry 1>
31. <10/9 : 0 + 3 = 4 Carry 0>
32. <10/8 : 7 + 4 = 1 Carry 1>
33. <10/7 : 9 + 8 = 8 Carry 1>
34. <10/6 : 7 + 1 = 9 Carry 0>
35. <10/5 : 8 + 5 = 3 Carry 1>
36. <10/4 : 2 + 3 = 6 Carry 0>
37. <10/3 : 0 + 0 = 0 Carry 0>
38. <10/2 : 6 + 0 = 6 Carry 0>
39. <10/1 : 3 + 0 = 3 Carry 0>
40. <15/17 : 0 + 6 = 6 Carry 0>
41. <15/16 : 4 + 7 = 1 Carry 1>
42. <15/15 : 7 + 7 = 5 Carry 1>
43. <15/14 : 0 + 7 = 8 Carry 0>
44. <15/13 : 4 + 2 = 6 Carry 0>
45. <15/12 : 1 + 6 = 7 Carry 0>
46. <15/11 : 3 + 1 = 4 Carry 0>
47. <15/10 : 3 + 1 = 4 Carry 0>
48. <15/9 : 4 + 5 = 9 Carry 0>
49. <15/8 : 1 + 9 = 0 Carry 1>
50. <15/7 : 8 + 9 = 8 Carry 1>
51. <15/6 : 9 + 0 = 0 Carry 1>
52. <15/5 : 3 + 1 = 5 Carry 0>
53. <15/4 : 6 + 0 = 6 Carry 0>
54. <15/3 : 0 + 0 = 0 Carry 0>
55. <15/2 : 6 + 0 = 6 Carry 0>
56. <15/1 : 3 + 0 = 3 Carry 0>
57. <17/17 : 6 + 4 = 0 Carry 1>
58. <17/16 : 1 + 4 = 6 Carry 0>
59. <17/15 : 5 + 9 = 4 Carry 1>
60. <17/14 : 8 + 6 = 5 Carry 1>
61. <17/13 : 6 + 0 = 7 Carry 0>
62. <17/12 : 7 + 9 = 6 Carry 1>
63. <17/11 : 4 + 7 = 2 Carry 1>
64. <17/10 : 4 + 7 = 2 Carry 1>
65. <17/9 : 9 + 8 = 8 Carry 1>
66. <17/8 : 0 + 4 = 5 Carry 0>
67. <17/7 : 8 + 7 = 5 Carry 1>
68. <17/6 : 0 + 2 = 3 Carry 0>
69. <17/5 : 5 + 0 = 5 Carry 0>
70. <17/4 : 6 + 0 = 6 Carry 0>
71. <17/3 : 0 + 0 = 0 Carry 0>
72. <17/2 : 6 + 0 = 6 Carry 0>
73. <17/1 : 3 + 0 = 3 Carry 0>
74. <036065355822675460>

Sois lo mejor.