Ensamblador - Combinaciones en copro

He hecho una macro para calcular combinaciones matemáticas en modo convencional y tengo unas dudas para pasarlo a lenguaje de copro.
Quisiera poder calcular combinaciones, por ejemplo, de 3000 elementos de 10 en 10. Esto no me es posible dado lo enorme del resultado.
Cómo, dónde almacenaría el resultado para luego, por ejemplo, convertirlo a ASCII?. Cómo lo pasaría a ASCII?
Gracias aunque no tenga respuesta.

Yo metería el resultado en un archivo.

Para transformarlo a ascii puedes usar las instrucciones de ajuste ascii. Hay unas cuantas, y tendrás que usar la que mejor te vaya.

Por ejemplo, si tienes en al un 23, que es un número hex, tras un aam tienes en ah un 3 y en al un 5. Tras un or ax, 3030h, tienes en ax un 3335, que es el número hex 23 en decimal ascii.

Me refiero a, si logro hacer en el copro, no se como, el resultado enorme que es de combinaciones de 3000 elementos de 10 en 10, en donde lo guardo. No entra en edx:eax por ejemplo. En memoria seria en torno a 5,9e + 34. Convertir a ASCII el contenido de EDX:EAX es sencillo. Cómo guardaría el copro el resultado?. Y luego vendría la conversión. Me refiero a números mayores de 64 bits.
Gracias.

Sí, me parece que no te entiendo del todo.

Dices combinaciones de 3000 elementos cogidos de 10 en 10, ¿no?. Hablamos entonces de 10 elementos en total, no sé lo que ocupará cada uno. Si son bytes, un número de 10 bytes cabe en un registro del coprocesador.

Todas las combinaciones, como mucho, van a caberte en el disco duro, no en memoria. Las operaciones que haces para convertir edx:eax a ascii te valen también para convertir lo que haya en un registro de 128 bits del coprocesador a ascii.

No sé si es eso.

Creo que no me he explicado bien.
Programo con un ordenador de 32 bits.
Lo que necesito es el nº de combinaciones, no el desarrollo de las combinaciones.
Con 32 bits puedo almacenar un nº en EDX:EAX de 2^64 como máximo. Lo puedo guardar en una variable en memoria y luego utilizarlo volviendo a cargarlo en EDX:EAX.
He puesto combinaciones de 3000 de 10 en 10 pero pudieran ser combinaciones de 20000 de 15 en 15.
Con el copro podria calcular el nº y acto seguido convertirlo en ASCII y guardarlo en memoria en ASCII.
Lo que necesito es guardarlo en memoria en hexadecimal para hacer otros cálculos y mas tarde convertirlo a ASCII.
Cuando cargas en EAX por ejemplo cargas un dword. (mov EAX, dword ptr lo que sea).
No se como se carga y se guarda en memoria el registro del copro. Qué tamaño tendría la variable? Si después de hacer varias operaciones, el nº final fuese 15 y está en la variable en que guardé el resultado del registro del copro, qué estructura sigue para cargar el resultado en EAX, o AX o AL.
Una variable dword la puedo cargar en EAX y manejarla con AL si es 1 byte, pero con el copro, ni idea.
Gracias de nuevo.

Entonces lo único que necesitas es manejar números muy grandas. Creí que estabas sacando las contraseñas de 128 bits del vecino.

Un procesador de ahora puede manejar núneros de 128 bits. Con la misma idea que manejas números de 64 bits con edx:eax podrás manejar números de 256 bits, juntando 2 registros de 128 bits.

Así que lo que tienes que mirarte son las instrucciones SIMD. http://www.ciciliani.com.ar/datos/SIMD%20la%20cuarta%20dimension_2010-04-20.MMX-SSE.pdf.

Un registro de 128 bits se guarda igual que uno de 32. Se empieza en el byte que le pases y va ocupando bytes consecutivos hasta los 16 que necesita, en una variable que es un tword.

Oword, un tword son 80 bits.

Nada, con el copro solo consigo/se conseguir 18 dígitos.
Seguiré estudiando.

Con 64 bits consigues 20 dígitos en decimal. Con el coprocesador estás usando la mantisa de cada registro, que son 64 bits. Ya te digo que puedes usar registros de 128 bits con instruccinones como MOVDQU. La palabrota mueve entre registros xmm, de 128 bits, y la memoria.

Gracias pero no tengo MMX.
Estoy haciendo un debug a la calculadora de windows para ver como hace para representar 2^106 = 32 dígitos.

Las instrucciones de las que hablo las implementó Intel en el 2005. El problema es que las incluya el ensamblador que uses. Tasm no las incluye. Nasm creo que sí. Podrías también meter asm desde un compilador de c moderno.

Sí, la calculadora maneja números gordísimos desde hace mucho, sin SSE ni nada. Se hace igual que un z80 maneja números de 32 bits, por código. Igual que metes un número gordo en edx:eax metes un número más gordo todavía en ecx:edx:eax.

Utilizo MASM32.
El tema es que estoy pasando programas que había hecho a principios de los 90 en 8086 a 386 y en entorno Windows. Ya tengo bastante rollo con el tema de las Apis como para meterme en C puesto que en su día cambié a Visual en lugar de C, error, pero bueno, prefiero ensamblador. Si o sí va a salir. Lo que me sobra es paciencia.

Meterte en c no, poner ensamblador desde un compilador de c. Puedes poner todo en asm, hacer un obj y enlazarlo con lo que sea.

Creo que puedes hacer otra cosa. No me he puesto a mirarlo pero con el ensamblador delante se ve enseguida. Yo he usado registros de 32 bits desde código en 16. Con un 66 delante de una instrucción en 16 bits usas registros de 32. Creo recordar que con código en 32 bits, con un procesador de ahora, con un 66 delante usas registros de 64 bits (espero que no use de 16). Con eso tienes un rdx:rax, 128 bits, igual que ahora usas edx:eax.

Bueno, ya he resuelto el problema.
He realizado una versión del algoritmo de Schönhage-Strassen para multiplicaciones añadiendo el acarreo en cada pasada para acortar el código.
Lo he probado multiplicando 64 bits x 64 bits x 32 bits x 32 bit x 32 bits y he parado en unos 100 digitos, pero la longitud solo depende de buffer que se ponga para almacenar el resultado.
Ni siquiera hace falta un 386 para que funcione.
No hay nada mejor que estudiar un poco y todo se puede resolver.

Si alguien está interesado, que lo diga y lo subo al foro.

Gracias por todo.

Hola Sabino, nos puedes compartir el código?

Variación del Algoritmo de Schönhage-Strassen para multiplicaciones enormes

.model small
.386
.code
empieza:
JMP inicio2
CR equ 13
LF equ 10
resultado dq 0ffffffffffffffffh ;cifras para el ejemplo
resultado2 dq 0ffffffffffffffffh
IntBuf1 DB 230 dup(0) ;operando1
IntBuf2 DB 24 dup(0) ;operando2
IntBuf3 Db 320 dup(0) ;producto
salida db 230 dup (0) ;almacena cadena de salida
; -------------------------------------------------------------------------
; Variación del Algoritmo de Schönhage-Strassen para multiplicaciones enormes
;Resultado de las multiplicaciones de prueba:
;2135987035920910081816061259982971137547620614667080038315646755056884185109834672074087649509375
; Sabino 12/03/2014
; -------------------------------------------------------------------------

inicio2 proc
push cs
pop ds
push cs
pop es
; ------------------------------Convierte las cifras a enteros (no ascii)--------------
lea edi,IntBuf1
mov eax,dword ptr resultado
mov edx,dword ptr resultado +4
call NoAsc64
lea edi,IntBuf2
mov eax,dword ptr resultado2
mov edx,dword ptr resultado2 +4
call NoAsc64
; -----------------------------Rutina que multiplica------------------------------------
call MulLongInt
call MulLongInt

call MulLongInt
call MulLongInt

; ----------------------------------------Invierte la cadena y conviete a Ascii------------
mov esi,edi ;edi viene de la rutina anterior
dec esi

lea edi,salida
Yavale:
std
lodsb
or al,30h
cld
stosb
loop Yavale
mov byte ptr [edi],'$'
; -------------------------------------------------------------------------
xor edx,edx
xor eax,eax
lea dx,salida
mov ah,09h
int 21h

mov ax,4c00h
int 21h
inicio2 endp
; ¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤
MulLongInt proc
lea edi,IntBuf3 ;pongo a 0 la variable/buffer
mov ecx,80 ;del resultado
mov eax,0
rep stosd
; -------------------------------------------------------------------------
xor eax,eax
xor ecx,ecx
lea edx,Intbuf2 ; segundo factor
lea edi,IntBuf3 ; Donde guarda el producto
mov Cl,byte ptr [edx] ; Cl para los enteros del 2º factor
MOV CH,10 ; Cociente
fila0:
lea esi,IntBuf1 ; primer factor
push edi
cld
fila1:
lodsb
cmp al,'$' ;señala fin del factor1,
je N2
mul Cl
add al,byte ptr[edi] ;sumo al que ya tiene el resultado

CMP Al,ch ;menor de 10
Jnb CASI2
MOV byte PTR [EDI],al ; añado al resultado
add edi,1
jmp fila1
CASI2:
DIV CH ;>=10, divido por 10
ror Ax,8
MOV byte PTR [EDI],al ; añado el resto al resultado
add byte ptr [edi+1],ah ; sumo el cociente al siguiente
Xor Ax,ax ; borro para leer otro
add Edi,1
jmp fila1
N2:
inc edx ;siguiente del factor2
mov Cl,byte ptr [edx]
cmp Cl,'$' ;fin del factor2
je saliendo
pop edi
add edi,1
jmp fila0
saliendo:
cmp byte ptr [edi],0 ;si el primero es cero
je bye
inc di
bye:
mov byte ptr [edi],'$' ;marco final del entero
pop edi

; ------------------------------------Copia el producto al operando1 para otro producto-------
lea edi,IntBuf1
lea esi,IntBuf3
xor ecx,ecx
cld
apormas:
lodsb
cmp al,'$'
je dalavuelta
add ecx,1 ;contador de dígitos
stosb
jmp apormas

dalavuelta:
mov byte ptr [edi],'$'
ret
MulLongInt endp
; ¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤=÷=¤

NoAsc64 PROC ;convierte a entero
cld ;el registro/s pasado
mov ecx,edx ;de izquierda a derecha.
xchg eax,esi
mov ebx,100

Asc64a: xor edx,edx
xchg eax,ecx
div ebx
xchg eax,ecx
xchg eax,esi
div ebx
xchg eax,esi
xchg eax,edx
aam
stosw
mov eax,ecx
or eax,esi
jnz Asc64a
sub edi,1
cmp byte ptr[edi],0
jz Asc64b
inc edi
Asc64b: mov byte ptr[edi],'$' ;marca final del entero
ret

NoAsc64 ENDP

end empieza

Que tal Sabino.

El mejor código de ensamblador que he visto por aquí en años,de lejos. En realidad, me llamó la atención este comentario:

"...El tema es que estoy pasando programas que había hecho a principios de los 90 en 8086 a 386 y en entorno Windows..."

¿Tendrá por ahi otros códigos que pendientes de resolver? Quiero ponerme al dia con el ASM

Nota aclaratoria: el código se ensambla y linkea sin problemas en TASM 5 y TLINK ya que soporta las instrucciones de 386