dividir número hexa muyyyy grande

[aguml]

Hola amigos, necesito realizar la siguiente division:
0xFFFFFFFFFFFFFFFFFFFFFFFF / 0xFFFFFFFFF
no he encontrado una calculadora que lo soporte y me gustaría saber si conocen alguna aplicación que me permita realizar lo o, en su defecto, como se haría a mano.
También necesito pasar el resultado al sistema decimal.

[[AgustinOrtu]]

Google da como resultado

1.1529215e+18

Como es un numero tan grande te queda en notacion cientifica

[engranaje]

Yo lo que suelo hacer en esos casos es partimos la cadena en trozos mas pequeños que si pueda dividir. Despues averiguo el resto y concateno el trozo siguiente de la parte de la cadena que que falta por tratar al resto. Es como cuando en una división "bajamos"
la parte del dividendo que aún no hemos tratado al lado del resto.

En delphi me queda algo así.

Código Delphi [-]
while length(strCadenaTratandose) > 6 do
begin
      strParteTratandose := copy(strCadenaTratandose,0,6);
      iParte := strtoint(strParteTratandose);

      iMod:= iparte mod  68;

      strCadenaTratandose :=  inttostr(iMod) +                       
                              copy(strCadenaTratandose,7,length(strCadenaTratandose));

  end;

Creo que mas o menos algo así debería servirte.

PErdón, edito porque me he dado cuenta de que no he respondido tu pregunta y esto solo te serviría para averiguar el resto final. no el cociente que es lo que buscas

[aguml]

Además tendría otro problema ya que el divisor es mayor que un entero con lo que pasar una parte del dividendo a entero no tiene mucho sentido ya que el divisor será mayor. Habría que usar enteros de 64 bits y ahí si que podría hacer eso pero que yo sepa no existe la función StringToInt64.
De todos modos me interesa el tema y me gustaría saber como hacer eso a mano y ya de paso sumar, restar, y multiplicar con hexadecimales.

[aguml]

Se me ocurre algo asi:

Código PHP:

#include <intypes.h>

bool dividirHex(AnsiString dividendo, AnsiString divisor, AnsiString *cociente, AnsiString *Resto)
{
   __uint64 auxDividendo, auxDivisor, auxCociente=0, auxResto=0;
   bool salir=false;
   bool retval=false;
   int largoDividendo, largoDivisor, largoPorcion, pos;
   *cociente="";
   *resto="";
   largoDivisor=divisor.Lenght();
   auxDivisor=sprintf("%UINT64", AnsiString ("0x" + divisor).c_str ());

   do {
      largoDividendo=dividendo.Lenght ();
      largoPorcion=largoDivisor;
      if (largoDividendo >= largoDivisor){
         if(auxDivisor > sprintf("%UINT64", AnsiString ("0x" + dividendo.SubString(1,largoPorcion)).c_str()){
            if(largoDividendo > largoDivisor){
               largoPorcion++;
            }else{
               break;
            }
         }
         auxDividendo=sprintf("%UINT64", AnsiString ("0x" + dividendo.SubString(1,largoPorcion)).c_str());
         auxResto=auxDividendo % auxDivisor;
         dividendo=dividendo.SubString(largoPorcion, largoDividendo);
         auxCociente=auxDividendo / auxDivisor;
         *cociente=*cociente + AnsiString (auxCociente);
         *resto=AnsiString(auxResto);
          if (auxResto > 0)
            dividendo= *resto + dividendo.SubString(largoPorcion,largoDividendo);
         else
            dividendo= dividendo.SubString(largoPorcion,largoDividendo);
         retval=true;
      }else{
         salir=true;
      }
   }while(!salir);
   return retval;
} 


Lo he escrito en el móvil y no está probado. ¿que os parece? Creo que lo que le faltaría es saber si el cociente desborda el int64 y si es así salir con false pero no se como comprobar eso. Supongo que seria obteniendo el valor máximo de un int64 y luego comparó carácter por carácter contra la cadena del cociente de izquierda a derecha mientras sean iguales hasta llegar al último o hasta que sea mayor el del dividendo. Si es mayor salgo del bucle y retorno false. Si es menor salgo del bucle y continuo con lo demás.

[alquimista]

La calculadora que hice y de la que hable en el foro, realiza la operación que comentas:

Hex('FFFFFFFFFFFFFFFFFFFFFFFF') /Hex('FFFFFFFFF') //pasa hex a decimal
Resultado: 1.15292150462362E18
-------
DectoHex(1.15292150462362E18) //pasa decimal a hex
Resultado:1000000000FFF000
-------
Hex('1000000000FFF000')
resultado: 1152921504623620096
--------
Esta en sourceforge como CALCUFP.

Esta también código fuente

Espero te sea útil.
Saludos

PD: Creo recordar que puse el código hexadecimal en JvInterpreter_Misc.pas