Rechnen mit MaxValue

[Shao]

Guten Abend,

ich habe eine Uni Aufgabe die eigentlich wahnsinnig simpel erscheint und normalerweise kein Problem für mich darstellen sollte.
Da ich aber sehr lange nicht mehr programmiert habe komme ich seit Stunden leider nicht auf eine Lösung.

Die Frage an der ich hänge ist wie ich in einem simplen Taschenrechner nicht über den MIN/MAX Value eines Integer rechne. Also Integer.MinValue - 10 würde ja dann ans andere Ende des Integer springen und mir irgendeinen Riesen Wert geben. Nun bekomme ich es nicht hin das ganze so abzufangen das er so etwas garnicht erst rechnet.
Ich vermute das wenn ich eine Lösung sehe absolut vor Scharm im Boden versinken werde, aber es will mir einfach keine Lösung einfallen ^^

Vllt kann mir jemand helfen
Mit freundlichen Grüßen Shaw

 

[Blender3D]

public int add(final int a, final int b) {
        int result = 0;
        try {
            result = Math.addExact(a, b);

        } catch (ArithmeticException e) {
            System.err.println("Overflow at operation add!");
        }
        return result;
    }

 

[Shao]

Danke dir @Blender3D. ich verstehe diese Lösung und hab so kompliziert garnicht gedacht direkt die Math Klasse zu nehmen.
Hast du noch eine leichtere Lösung von wegen (a+b);
Weil mein Nachbar grade guckt mit Tränen auf meinen Bildschirm und versteht das ganze mit TryCatch nämlich garnicht ^^

 

[Robat]

Du könntet die Werte auch zu einem long casten.

long test = (long)x+ (long)y;
if (test > Integer.MAX_VALUE || test < Integer.MIN_VALUE) {
   // Overflow!
}

 

[kneitzel]

Man kann sich natürlich auch die ganzen Kriterien selbst überlegen.

Also nehmen wir nur mal die Addition (+):
result = a + b;

Wenn a und b positiv sind, dann prüfen wir auf:
MAX_VALUE - b < a // entspricht a + b > MAX_VALUE

Wenn a und b negativ sind, dann prüfen wir:
MIN_VALUE -b > a // entspricht a + b < MIN_VALUE

Wenn ein Operand positiv und der andere negativ ist, dann kann es zu keinem Overflow kommen.

Das Ganze kann man dann ähnlich für die anderen Operationen überlegen.

Funktionieren tut das, weil wir nie einen Überlauf oder Unterlauf haben: MAX_VALUE - einem positiven Integer ist im Wertebereich. Ebenso MIN_VALUE - negativer Integer.

 

[Xyz1]

In Assembler ist das sehr easy:

javac -h . MyJni.java
MyJni.java:

public class MyJni {
	static {
		System.loadLibrary("my");
	}
	public native boolean addO(int x, int y);
	public native boolean subO(int x, int y);
	public static void main(String[] args) {
		MyJni j = new MyJni();
		System.out.println(j.addO(Integer.MAX_VALUE - 1, 1));
		System.out.println(j.subO(-2, Integer.MAX_VALUE));
	}
}

(export java home...).
gcc -I"$JAVA_HOME/include" -I"$JAVA_HOME/include/linux" -shared -o libmy.so MyJni.c
MyJni.c:

#include <jni.h>
#include "MyJni.h"

/*
 * Class:     MyJni
 * Method:    addO
 * Signature: (II)Z
 */
JNIEXPORT jboolean JNICALL Java_MyJni_addO
  (JNIEnv *env, jobject to, jint x, jint y) {
	  int l1=x, l2=y, l3=1;
	  asm("add %%ebx, %%eax;"
	  "jo aSiOv;"
	  : "=a" (l3)
	  : "a" (l1), "b" (l2));
	  l3 = 0;
	  asm("aSiOv:" : : );
	  return l3 == 1;
  }

/*
 * Class:     MyJni
 * Method:    subO
 * Signature: (II)Z
 */
JNIEXPORT jboolean JNICALL Java_MyJni_subO
  (JNIEnv *env, jobject to, jint x, jint y) {
	  int l1=x, l2=y, l3=1;
	  asm("sub %%ebx, %%eax;"
	  "jo sSiOv;"
	  : "=a" (l3)
	  : "a" (l1), "b" (l2));
	  l3 = 0;
	  asm("sSiOv:" : : );
	  return l3 == 1;
  }

java -Djava.library.path=. MyJni:
...
...

jo springt bei einem Overflow zu aSiOv (add signed overflow) oder sSiOv (sub signed overflow).

 

[Blender3D]

Hast du noch eine leichtere Lösung von wegen (a+b);

@Robat hat die einfache Variante der Addition bereits gepostet.
Aber ich würde die eingebaute Lösung von Java nützen, weil Du damit auch Fehler bei Multiplikationen abfangen kannst.
Es stellt für den Anwender auch die einfachste Variante dar. Der try Block versucht die Operation ohne Überlauf durchzuführen.
Falls das nicht klappt wird der catch Block aufgerufen. Das ist nicht wirklich kompliziert.

 

[Xyz1]

Na ja zum Beispiel:

System.out.println(j.addO(Integer.MAX_VALUE, Integer.MAX_VALUE));
//oder
System.out.println(j.subO(Integer.MIN_VALUE, Integer.MAX_VALUE));

zu erkennen finde ich schon kompliziert, zumal die alu ja schon ein Flag setzt... Es ist nur nicht in JAVA verwendbar.