Visualizzazione dei risultati da 1 a 5 su 5
  1. #1

    Conversione Int-Short e viceversa

    salve ragazzi,
    sono alle prime armi con java.. ho bisogno di un codice che presi in ingresso due interi lo divida in 2 short (uno che rappresenta il valore decimale dei bit più significativi e uno di quelli meno significativi) ottenendo quindi 4 short (2 per il primo e due per il secondo intero). Successivamente dopo aver effettuato un'operazione sugli short (per esempio una sottrazione del tipo.. risultH (short)= short1H-short2H ; risultL (short) = short1L-short2L. NB dove short1H e short1L sono rispettivamente la parte più significativa e quella meno significativa del primo intero.) vorrei ricostruire un intero nel seguente modo:
    risultato (intero)= (risultH+risultL). Soprattutto vorrei che il risultato coincidesse con quello della sottrazione effettuata direttamente sugli interi in input.
    Questo è quello che sono riuscito a fare con l'aiuto di alcuni gentilissimi utenti di questo forum.. il problema è che a volte nn tornano i conti

    // Divide due int in quattro short (shortH indica la parte alta, bit più significativi;
    // shortL è la parte bassa, bit meno significativi). Successivamente fa la sottrazione tra gli short corrispondenti
    // (short1H-short2H...) riporta il risultato dell'operazione e ricostruisce un intero con i due short risultanti.

    public class Int_to_2short_versione5 {

    public static void main(String[] args) {

    int a= -222222990;
    int b= 999000;

    int valore=a-b;
    System.out.println("Sottrazione tra interi (int1-int2):"+valore);//controllo

    //Converto l'int1 a in due short
    short high = (short) (a >> 16);
    short low = (short) a;

    System.out.println("");
    System.out.println("Numero1H short:"+high);
    System.out.println("Numero1L short:"+low);

    //Converto l'int2 a in due short
    short high2 = (short) (b >> 16);
    short low2 = (short) b;
    System.out.println("");

    System.out.println("Numero2H short:"+high2);
    System.out.println("Numero2L short:"+low2);
    System.out.println("");

    // effettuo la sottrazione e ne memorizzo il risultato
    // in altri 2 short (sottrazione e sottrazione2)
    short sottrazione=(short) (high-high2);
    short sottrazione2 = (short) (low-low2);

    System.out.println("RisultatoH short (short1H-short2H):"+sottrazione);
    System.out.println("RisultatoL short (short1L-short2L):"+sottrazione2);

    //Ricostruisco un int con i due short sottrazione e sottrazone2.
    int num2 = sottrazione << 16 | sottrazione2 & 0xFFFF;


    System.out.println("Risultato (int):"+num2);
    if(valore!=num2){

    System.out.println("");
    System.out.println("Errore!!!");

    }
    }
    }

    OUTPUT:

    Sottrazione tra interi (int1-int2):-223221990

    Numero1H short:-3391
    Numero1L short:9586

    Numero2H short:15
    Numero2L short:15960

    RisultatoH short (short1H-short2H):-3406
    RisultatoL short (short1L-short2L):-6374
    Risultato (int):-223156454

    Errore!!!

    PS scusate se ho postato 2 volte lo stesso mess.. nn avevo letto il regolamento..sorry

  2. #2
    Utente di HTML.it L'avatar di andbin
    Registrato dal
    Jan 2006
    residenza
    Italy
    Messaggi
    18,284

    Re: Conversione Int-Short e viceversa

    Originariamente inviato da Leon@@rdo
    Successivamente dopo aver effettuato un'operazione sugli short (per esempio una sottrazione del tipo.. risultH (short)= short1H-short2H ; risultL (short) = short1L-short2L. NB dove short1H e short1L sono rispettivamente la parte più significativa e quella meno significativa del primo intero.) vorrei ricostruire un intero nel seguente modo:
    risultato (intero)= (risultH+risultL). Soprattutto vorrei che il risultato coincidesse con quello della sottrazione effettuata direttamente sugli interi in input.
    Come l'hai fatto tu può capitare (a seconda dei valori) che non coincida. E questo perché non hai tenuto conto del "borrow" (prestito).
    Quindi non si tratta di programmazione Java o in un altro linguaggio .... ma dell'aritmetica in base 2!!! Cioè cose mooooooolto più basilari!


    Facciamo l'esempio su 8 bit (per fare le cose semplici) di due numeri: -90 e +56

    -90 in binario 10100110 (il bit 7 è il segno, 1=negativo)
    +56 in binario 00111000

    Spezziamo i numeri in 2 parti ovvero 4 + 4 bit. Facciamo la sottrazione parte per parte

    Sottrazione tra le parti basse: 0110 - 1000

    Che succede? Che c'è un 0 - 1 (i bit più alti) e questo vuol dire che deve "chiedere in prestito" un 1 dalla parte più alta.

    Quindi si fa 10110 - 1000 e viene 1110

    Alla parte alta ora devi sottrarre un 1 (ovvio ... l'hai prestato).

    Quindi 1010 - 1 = 1001

    Sottrazione tra le parti alte: 1001 - 0011 = 0110

    Il valore finale è 01101110

    E -90 - 56 fa -146, cioè in hex 6E su 8 bit.

    Banale "aritmetica" .....
    Andrea, andbin.devSenior Java developerSCJP 5 (91%) • SCWCD 5 (94%)
    java.util.function Interfaces Cheat SheetJava Versions Cheat Sheet

  3. #3
    grazie per la risposta.. come faccio però ad implementarlo??

    se faccio una cosa del genere..

    if (parte bassa <0)
    parte alta= parte alta + (variabile (Short) =1) cioè sommo alla parte alta una variabile di tipo short e di valore 1 ossia gli sommo ..00000000001 in binario.

  4. #4
    ps mi sono dimenticato.. con parte bassa intendevo il risultato della sottrazione tra le due parti basse dei due int.

  5. #5
    Moderatore di Programmazione L'avatar di alka
    Registrato dal
    Oct 2001
    residenza
    Reggio Emilia
    Messaggi
    24,480

    Moderazione

    C'è già questa discussione aperta sull'argomento.
    MARCO BREVEGLIERI
    Software and Web Developer, Teacher and Consultant

    Home | Blog | Delphi Podcast | Twitch | Altro...

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2025 vBulletin Solutions, Inc. All rights reserved.