Commits

trikitrok committed 463eaf5 Draft

Added comments in Spanish to add_term.asm

Comments (0)

Files changed (1)

+;
+; NOMBRE: Manuel Rivero González
+;
+;
+;
+;
+;
+
 section .data          
 
 section .text    
 ; Se hacen visibles las rutinas de ensamblador que se deben ver desde el programa en C
 global p_term_add_c, p_add_sub, p_term_mul
 
+; Multiplica un término (coef*x^exp) por un polinomio. s(x)=(coef*x^exp)*s(x)
+; Mantiene el polinomio ordenado según el exponente.
+; Parámetros de entrada : coef(rdi), exp(rsi), v_coef(rdx), v_exp(rcx)
+; Parámetros de salida: Ninguno
 p_term_mul:
   push rbp
-  mov  rbp, rsp           ; Store stack initial state
+  mov  rbp, rsp          ; Se guarda el estado inicial
   push r8
   push rax
   push r9
-
-  ; coef(rdi),   exp(rsi),    v_coef(rdx),  v_exp(rcx)
   
-  mov r8,0               ; Index
-  mov r9, rdx
+  mov r8,0               ; Se usa R8 como índice
+  mov r9, rdx            ; Se mueve la dirección del vector los coeficientes del polinomio a R9
+                         ; porque el contenido de RDX se ve afectado por la operación de multiplicación
   
+  ; Para cada término del polinomio
   term_mul_loop:
-    ; Sum the exponents
     mov eax, dword[rcx+r8*4]
 
-    cmp eax,-1           ; If the exponent is -1, we are done
-    JE done_term_mul     ; We are suppossing that the polynomial
-                         ; is properly sorted
+    cmp eax,-1           ; Si el exponente es -1, se termina porque se supone que el polinomio estáwe are done
+    JE done_term_mul     ; correctamente ordenado
     
-    ; Sum the exponents
+    ; Se suman los exponentes
     add eax, esi
     mov dword[rcx+r8*4], eax
 
-    ; Multiply the coefficients
+    ; Se mumltiplican los coeficientes
     mov eax, dword[r9+r8*4]
     mul edi
     mov dword[r9+r8*4], eax
     
     inc r8
-    cmp r8, 20
+    cmp r8, 20          ; si R8 < 20 se sigue iterando
     JL term_mul_loop
 
   done_term_mul:
   
-  pop r9
+  pop r9                ; Se restaura el estado inicial
   pop rax
   pop r8  
   mov rsp, rbp
   pop rbp
-  
   ret
 
+; Suma / Resta dos polinomios. r(x)=r(x)+s(x) o r(x)=r(x)-s(x)
+; Si el parámetro suma/resta (quinto parámetro) es 0 se hace la suma, si es -1 se hace la resta.
+; Para hacer la suma/resta de los polinomios se hace la suma/resta de cada término de s(x) en el polinomio r(x)
+; llamando a la subrutina p_term_add. Para hacer la resta sólo se necesita negar el coeficiente del término
+; que se quiere restar antes de llamar a la subrutina p_term_add.
+; Si al hacer la suma o la resta r(x) tiene más de 20 términos se borra r(x).
+; Parámetros de entrada : r_coef(rdi), r_exp(rsi), s_coef(rdx), s_exp(rcx), suma/resta(r8)
+; Parámetros de salida: rax (0 si se pudo hacer la suma, -1 si no se pudo).
 p_add_sub:
   push rbp
-  mov  rbp, rsp           ; Store stack initial state
+  mov  rbp, rsp          ; Se guarda el estado inicial
   push rbx
   push r9
   push r10
 
   ;  r_coef(rdi),   r_exp(rsi),    s_coef(rdx),    s_exp(rcx),    suma/resta(r8)
 
-  mov rbx, 0              ; índice
-  mov r10, rdi
+  mov rbx, 0              ; Se usa rbx como índice
+  mov r10, rdi            ; Se mueve la dirección del vector de coeficientes del polinomio r(x) a otro 
+                          ; registro (R10) porque RDI lo usa p_term_add como parámetro de salida
 
+  ; Por cada término del polinomio s(x)
   add_sub_loop:
-    ; Call to p_term add 
-    push rsi                    ; We push the address of the exponents of the polynomial to the stack
-    push r10                     ; We push the address of the coeficients of the polynomial to the stack
-    mov eax, dword[rcx + rbx*4] ; We push the exponent of the new term we want to insert
+    ;*******************
+    ; Llamada a p_term_add
+    ;*******************
+    push rsi                     ; Se empuja a la pila la dirección de los exponentes del polinomio r(x)
+    push r10                     ; Se empuja a la pila la dirección de los coeficientes del polinomio r(x)
+    mov eax, dword[rcx + rbx*4]  ; Se empuja a la pila el exponente del término actual de s(x)
     push rax    
     
-    mov eax, dword[rdx + rbx*4] ; We push the coefficient of the term we want to insert
+    ; Si se trata de una resta (R8 == -1) se cambia el signo del coeficiente del término actual de s(x)
+    mov eax, dword[rdx + rbx*4]  
     cmp r8, 0
     JE push_coef
       neg rax
     push_coef:
-      push rax                    
+      push rax                   ; Se empuja a la pila el coeficiente del término actual de s(x)
                         
-    call p_term_add
-    add rsp,32
-    mov rax, rdi
+    call p_term_add              ; Finalmente se llama a p_term_add
+    add rsp,32                   ; Se deja la pila como estaba antes de la llamada
+    mov rax, rdi                 ; Se recupera el resultado de llamar a p_term_add 
+    ;*******************    
     
+    ; Si este es -1 quiere decir que hubo un error al hacer la suma/resta
+    ; se sale del bucle saltando a la etiqueta add_sub_error
     cmp rax,-1
     JE add_sub_error
     
+    ; Si no hubo error, se itera para hacer lo mismo con el siguiente término
     add ebx,1
     cmp rbx, 20                             
-    jl add_sub_loop   ; si (rbx < 20*4) se hace otra iteración
+    jl add_sub_loop   ; mientras (rbx < 20)
         
-  ;Store success operation flag
-  mov rax, 0
-  JMP add_sub_end
+  ; Si se llega aquí quiere decir que la suma/resta fue bien 
+  mov rax, 0          ; y se devuelve al programa en C a través de RAX la flag de éxito (0)
+  JMP add_sub_end     ; y se salta al final de la función
   
+  ; Si hubo un error, se borra el polinomio
   add_sub_error:
-  ; Delete polynomial
+  ;*******************
+  ; Llamada a p_delete
+  ;*******************
   mov rax, r10
   mov rbx, rsi
   call p_delete
-  ;Store error operation flag
+  ;*******************
+  ; Y se devuelve al programa en C a través de RAX la flag de error (-1)
   mov rax, -1
 
   add_sub_end:
 
-  pop r10
+  pop r10           ; Se restaura el estado inicial
   pop r9
   pop rbx
   mov rsp, rbp
   pop rbp
-  
   ret
 
+; Llama a la subrutina p_term_add pasándole los parámetros recibidos desde el programa en C.
+; Parámetros de entrada : coef(rdi), exp(rsi), v_coef(rdx), v_exp(rcx)
+; Parámetros de salida: rax (0 indica que se sumó el término correctamente, -1 que no se pudo insertar).
 p_term_add_c:
-  push rbp                ; Store stack initial state
+  push rbp                ; Se guarda el estado inicial
   mov  rbp, rsp   
 
-  push rcx                ; We push the address of the exponents of the polynomial to the stack
-  push rdx                ; We push the address of the coeficients of the polynomial to the stack
-  push rsi                ; We push the exponent of the new term we want to insert
-  push rdi                ; We push the coefficient of the term we want to insert
-  call p_term_add
-  add rsp,32
-  mov rax, rdi
+  ;*******************
+  ; Llamada a p_term_add
+  ;*******************
+  push rcx                ; Se empuja a la pila la dirección de los exponentes del polinomio
+  push rdx                ; Se empuja a la pila la dirección de los coeficientes del polinomio
+  push rsi                ; Se empuja a la pila el exponente del nuevo término que se quiere insertar
+  push rdi                ; Se empuja a la pila el coeficiente del nuevo término que se quiere insertar
+  call p_term_add         ; Se llama a p_term_add
+  add rsp,32              ; Se mueve el puntero de la pila a la posición donde está el resultado
+  mov rax, rdi            ; Se mueve el resultado a RAX para poder devolverlo al programa en C
+  ;*******************
         
-  mov rsp, rbp            ; Restore stack initial state
+  mov rsp, rbp            ; Se restaura el estado inicial
   pop rbp
-
   ret
 
+; Suma un nuevo término (coef*x^exp) a un polinomio. s(x)=(coef*x^exp)+s(x)
+; Mantiene el polinomio ordenado según el exponente.
+; Si ya existe un término con el mismo exponente se suma.
+; Si al hacer la suma el coeficiente queda a cero, se elimina el término.
+;   (Para mantener el vector ordenado, a partir de la posición eliminada se desplazan
+;    el resto de elementos del vector una posición y se inserta un -1 al final).
+; Si no existe, se inserta, pero sólo si el polinomio tiene menos de 20 términos.
+;   (Para mantener el vector ordenado se desplaza el resto de elementos del vector una posición
+;    a partir de la posición donde se inserta el nuevo término).
+; Si ya ha 20 términos se inidca con un -1 (flag de error).
+; Parámetros d'entrada : coef_term(rbp+16), exp_term(rbp+24), coefs(rbp+32), exps(rbp+40)
+; Parámetros de salida: rdi: 0 indica que se sumó el término correctamente, -1 que no se pudo insertar.
 p_term_add:
-  push rbp                ; Store stack initial state
+  push rbp                ; Se almacena el estado inicial
   mov  rbp, rsp   
   push rcx
   push rbx
   push rax
   push rsi
            
-  mov rbx, [rbp+40]       ; We move the exponents address (exps) from the stack to RBX
-  mov ecx, dword[rbp+24]  ; We move the exponent (exp_term) from the stack to RCX
+  mov rbx, [rbp+40]       ; Se mueve la dirección de los exponentes del polinomio (exps) de la pila a RBX
+  mov ecx, dword[rbp+24]  ; Se mueve el exponente del término a insertar (exp_term) de la pila a RCX
   
   ;*******************
-  ; Call p_exist_term
+  ; Llamada a p_exist_term
   ;*******************
-  sub rsp, 8              ; We make space for the result by subtracting 8 bytes to the stack pointer
-  push rbx                ; We push the exponents address to the stack
-  push rcx                ; We push the exponent we wish to find            
-  call p_exist_term       ; Now we call p_exist_term
-  add rsp, 16             ; We place the stack pointer in the position were the result is
-  pop rsi                 ; RDI contains the position of the term if it exists -1 if it does not
+  sub rsp, 8              ; Se reserva espacio para el resultado (posición del término si este existe o -1 si no existe)
+  push rbx                ; Se empuja a la pila la dirección de los exponentes del polinomio
+  push rcx                ; Se empuja a la pila la posición del término que se quiere encontrar
+  call p_exist_term       ; Se llama a p_exist_term
+  add rsp, 16             ; Se mueve el puntero de la pila al lugar donde está el resultado
+  pop rsi                 ; y se desapila el resultado moviéndolo a RSI
   ;********************
 
-  ; if it's -1 the term does no exist
+  ; Si la posición es -1 quiere decir que el término no existe
   cmp rsi,-1
-  JE insert_new_term_call
+  JE insert_new_term_call    ; y se pasa a insertarlo
 
-  ; Sum coefficients
-  mov rdi, [rbp+32]         ; We move the coefficients address (coefs) from the stack to RDI
-  mov eax, dword[rbp+16]    ; We sum the coefficients
+  ; En caso de que el término si exista en el polinomio se suman su coeficiente y el del término a añadir
+  mov rdi, [rbp+32]          ; Se mueve la dirección de los coeficientes de la pila a RDI
+  mov eax, dword[rbp+16]     ; y se efectúa la suma
   add eax, dword[rdi+rsi*4]
   
-  cmp rax,0               ; If sum == 0, we delete the term
+  cmp rax,0                  ; Si la suma de los coeficientes es igual a 0 -> el término se elimina del polinomio
   JE delete_term_call
   
-  mov dword[rdi+rsi*4], eax ; If not we update it
+  mov dword[rdi+rsi*4], eax  ; Si no lo es, se actualiza el valor de su coeficiente
   JMP success
   
   delete_term_call:
   ;*******************
-  ; Call p_delete_term 
+  ; Llamada a p_delete_term 
   ;*******************
-  push rbx                ; We push the address of the exponents of the polynomial to the stack
-  push rdi                ; We push the address of the coeficients of the polynomial to the stack
-  push rsi                ; We push the position of the term we want to delete
-  call p_delete_term      ; Now we call p_delete_term
-  add rsp,24
-  JMP success
+  push rbx                ; Se empuja a la pila la dirección de los exponentes del polinomio
+  push rdi                ; Se empuja a la pila la dirección de los coeficientes del polinomio
+  push rsi                ; Se empuja a la pila la posición del término que se quiere borrar
+  call p_delete_term      ; Se llama a p_delete_term
+  add rsp,24              ; Se deja el puntero de la pila como estaba antes de la llamada
   ;*******************
+  JMP success             ; Se termina con éxito
   
   
+  ; Se intenta insertar el elemento
   insert_new_term_call:
   
   ;*******************
-  ; Call p_count_term
+  ; Llamada a p_count_term
   ;*******************
-  sub rsp, 8              ; We make space for the result by subtracting 8 bytes to the stack pointer
-  push rbx                ; We push the exponents to the stack
-  call p_count_terms      ; Now we call p_count_terms
-  add rsp, 8              ; We place the stack pointer to the 
-                          ; position were the result is
-  pop rax                 ; And move it to rax so that it's
+  sub rsp, 8              ; Se reserva espacio para el resultado (el número de términos del polinomio)
+  push rbx                ; Se empuja a la pila la dirección de los exponentes del polinomio
+  call p_count_terms      ; Se llama a p_count_terms
+  add rsp, 8              ; Se mueve el puntero de la pila al lugar donde está el resultado
+  pop rax                 ; y se desapila el resultado moviéndolo a RAX
   ;*******************
   
-  ; if there are already 20 elements in the vector we can't insert one more
+  ; Si el polinomio ya tiene 20 elements no se puede insertar uno nuevo y se termina con un error
   cmp rax,20
   JE error
 
+  ; Si hay menos de 20 elementos, se pasa a insertarlo
+
   ;*******************
-  ; Call p_find_position 
+  ; Llamada a p_find_position 
   ;*******************
-  sub rsp, 8              
-  push rbx                ; We push the exponents of the polynomial to the stack
-  mov eax, dword[rbp+24]  ; We push the exponent of the new term we want to find
+  sub rsp, 8              ; Se reserva espacio para el resultado (la posición donde se insertará el nuevo término)
+  push rbx                ; Se empuja a la pila la dirección de los exponentes del polinomio
+  mov eax, dword[rbp+24]  ; Se empuja a la pila el exponente del nuevo término a insertar
   push rax
-  call p_find_position    ; Now we call p_find_position
-  add rsp, 16              
-  pop rsi                 ; And move its result to rsi
+  call p_find_position    ; Se llama a p_find_position
+  add rsp, 16             ; Se mueve el puntero de la pila al lugar donde está el resultado
+  pop rsi                 ; y se desapila el resultado moviéndolo a RSI
   ;*******************
   
   ;*******************
-  ; Call p_insert_term
+  ; Llamada a p_insert_term
   ;******************* 
-  push rbx                ; We push the address of the exponents of the polynomial to the stack
-  mov rdi, [rbp+32]       ; We push the address of the coeficients of the polynomial to the stack
+  push rbx                ; Se empuja a la pila la dirección de los exponentes del polinomio
+  mov rdi, [rbp+32]       ; Se empuja a la pila la dirección de los coeficientes del polinomio
   push rdi                
-  mov eax, dword[rbp+24]  ; We push the exponent of the new term we want to insert
+  mov eax, dword[rbp+24]  ; Se empuja a la pila el exponente del nuevo término a insertar
   push rax                
-  mov eax, dword[rbp+16]  ; We push the coefficient of the term we want to insert
+  mov eax, dword[rbp+16]  ; Se empuja a la pila el coeficiente del nuevo término a insertar
   push rax                
-  push rsi                ; We push the position were we want to insert the term
-  call p_insert_term      ; Now we call p_insert_term
-  add rsp, 40
+  push rsi                ; Se empuja a la pila la posición donde se insertará el término
+  call p_insert_term      ; Se llama a p_insert_term
+  add rsp, 40             ; Se deja el puntero de la pila como estaba antes de la llamada
   ;*******************      
-  JMP success
+  JMP success             ; Se termina con éxito
           
   error:     
-  ;Store error operation flag
+  ; Se guarda en RDI el flag de error (-1)
   mov rdi, -1
   JMP end_add_term
   
   success:
-  ;Store success operation flag
+  ; Se guarda en RDI el flag de éxito (0)
   mov rdi, 0
   
   end_add_term:
   pop rbx      
   pop rcx
 
-  mov rsp, rbp            ; Restore stack initial state
+  mov rsp, rbp            ; Se restaura el estado inicial
   pop rbp
-
   ret
 
+; Inserta un nuevo término en un polinomio
+; Parámetros de entrada: Posición del término a insertar (pos) en rbp+16
+;                        Coeficiente del nuevo término (coef_term) en rbp+24
+;                        Exponente del nuevo término (exp_term) en rbp+32
+;                        Dirección de los coeficientes del polinomio en rbp+40
+;                        Dirección de los exponentes del polinomio en rbp+48
+;                        El exponente del nuevo término en rbp+16
+; Parámetro de salida: Ninguno
 p_insert_term:
   push rbp
-  mov  rbp, rsp           ; Store stack initial state
+  mov  rbp, rsp           ; se guarda el estado inicial
         
   push rax                   
   push rbx
   push rdx
   push rdi
   
-  mov rbx, [rbp+48]       ; We move the exponents address (exps) from the stack to RBX
-  mov rcx, [rbp+40]       ; We move the coefficients address (coefs) from the stack to RCX
-  mov edx, dword[rbp+16]  ; We move the position to insert the term to  RDX
+  mov rbx, [rbp+48]       ; Se mueve la dirección de los exponentes (exps) de la pila a RBX
+  mov rcx, [rbp+40]       ; Se mueve la dirección de los coeficientes (coefs) de la pila a RCX
+  mov edx, dword[rbp+16]  ; Se mueve la posición del término a insertar (pos) de la pila a EDX
 
   ; exp_term is at [rbp+32]  
   ; coef_term is at [rbp+24]
   
-  mov edi, 19             ; RDI will be the index
+  mov edi, 19             ; RDI se usa como índice y se empieza a recorrer los vectores desde el final
+                          ; hasta la posición donde se inserta el término moviendo los términos posteriores
+                          ; para abrirle un hueco al nuevo término
 
   insert_term_loop:
-    cmp rdi, rdx          ; if (index == position) the insert the new term
+    cmp rdi, rdx          ; Si (índice == pos) -> se inserta el nuevo término
     JE insert_new_term
   
-    ; exps[i] = exps[i-1]
+    ; Si no, se desplaza el término hacia la derecha
+    
+    ; Haciendo exps[i] = exps[i-1]
     mov eax, dword[rbx + (rdi-1)*4]
     mov [rbx + rdi*4], eax
     
-    ; coefs[i] = coefs[i-1]
+    ; y coefs[i] = coefs[i-1]
     mov eax, dword[rcx + (rdi-1)*4]
     mov [rcx + rdi*4], eax
     
     JMP insert_term_loop   
   
   insert_new_term:
-    mov eax, dword[rbp+32]          ; insert exp_term
+    mov eax, dword[rbp+32]          ; Se inserta exp_term
     mov dword[rbx + rdi*4], eax
-    mov eax, dword[rbp+24]          ; insert coef_term
+    mov eax, dword[rbp+24]          ; Se inserta coef_term
     mov dword[rcx + rdi*4], eax     
 
-  pop rdi
+  pop rdi                 ; Se restaura el estado inicial
   pop rdx
   pop rcx
   pop rbx
   pop rax    
   mov rsp, rbp
-  pop rbp
-  
+  pop rbp  
   ret
   
+; Encuentra la posición en que debe insertarse un término en un polinomio
+; Parámetros de entrada: La dirección del vector de exponentes en rbp+24
+;                        El exponente del nuevo término en rbp+16
+; Parámetro de salida: Posición del término a insertar (pos) en rbp+32.
 p_find_position:
   push rbp
-  mov  rbp, rsp           ; Store stack initial state
+  mov  rbp, rsp           ; Se guarda el estado inicial
   push rbx
   push rcx  
   push rdx
   
-  mov rbx, [rbp+24]       ; We move the exponents (exps) from the stack to RBX
-  mov edx, dword[rbp+16]  ; We move the exponent (exp) we'd like to find to RDX
-  mov rcx, 0              ; Index
+  mov rbx, [rbp+24]       ; Se mueve la dirección de los exponentes (exps) de la pila a RBX
+  mov edx, dword[rbp+16]  ; Se mueve el exponente (exp) de la pila a RDX
+  mov rcx, 0              ; Se usa RDX como índice
 
   find_position_loop:
-    cmp dword[rbx + rcx*4], edx ; if exps[i] < exp, then pos = ecx
+    cmp dword[rbx + rcx*4], edx ; Si exps[i] < exp -> pos = ecx
     JL found
     
     add ecx,1
-    JMP find_position_loop   
+    JMP find_position_loop 
 
   found: 
     ; Se guarda el resultado en la pila
     mov qword[rbp+32], rcx
   
-  pop rdx                 ; Restore stack initial state
+  pop rdx                 ; SE restaura el estado inicial
   pop rcx
   pop rbx
   mov rsp, rbp
-  pop rbp
-  
+  pop rbp  
   ret
-  
+
+; Borra un término de un polinomio
+; Parámetros de entrada: La dirección del vector de exponentes en rbp+32
+;                        La dirección del vector de coeficientes en rbp+24
+;                        Posición del término que se quiere borrar en rbp+16.
+; Parámetro de salida: Ninguno    
 p_delete_term:
   push rbp
-  mov  rbp, rsp           ; Store stack initial state
+  mov  rbp, rsp           ; Se guarda el estado inicial
         
   push rax                   
   push rbx
   push rcx  
   push rdx
   
-  mov rbx, [rbp+32]       ; We move the exponents (exps) from the stack to RBX
-  mov rcx, [rbp+24]       ; We move the coefficients (coefs) from the stack to RCX
-  mov edx, dword[rbp+16]  ; We move the position (pos) of the term we'd like to delete to RDX
+  mov rbx, [rbp+32]       ; Se mueve la dirección de los exponentes (exps) de la pila a RBX
+  mov rcx, [rbp+24]       ; Se mueve la dirección de los coeficientes (coefs) de la pila a RCX
+  mov edx, dword[rbp+16]  ; Se mueve la posición (pos) del término a borrar de la pila a RDX
 
-  cmp edx, 19             ; if pos == the last one, we don't need to move anything 
-                          ; and we just have to delete it
-  JE delete_last_term
+  cmp edx, 19             ; if pos == a la última posición, no hay que mover nada
+  JE delete_last_term     ; y sólo hay que borrar el término
 
-  add edx,1               ; RDX will be our index
+  ; Si no, hay que mover elementos que están después del término a borrar para cerrar el hueco
+  ; Para ello se recorre el vector desde pos+1 hasta el final usando RDX como índice
+  add edx,1               
 
   delete_term_loop:
-    ; exps[i-1] = exps[i]
+    ; Se hace exps[i-1] = exps[i]
     mov eax, dword[rbx + rdx*4]
     mov [rbx + (rdx-1)*4], eax
     
-    ; coefs[i-1] = coefs[i]
+    ; Y coefs[i-1] = coefs[i]
     mov eax, dword[rcx + rdx*4]
     mov [rcx + (rdx-1)*4], eax
     
-    add edx,1              ; if (rdx < 20), we iterate again
+    add edx,1              ; Si (EDX < 20), se itera de nuevo
     cmp edx, 20                             
     jl delete_term_loop   
   
-  delete_last_term:        ; We delete the last element
+  delete_last_term:        ; Se borra el último elemento
     mov edx,19
     mov dword[rbx + rdx*4],-1
     mov dword[rcx + rdx*4],0
   
-  pop rdx                  ; Restore stack initial state
+  pop rdx                  ; Se restaura el estado inicial
   pop rcx
   pop rbx
   pop rax
   mov rsp, rbp
-  pop rbp
-  
+  pop rbp  
   ret    
   
+; Comprueba si un término ya existe en un polinomio
+; Parámetros de entrada: La dirección del vector de exponentes en rbp+24
+;                        El exponente del término cuya existencia vamos a comprobar en rbp+16
+; Parámetro de salida: Posición del término en el vector si ya existe.
+;                      En caso de no existir -1. Se devuelve a través de la pila en rbp+32  
 p_exist_term:
   push rbp
-  mov  rbp, rsp           ; Store stack initial state
+  mov  rbp, rsp           ; Se guarda el estado inicial
         
   push rbx
   push rcx  
   push rdx
   
-  mov rbx, [rbp+24]       ; We move the exponents (exps) from the stack to RBX
-  mov edx, dword[rbp+16]  ; We move the exponent (exp) we'd like to find to RDX
-  mov rcx, 0              ; Index
+  mov rbx, [rbp+24]       ; Se mueven los exponentes (exps) de la pila a RBX
+  mov edx, dword[rbp+16]  ; Se mueven el exponente (exp) que se va a buscar a RDX
+  mov rcx, 0              ; RCX se usa como índice
 
   exist_term_loop:
-    cmp dword[rbx + rcx*4], edx ; if exps[i] == exp, eax = ecx
-    JNE next_term_1
-    JMP done                    ; and we are done
+    cmp dword[rbx + rcx*4], edx ; Si exps[i] == exp -> salimos del bucle (etiqueta done)
+    JNE next_term_1             ; si no pasamos al siguiente término
+    JMP done                    
     
     next_term_1:
     
-    add ecx,1                   
-    cmp ecx, 20                             
+    add ecx,1             ; Si no sale porque encuentra el exponente buscado
+    cmp ecx, 20           ; sigue iterando hasta llegar al final del vector
     jl exist_term_loop   
   
-  ; Si llega aquí hay un error
+  ; Si llega aquí quiere decir que el término no existe (posición = -1)
   mov rcx, -1
   
   done: 
-  ; Se guarda la posicion en la pila
+  ; Se guarda la posición en la pila
   mov qword[rbp+32], rcx
   
-  pop rdx                 ; Restore stack initial state
+  pop rdx                 ; Se restaura el estado inicial
   pop rcx
   pop rbx
   mov rsp, rbp
-  pop rbp
-  
+  pop rbp  
   ret    
 
+; Cuenta los términos de un polinomio
+; Parámetros de entrada: La dirección del vector de exponentes en rbp+16
+; Parámetro de salida: El número de términos en rbp+24
 p_count_terms:
   push rbp
-  mov  rbp, rsp           ; Store stack initial state
+  mov  rbp, rsp           ; Se guarda el estado inicial
         
   push rax                   
   push rbx
   push rcx  
   
-  mov rax, 0              ; Initialize rax  
-  mov rbx, [rbp+16]       ; We move the exponents from the stack to RBX
-  mov rcx, 0              ; índice
+  mov rax, 0              ; Se initializa RAX que servirá de contador
+  mov rbx, [rbp+16]       ; Se mueve la dirección de los exponentes de la pila a RBX
+  mov rcx, 0              ; Se inicializa RCX que servirá de índice
 
   count_terms_loop:
     cmp dword[rbx + rcx*4], -1
     JE next_term
     
-    add eax,1              ; si el exponente del término != -1 se cuenta el término
-    
+    add eax,1              ; Si el exponente del término != -1 se cuenta el término
+                           ; si no se pasa al siguiente término. Esto es para que la 
+                           ; función también sirva con polinomios "mal ordenados".
     next_term:
     
-    add ecx,1              ; si no (rdx < 20*4) se hace otra iteración
+    add ecx,1              ; Si (ECX < 20) se hace otra iteración
     cmp ecx, 20                             
     jl count_terms_loop   
   
   ; Se guarda el resultado en la pila  
   mov qword[rbp+24], rax
   
-  pop rcx                 ; Restore stack initial state
+  pop rcx                 ; Se restaura el estado inicial
   pop rbx
   pop rax
   mov rsp, rbp
   pop rbp
-  
   ret    
   
-; Esborrar els termes d'un vector de 20 posicions. El coeficient a 0 i l'exponenet a -1.
-; Paràmetres d'entrada: v_coef(rax), v_exp(rbx)
-; Paràmetre de sortida: cap
+; Borra los términos de un vector de 20 posicions (coeficient a 0 y exponente a -1)
+; Parámetros de entrada: v_coef(rax), v_exp(rbx)
+; Parámetro de salida: Ninguno
 p_delete:
   push rbp
   mov  rbp, rsp
-  push rax                   ;guardem a la pila els registres que modifiquem
+  push rax                   ;Se guarda el estado inicial en la pila
   push rbx
   push rsi
     
-  mov  rsi, 19               ;comencem per la darrera posició.
+  mov  rsi, 19               ;Se comienza por la última posición.
   
   p_delete_loop:
     mov dword[rax+rsi*4], 0
     mov dword[rbx+rsi*4],-1
-    dec  esi
-    jge  p_delete_loop
+    dec esi
+    jge p_delete_loop
  
   p_delete_end:
-  pop rsi                    ;restaurar l'estat dels registres.
+  pop rsi                    ;Se restaura el estado inicial
   pop rbx
   pop rax
   mov rsp, rbp