Altri Linguaggi - Come far funzionare il codice MIPS con i floating point

Salve,

ho scritto un programma che cerca, all'interno di un array, il valore massimo e il valore minimo dei numeri contenuti in esso.

La grandezza dell'array non è definita, bensì viene scelta dall'utente al momento dell'esecuzione del programma.

Una volta stabilita la grandezza attraverso una serie di cicli l'utente inserisce i valori (N INTERI).

Esempio esecuzione
Inserisci la grandezza: 5

### Creo un array grande 5 ###

Inserisci i valori:

a[0] = n
a[1] = m
..
a[5] = z

##### Inserisco i valori nelle caselle disponibili dell'array appena creato #####

Ora. Lo script funziona correttamente per i numeri interi, io vorrei convertirlo per i numeri floating point.

Esempio
grandezza array: 3 (n intero)
Valori array:



a[0] = 13.3 (n float)
a[1] = 143.543
a[2] = 500.232

###########################################

Codice

.data 

array: .word 0 #Inizializzo l'array 
grandezza: .asciiz "Inserisci la grandezza (n intero) : "
elementi: .asciiz "Inserisci gli elementi : "
max: .asciiz "Il valore massimo: "
min: .asciiz "\nIl valore minimo: "

.text

.globl main

main:

li $v0, 4 
la $a0, grandezza
syscall 

li $v0, 5 #Prendo la grandezza dell'array
syscall



move $t0, $v0 
move $t1, $v0 

li $v0, 4 
la $a0, elementi
syscall

la $t3, array


### Prima ricerca se ho solo un elemento allora il primo è uguale all'ultimo quindi stampo ###
prima_ricerca:

beq $zero, $t0, risultato_prima_ricerca_1_1
li $v0, 5 
syscall

sw $v0, 0($t3)
addi $t3, $t3, 4
addi $t0, $t0, -1
j prima_ricerca

risultato_prima_ricerca_1_1:

lw $t3, array 
la $s0, array 
move $s1,$t3 
move $s2,$t3 

###Seconda ricerca se la grandezza dell'array è > 1 ###

seconda_ricerca:


beq $t1,$zero, risultato_generale # t1 contiene la grandezza del array
slt $t0, $s1, $t3 # Se il valore massimo s1 è minore del valore dell'array t3 allora sposto il numero in t0
beq $t0 ,$zero, proseguo_ricerca #Quindi continuo con la ricerca per il minimo
move $s1, $t3 # Altrimenti sposto il valore t3 nel max $s1



proseguo_ricerca:
slt $t0, $t3, $s2 # Se il valore dell'array t3 è minore di s2 allora sposto tutto in t0
beq $t0 ,$zero, trovato #Trovato
move $s2,$t3 #Sposto il valore t3 nel max
j trovato


trovato:

addi $s0, $s0, 4
lw $t3, 0($s0)
addi $t1, $t1 ,-1
j seconda_ricerca

risultato_generale:

li $v0, 4
la $a0, max
syscall
li $v0, 1 
move $a0, $s1
syscall

li $v0, 4 
la $a0, min
syscall
li $v0, 1 
move $a0, $s2
syscall


exit:
li $v0, 10
syscall # end of program

Qualcuno mi può dare una mano?