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

[RedPic]

Pues la pregunta es exactamente esa ... ¿Como estáis de aritmética de mas de 32 bits?

Me explico: De un dispositivo recojo exactamente 40 bits que representan un único número decimal equivalente. La cosa es que nunca he trabajado con mas de 32 bits y no se cómo componer un decimal de con 32+8 bits ¿En dos variables de 32 bits? ¿En una de 32 y otra de 8 y después ... ? ¿Qué?

O sea si recojo 1111111111111111111111111111111111111111 (40 "unos") tengo que generar el decimal 1.099.511.627.775 en mi super printf("%XLu") Pongo %XLu porque es un entero de tamaño XL (como las camisetas (sudaderas, remeras) para gente amplia como yo)  

Se aceptan sugerencias, ideas, conceptos y saltos jabonados de delfin.  

[Nocturno]

¿Qué necesitas hacer con ese chorizo?, ¿sólo almacenarlo e imprimirlo, o también operaciones matemáticas?

[RedPic]

¿Qué necesitas hacer con ese chorizo?, ¿sólo almacenarlo e imprimirlo, o también operaciones matemáticas?

Leo los 40 bits binarios, los convierto a decimal y transmito, uno a uno, los dígitos en ASCII del decimal (0x31,0x30,0x39,0x39 ... del decimal del ejemplo anterior 1099.... )

Ni sumo , ni resto, mi multiplico ni mucho menos divido. 

Por cierto ... ¿ sabéis algún chiste matemático, biológico y teológico ? ...

Dicen que Dios en el momento del Génesis proclamó - Creced y multiplicaos.
Y dijeron las tozudas amebas - Pues nosotras nos dividiremos.
A lo que Dios respondió - Creced y multiplicaos ... por división.

[RedPic]

Sus pongo un ejemplo real de lo que estoy enfrentando.

Recibo 40 bits : 0000000100001000010100110111100000111111
Este número binario es en decimal : 0004434655295

Pero como mi aritmética no pasa de los 32 Bits divido los 40 que recibo en dos bloques de 8 + 32 bits así que ...

Recibo 8+32 bits : 00000001     00001000010100110111100000111111
Estos números binarios son en decimal : 1 + 139687999

Y cuadran porque 1 * 2^32 + 139687999 es exactamente lo que necesito que es el 0004434655295

El problema es ... ¿como cogno genero ese 1 * 2^32? que obviamente es un número de mas de 32 bits 

[RedPic]

Y los dobles saltos mortales carpados hacia delante (también conocidos como Sukaharas) ...

Esos 40 bits pueden ser troceados de cualquier forma u manera, siempre y cuando se obtenga el valor de un dígito según su "peso" en la cifra ...

Quizir:

Si mis anteriores 40 bits los divido en 32+8 (en lugar de los 8+32) obtengo también el mismo resultado decimal

Si proceso 32+8 :  00000001000010000101001101111000   00111111
estos son en decimal 17322872 y 63

Y también cuadran perfectamente, pero esta vez como 17322872 * 2^8 + 63

Pero estamos en las mismas ya que 17322872 * 2^8 es también un número de mas de 32 bits.

 

[erdanieee]

Buenas RedPic,

si no necesitas hacer operaciones aritméticas se me ocurre la siguiente manera:
  - coges el primer bloque de 4 bits (del 0 al 3), lo conviertes a decimal (tendría 2 dígitos: x2, x1). Ej: 0xf -> 15 -> x2=1, x1=5
  - coges el segundo bloque (4-7) lo conviertes a decimal igual que antes (sean y2, y1 los dos dígitos en decimal)
  - así obtienes 2 dígitos decimales de tu conversión final, que son d1=x1, d2=primerDígito(x2+y1). Si el resultado de x2+y1 es mayor de 9 sumas uno al segundo dígito del segundo bloque (y2++).
  - repites el bucle para los siguientes bloques: bloque (4-7), que ya lo tienes convertido a decimal y modificado (si te llevabas una ) y bloque (8-11). En el último ciclo obtienes 3 dígitos en lugar de 2...


Probablemente haya una forma más sencilla de hacerlo directamente en binario, sin tener que convertir cada bloque a decimal, pero así a vista de pájaro no se me ocurre como.

saludos!!

[RedPic]

Gracias, erdanieee, voy a ver si logro entenderte (soy muy bruto y hay veces que me cuesta encontrarme la espalda) ... y ya te digo algo. Gracias, de nuevo.

[erdanieee]

no te molestes, acabo de ver que está mal lo que te he dicho! jajaja, qué desastre!

[J1M]

Diego a ver si esto te sirve:
http://www.ccsinfo.com/forum/viewtopic.php?t=28816&view=next

Lo que hace el artista de telmah es crear una variable de 64bits; Además de regalo van varias funciones de operaciones aritméticas...!

Código: [Seleccionar]

union bits64 {
   int8 b[8];
   int32 w[2];
};
typedef union bits64 int64;
int64 scratch64;
int1 BORROW=FALSE;
#bit CARRY=0xFD8.0

//Macro to add two 64bit values. Result into the first
#define M_add64x64(M_a,M_b) \
   #asm\
   movf M_b.b[0],0\
   addwf M_a.b[0],1\
   movf M_b.b[1],0\
   addwfc M_a.b[1],1\
   movf M_b.b[2],0\
   addwfc M_a.b[2],1\
   movf M_b.b[3],0\
   addwfc M_a.b[3],1\
   movf M_b.b[4],0\
   addwfc M_a.b[4],1\
   movf M_b.b[5],0\
   addwfc M_a.b[5],1\
   movf M_b.b[6],0\
   addwfc M_a.b[6],1\
   movf M_b.b[7],0\
   addwfc M_a.b[7],1\
   #endasm
//Macro as above, to subtract two 64bit values.
#define M_sub64x64(M_a,M_b) \
   #asm\
   movf M_b.b[0],0\
   subwf M_a.b[0],1\
   movf M_b.b[1],0\
   subwfb M_a.b[1],1\
   movf M_b.b[2],0\
   subwfb M_a.b[2],1\
   movf M_b.b[3],0\
   subwfb M_a.b[3],1\
   movf M_b.b[4],0\
   subwfb M_a.b[4],1\
   movf M_b.b[5],0\
   subwfb M_a.b[5],1\
   movf M_b.b[6],0\
   subwfb M_a.b[6],1\
   movf M_b.b[7],0\
   subwfb M_a.b[7],1\
   #endasm

//Macros to shift a 64bit value
#define M_shiftleft64(x) shift_left(&x,8,0)
#define M_shiftright64(x) shift_right(&x,8,0)
//Macro to zero a 64bit value
#define M_zero64(x) x.w[0]=0L;x.w[1]=0L
#define M_iszero64(x) ((x.w[0]==0L)&&(x.w[1]==0L))
#define bit64_set(x,i) x.b[i>>3]|=(1<<(i&7))

int64 cast32x64(int32 a) {
   //routine to convert a 32bit int to 64bit
   int64 temp;
   int8 i;
   temp.w[0]=a;
   //and clear the top half
   temp.w[1]=0L;
   return temp;
}

int64 I_A_LT_B(int64 a,int64 b) {
   //Internal routine to _compare_ two 64 bit values
   //Actually performs subtraction, and returns this, with the 'borrow'
   //flag in the global variable 'BORROW'. Performs a-b, hence flag is
   //set if A less than B
   M_sub64x64(a,b);
   if (CARRY==0) BORROW=TRUE;
   else BORROW=FALSE;
   return a;
}

int64 add64x64(int64 a,int64 b) {
   //simple 64 bit addition call - returns (a+b)
   M_add64x64(a,b);
   return a;
}

int64 sub64x64(int64 a,int64 b) {
   //64 bit subtraction call as above - returns (a-b)
   M_sub64x64(a,b);
   return a;
}

int64 mult32x32(int32 a,int32 b) {
   //Routine to multiply two 32bit values with a 64bit result
   int64 temp2;
   int8 i;
   //zero output
   M_zero64(temp2);
   //Not trying to break any records for efficiency, so all in C, and not using
   //hardware multiply
   //start by moving the int32, into the low half of the int64
   scratch64=cast32x64(b);
   //Now need to work through all 32 bits in the 'a' variable
   for (i=0;i<32;i++) {
      //if source bit in 'a' is one, perform addition
      if (bit_test(a,i))
         M_add64x64(temp2,scratch64);
      //rotate the second value here
      M_shiftleft64(scratch64);
   }
   return temp2;
}

int64 div64x64(int64 a,int64 b) {
   //Routine to divide 'a' by 'b' in 64bit arithmetic
   //returns with result, leaving remainder in the scratch64
   int8 bitno=0,ctr;
   int64 temp;
   if (M_iszero64(b)) {
      if (!M_iszero64(a)) {
         //need maximum result
         temp.w[0]=temp.w[1]=0xFFFFFFFF;
         M_zero64(scratch64);
         return temp;
      }
      //Else 0/0=1
      M_zero64(temp);
      M_zero64(scratch64);
      temp.b[0]=1;
      return temp;
      //return 1
   }
   M_zero64(temp);
   bitno=0;
   //Now position divisor to suit find top bit in A, and rotate b till it's
   //top bit is in the same position
   if (a.w[1]!=0) {
      for(ctr=31;!bit_test(a.w[1], ctr);ctr--) ;
      //Now rotate b till it's top bit matches.
      while (!bit_test(b.w[1], ctr)) {
         M_shiftleft64(b);
         ++bitno;
      }
   }
   else {
      for(ctr=31;!bit_test(a.w[0], ctr);ctr--) ;
      bitno=ctr;
      //Now rotate b till it's top bit matches.
      while (!bit_test(b.w[1], ctr)) {
         M_shiftleft64(b);
         ++bitno;
      }
   }    
   //bitno now stores how far b had to rotate
   while (bitno) {
      //Loop for bitno bits, performing subtract, shift & test
      scratch64=I_A_LT_B(a,b);
      if (!BORROW) {
         a=scratch64;
         //Set output bit if no borrow
         bit64_set(temp,bitno);
      }
      if (M_iszero64(a)) break;
      M_shiftright64(b);
      bitno--;
   }
   scratch64=a;
   return temp;
}


[Nocturno]

Pues lo veo complicado, no hay ninguna función ahí para convertirlo a decimal...

Llevo toda la mañana pensando en el tema y no se me ha encendido la bombilla.

[jfh900]

Y no te sirve:

int64 Var;

Var := var_8 * pow(2,32)+var_32;

printf("%f",Var);

Donde var_8 y var_32 son los valores que recibes.

Un saludo

[J1M]

o_0 ... me gusta y tiene sentido!

[Nocturno]

Pues yo me pierdo: ¿int64 en CCS?

[J1M]

Teóricamente está definido en la ayuda... aunque solo como signed.

[jfh900]

Pues yo me pierdo: ¿int64 en CCS?

Tienes razón, en CCS no está definida el int64.

Un saludo