[Assembly] Listato che non da risultati

[-Ivan-]

Questo è il programma, la maschera è in C ma l'algoritmo è tutto in assembly.
Dovrebbe secondo il mio ragionamento calcolare la distanza tra il punto Point e gli altri punti contenuti in PointSet e darmi in output l'indice dell'elemento di PoinSet più vicino a Point.

l'algoritmo che ho pensato è semplicissimo ed è questo:

1) metto prima in ax e bx le coordinate x di Point e di un elemento PointSet poi le coordinate y
2) eseguo le operazioni matematiche per calcolare la distanza e metto il risultato in DX
3) confronto DX con il vecchio DX che conteneva la distanza tra il punto e l'elemento precedente di PointSet, se il vecchio DX è più grande lo sostituisco con il nuovo in modo da avere in DX sempre la distanza minore
4) aggiorno l'indice se ho sostituito DX altrimenti lo lascio invariato (come indice uso ECX che incremento per scorrere PointSet e che salvo nello stack all'inizio del ciclo)
5) ripeto il ciclo fino a n che è il numero di elementi di PointSet e poi esco

#include<stdio.h>

void main()
{	
	unsigned int Point = (5<<16 | 3); //il punto
	unsigned int PointSet[] = {(10<<16) |3, (4<<16) |2, (5<<16) |20 }; //insieme
	unsigned int n = sizeof(PointSet)/sizeof(PointSet[0]); //numero punti dell'insieme
	unsigned int index; //risultatoindice del punto più vicino a Point

	
	_asm{
		//Azzero i registri utilizzati nel programma
		XOR EAX,EAX
		XOR EBX,EBX
		XOR ECX,ECX
		XOR EDX,EDX
						
		XOR ESI,ESI
		XOR EDI,EDI

Ciclo:		
		PUSH ECX

		MOV CX, DX
		// metto in AX la coordinata x di Point
		MOV AX,[WORD PTR Point+2]
		// metto in BX la coordinata x dell'elemento PointSet a cui sono arrivato
		MOV BX,[WORD PTR PointSet+ECX+2]
		
		//operazioni matematiche sui registri per fare sqrt ((x2-x1)^ + (y2-y1)^2)
		SUB BX, AX //in bx ho x2-x1
		IMUL BX, BX //in bx ho (x2-x1)^2
		MOV DX, BX //in dx ho (x2-x1)^2
		MOV AX,[WORD PTR Point]
		MOV BX,[WORD PTR PointSet+ECX]
		SUB BX, AX //in bx ho y2-y1
		IMUL BX, BX //in bx ho (y2-y1)^2
		ADD BX, DX //in BX ho (x2-x1)^ + (y2-y1)^2
		MOV DX, BX //in DX ho (x2-x1)^ + (y2-y1)^2

		//mettere qui la radice quadrata di DX
		
		CMP CX, DX
		JG Salva
		
Ritorna:
		POP ECX
		INC ECX
		CMP ECX, n
		JNE Ciclo
		JE Termina

Salva:
		MOV CX, DX
		MOV index, ECX
		JMP Ritorna

Termina:




	}

	//Stampa su video
	printf("Il punto più vicino a: ( %d, %d ) e' |%d, %d| [indice=%d]\n", 
	(short int)(Point&0xFFFF), (short int) (Point>>16),
	(short int)(PointSet[index]&0xFFFF), (short int) (PointSet[index]>>16),
	index
	);
}

[andbin]

Per fare i calcoli se vuoi puoi usare le istruzioni per le operazioni matematiche in floating-point!

[71104]

ma perché l'algoritmo lo fai in assembly? e la maschera che è?

[-Ivan-]

Originariamente inviato da 71104

ma perché l'algoritmo lo fai in assembly? e la maschera che è?

Lo devo fare per forza in assembly, per maschera intendevo l'intestazione del programma e la struttura che è fatta sotto visual c++.
Non posso cambiare le variabili e posso solo scrivere l'algoritmo in assembly tra le graffe asm.

[-Ivan-]

Originariamente inviato da andbin

Per fare i calcoli se vuoi puoi usare le istruzioni per le operazioni matematiche in floating-point!

Il fatto è che non le conosco, ho cercato di risolvere con le conoscenze che ho, alla fine questo è quello che abbiamo fatto nel corso penso che dovrebbero bastare. Può essere che non funziona perchè sbaglio le operazioni dici?
Io a parte che non so fare la radice quadrata pensavo che le altre operazioni sui registri potessero andare.

[andbin]

Originariamente inviato da -Ivan-

Il fatto è che non le conosco, ho cercato di risolvere con le conoscenze che ho, alla fine questo è quello che abbiamo fatto nel corso penso che dovrebbero bastare. Può essere che non funziona perchè sbaglio le operazioni dici?
Io a parte che non so fare la radice quadrata pensavo che le altre operazioni sui registri potessero andare.

Sto controllando il tuo sorgente. Per la radice quadrata ... non saprei come farla senza usare le istruzioni FP. Cioè bisogna conoscere l'algoritmo per calcolare la radice quadrata. Che non è sicuramente così banale!

Comunque invece di fare:

MOV AX,[WORD PTR Point+2]
MOV BX,[WORD PTR PointSet+ECX+2]
SUB BX, AX

Puoi fare più semplicemente:

MOV BX,[WORD PTR PointSet+ECX+2]
SUB BX,[WORD PTR Point+2]

[-Ivan-]

Prova a dirmi per esempio una istruzione sui fp che magari le conosco ma sono leso in questo momento e non mi vengono in mente.

edit: ho attuato qualche modifica ai registri, ora ho un risultato non mi si blocca più il programma, l'ultima cosa è che devo fare la radice quadrata di AX e non so come farla, non si fa per caso con lgi shift? Con quali comandi si fa?
Intanto ti ringrazio davvero tanto andbin perchè mi hai dato una grossa mano.

[andbin]

Originariamente inviato da -Ivan-

Prova a dirmi per esempio una istruzione sui fp che magari le conosco ma sono leso in questo momento e non mi vengono in mente.

Ecco:

finit

fild	[WORD PTR PointSet+ecx+2]     // x2
fisub	[WORD PTR Point+2]            // x2 - x1
fmul	ST(0), ST(0)                  // (x2-x1)^2

....

Originariamente inviato da -Ivan-

l'ultima cosa è che devo fare la radice quadrata di AX e non so come farla, non si fa per caso con lgi shift? Con quali comandi si fa?

Non bastano degli shift o una istruzione ma un algoritmo ben preciso!!!

[-Ivan-]

Porca pupazza io non li ho mai visti questi comandi, la vedo abbastanza male allora anche perchè non ci sono nemmeno sulle dispense.
Non è che magari ho sbagliato a calcolare la distanza tra 2 punti e non è
sqrt((x2-x1)^2+(y2-y1)^2) ma qualcos'altro? Oppure c'è un modo più semplice.
Grazie lo stesso, adesso devo andare a lavorare mi ci metto stanotte semmai.

[andbin]

Originariamente inviato da -Ivan-

Non è che magari ho sbagliato a calcolare la distanza tra 2 punti e non è
sqrt((x2-x1)^2+(y2-y1)^2) ma qualcos'altro? Oppure c'è un modo più semplice.

Questo non lo so ... non sono un matematico. So che per calcolare la distanza tra 2 punti si usa il ben noto Teorema di Pitagora, che porta alla formula che hai appena detto.


P.S. comunque se non puoi calcolare la radice quadrata, puoi usare anche solo: (x2-x1)^2+(y2-y1)^2. Tanto devi solo fare delle comparazioni per determinare quale tra i punti è più vicino al primo punto!

[repne scasb]

A meno di errori grossolani:

;	Mode: Assembly x86/16/32
;
;	Input
;
;	word ptr [point] = Coordinate x,y
;	word ptr [point_set] = Array di coordinate x,y
;	word ptr [n_point] = Numero punti
;
;	Output
;
;	word ptr [min_point_set] = Indice distanza minima


        Check_DPoint	proc	far

	pushad
	xor	ecx,ecx
	mov	bx,0FFFFh
loop_check_dpoint:
	mov	ax,word ptr [4*ecx+point_set]
	mov	dx,word ptr [4*ecx+point_set+2h]
	sub	ax,word ptr [point]
	sub	dx,word ptr [point+2h]
	imul	ax,ax
	imul	dx,dx
	add	ax,dx
	cmp	ax,bx
	jnb	no_min_d
	mov	word ptr [min_point_set],cx
	xchg	ax,bx
no_min_d:
	inc	cx
	cmp	cx,word ptr [n_point]
	jne	loop_check_dpoint	
	popad
	ret

	Check_DPoint	endp