package client;
/** Ein Rechner mit Stack-Architektur (model).
*
* Ein Objekt dieser Klasse stellt die reine Statusmaschine (model, Automat)
* eines Stackrechners dar. Es gibt vier Stackregistern --
* x, y, z und t -- genau wie bei den berühmten
* HP-Taschenrechnern.
*
* Die Anzeige (view) ist nicht enthalten. Sie wird insofern unterstützt,
* dass für alle vier Register String-Werte geliefert werden.
* Fehlerzustände werden durch
* Nicht-Zahlen-Texte des X-Registers signalisiert.
*
* Die Java-Nutzung dieser Klasse ist so eingeschränkt, dass eine
* problemlose Übersetzung in JavaScript mit dem Google-Webtoolkit (GWT)
* möglich ist.
*
* Dezimale und hexadezimale Darstellung werden unterstützt.
*
* Die (Tasten-) Eingaben für Ziffern, Enter und Operationen gehören nicht
* zum ({@link StackCalcMod}-) Objekt. Sie sind über öffentliche Methoden
* ansteuerbar. Damit ist ein beliebig gestalteter Controller
* einsetzbar.
*
* Auf einer Demo-Seite kann man sich dies alles anschauen.
*
* Copyright 2007 Albrecht Weinert
*
* @see StackCalcGWT
*
* @author Albrecht Weinert
* @version 1 (21.01.2010)
*/
// Bisher : V02.00 (30.01.2007 11:44) : neu aus Rechner.java (Applet)
// V01.01 (23.09.2007 17:28) : /**
// V01.02 (07.10.2009 18:26) : autoEnter Verderben durch History
// korrigiert (GWT-Hinw.: History setzen spielt diese zurück!)
// V.124+ (07.10.2009 19:00) : nach SVN und weWebSite
// V.05+ (10.01.2010 14:48) : to Frame4J (& GWT 2.0) SVN-rev-jmp
public class StackCalcMod {
public double[] state() {
double[] ret = new double[5];
ret[0] = x;
ret[1] = y;
ret[2] = z;
ret[3] = t;
if (autoEnter) ret[4] = 1;
return ret;
} // state()
public void set(double[] state) {
x = state[0];
y = state[1];
z = state[2];
t = state[3];
enterTo0 = true;
autoEnter = state[4] != 0; // geä. am 07.10.2009 /// false;
afterDot = false;
error = false;
errText = null;
} // set(double[])
/** Hauptregister X (=Anzeige).
*/
protected double x;
/** Stackregister Y (Stack ist x, y, z, t).
*/
protected double y,z,t;
/** Zustand Hex-Rechner.
*/
protected boolean hex;
/** Zustand: nächste Zifferneingabe löscht vorher X.
*/
protected boolean enterTo0 = true;
/** Zustand: nächste Zifferneingabe macht Enter.
*/
protected boolean autoEnter;
/** Zustand: in Zifferneingabe nach Dezimalpunkt.
*/
protected boolean afterDot;
/** Wert: Dezimalfaktor für nächste einzelne Nachkommastelle.
*/
double dotFactor;
/** Zustand Fehler.
*/
protected boolean error;
/** Fehlertext.
*/
protected String errText;
/** X-Text liefern.
*/
public String showX() {
if (error) {
if (errText == null) errText = "Error";
return errText;
}
if (x == 0 && afterDot) return "0.";
String ret = formatStackValue(x);
if (hex) {
final int le = 28 - ret.length();
ret = "[hex] ".substring(0, le) + ret;
}
/// TEST ret = ret + (autoEnter ? 'a' : '#');
return ret;
} // showX()
/** Formatieren eines (Stack-) Werts.
*
* @return formatierte Zahl
*/
protected String formatStackValue(double w) {
if (Double.isNaN(w)) {
return "Error: NaN (not a number)";
}
if (w == 0) return "0";
if (hex) {
// JavaScript kann kein Double.toHex
return Integer.toHexString((int) w);
}
String ret = Double.toString(w);
if (!afterDot || dotFactor != 0.1 || Double.isInfinite(w)) return ret;
return ret + '.';
} // formatStackValue(double)
/** Y-Text liefern.
*/
public String showY() {
if (y == 0) return "0";
if (hex) {
return Integer.toHexString((int) y);
}
return Double.toString(y);
} // showY()
/** Z-Text liefern.
*/
public String showZ() {
if (z == 0) return "0";
if (hex) {
return Integer.toHexString((int) z);
}
return Double.toString(z);
} // showY()
/** T-Text liefern.
*/
public String showT() {
if (t == 0) return "0";
if (hex) {
return Integer.toHexString((int) t);
}
return Double.toString(t);
} // showY()
/** Zustand: Fehler.
*/
public final boolean isError() {
return error || Double.isNaN(x);
}
/** Wert vom T-Register.
*/
public final double getT() { return t; }
/** Wert vom X-Register.
*/
public final double getX() { return x; }
/** Wert vom Y-Register.
*/
public final double getY() { return y; }
/** Wert vom Z-Register.
*/
public final double getZ() { return z; }
/** Eingabe einer Ziffer (0..9; ..15).
*
* Diese Methode ist mit entsprechendem Parameter
* von den Zifferntasten 0..9,A..F aufzurufen.
*
* Der x-Wert entsprechend geändert. Nach einer
* vorangegangenen Operation wird vorher
* {@link #enter()} ausgeführt.
*
* return false, falls Ziffer außerhalb 0..9/15 oder overflow bei dezimal
*/
public boolean zif(int zif) {
if (zif < 0 || zif > 15 || zif >= 10 && !hex) return false;
if (autoEnter) enter();
final boolean was0 = enterTo0 || x == 0;
enterTo0 = false;
if (was0) {
if (! afterDot) {
x = zif;
return true;
}
x = 0;
}
if (hex) {
x = x * 16 + zif;
return true; // ignore overflow in hex
}
if (afterDot) {
x += zif * dotFactor;
dotFactor *= 0.1;
return true;
}
x = x * 10 + zif;
return true;
} // zif(int)
/** Dezimalkomma-Eingabe.
*
* @return true, wenn vorher noch nicht
*/
public boolean dot() {
if (afterDot) return false;
if (autoEnter) enter();
final boolean was0 = enterTo0 || x == 0;
enterTo0 = false;
if (was0) x = 0;
dotFactor = 0.1;
afterDot = true;
return true;
} // dot()
/** Multiplikation x = x * y.
*
* Diese Methode multipliziert die beiden unteren Stackregister
* und "zieht" den Stack eins runter (t wird nach
* z kopiert).
*/
public void mal() {
x *= y;
popToY();
} // mal()
/** Umrechnungsfaktor rad / grad.
*
* Wert: {@value}
*/
public static final double TO_RAD_FAC = Math.PI / 180;
/** Wurzel aus 2.
*
* Wert: {@value}
*/
public static final double SQRT2 = // = Math.sqrt(2.0);
1.4142135623730950; // 488016887242096980785696718753769480731;
/** Einstellige Funktion x = f(x).
*
* Definiert sind: sin, cos, tan, asin, acos atan, sqrt, exp, ln,
* toRad und toDeg.
* Als "Setzwerte sind definiert: pi, e und sqrt2.
*
* Aufruf mit einem undefinierten Funktionsnamen ist die
* Einheitsfunktion f(x) = x; der Wert wird bezüglich Zifferneingabe
* abgeschlossen (auto-Enter).
*
*/
public void fun(String f) {
autoEnter = true;
afterDot = false;
if (f == null || f.length() == 0) return;
if ("sqrt".equals(f)) {
x = Math.sqrt(x);
return;
}
if ("sin".equals(f)) {
x = Math.sin(x);
return;
}
if ("cos".equals(f)) {
x = Math.cos(x);
return;
}
if ("tan".equals(f)) {
x = Math.tan(x);
return;
}
if ("asin".equals(f)) {
x = Math.asin(x);
return;
}
if ("acos".equals(f)) {
x = Math.acos(x);
return;
}
if ("atan".equals(f)) {
x = Math.atan(x);
return;
}
if ("exp".equals(f)) {
x = Math.exp(x);
return;
}
if ("ln".equals(f)) {
x = Math.log(x);
return;
}
if ("toRad".equals(f)) {
x *= TO_RAD_FAC;
return;
}
if ("toDeg".equals(f)) {
x /= TO_RAD_FAC;
return;
}
if ("pi".equalsIgnoreCase(f)) {
setX(Math.PI);
return;
}
if ("e".equalsIgnoreCase(f)) {
setX(Math.E);
return;
}
if ("sqrt2".equalsIgnoreCase(f)) {
setX(SQRT2);
return;
}
/* xxxxx if ("atan2".equals(f)) {
x = Math.atan2(y, x);
y = z;
z = t;
return;
} xx atan2 wird nicht in JavaScript übersetzt, obgl. es gehen müsste */
} // fun(String)
/** Division (ganzzahlig) x = y / x.
*
* Diese Methode verknüpft die beiden unteren Stackregister
* und "zieht" den Stack eins runter (t wird nach
* z kopiert).
*/
public void teilen() {
autoEnter = true;
afterDot = false;
try {
x = y / x;
y = z;
z = t;
} catch (Exception e) {
error = true;
errText = "Error: " + e.getMessage();
enterTo0 = true;
}
} // teilen()
/** Division und Rest (ganzzahlig) x,y = (y / x), (x mod y).
*
* Diese Methode berechnet den ganzzahligen Quotienten y / x und den
* ganzzahligen Rest y mod x (y % x in Java). der neue Inhalt von
* x ist der Quotient und der von y der Rest. Durch Vertauschen mit
* {@link #chgXY()} kann man beide Ergebnisse abwechselnd in's
* x-Register bringen.
* Die Register z und t bleiben unverändert.
*/
public void teilen2() {
autoEnter = true;
afterDot = false;
try {
double tempX = y / x;
double tempY = y % x; // Zwei temps wg. mgl. Except.
y = tempY;
x = tempX;
} catch (Exception e) {
error = true;
errText = "Error: " + e.getMessage();
enterTo0 = true;
}
} // teilen2()
/** Modulo (ganzzahliger Rest) x = y % x.
*
* Diese Methode verknüpft die beiden unteren Stackregister und
* "zieht" den Stack eins runter (t wird nach z kopiert).
*/
public void mod() {
autoEnter = true;
afterDot = false;
try {
x = y % x;
y = z;
z = t;
} catch (Exception e) {
error = true;
errText = "Error: " + e.getMessage();
enterTo0 = true;
}
} // mod()
/** Exponent (y hoch x) x = y ** x.
*
* Diese Methode verknüpft die beiden unteren Stackregister und
* "zieht" den Stack eins runter (t wird nach z kopiert).
*/
public void yHx() {
autoEnter = true;
afterDot = false;
try {
x = Math.pow(y, x);
y = z;
z = t;
} catch (Exception e) {
error = true;
errText = "Error: " + e.getMessage();
enterTo0 = true;
}
} // yHx()
/** Addition x = y + x.
*
* Diese Methode verknüpft die beiden unteren Stackregister und
* "zieht" den Stack eins runter (t wird nach z kopiert).
*/
public void plus() {
x += y;
popToY();
} // plus()
/** Hilfsmethode.
*
*/
protected void popToY() {
y = z;
z = t;
autoEnter = true;
afterDot = false;
} // popToY()
/** Subtraktion x = y - x.
*
* Diese Methode verknüpft die beiden unteren Stackregister und
* "zieht" den Stack eins runter (t wird nach z kopiert).
*/
public void minus() {
x = y - x;
popToY();
} // minus()
/** Ändern des Vorzeichens von x: x = -x.
*
* Diese Methode ändert das Vorzeichen des Inhalts des Hauptstackregisters
* x. Die anderen drei Stackregister bleiben unverändert.
*/
public void chgSign() {
x = -x;
autoEnter = true;
afterDot = false;
} // chgSign()
/** Hex-Dez-Umschaltung.
*
* Diese Methode setzt den Modus Hexadezimal oder Dezimal.
* Ein ggf. Änderung wird über die Rückgabe signalisiert und wirkt
* wie Eingabeabschluss (nächste Ziffer auto Enter).
*
* @return Änderung
*/
public boolean setHex(boolean hex) {
if (this.hex == hex) return false;
this.hex = hex;
autoEnter = true;
return true;
} // setHex()
/** Hex-Dez-Umschaltung (toggle).
*
* Diese Methode ändert den Modus Hexadezimal / Dezimal und wirkt
* wie Eingabeabschluss (nächste Ziffer auto Enter).
*
* @return hex
*/
public boolean toggleHex() {
autoEnter = true;
return hex = !hex;
} // toggleHex()
/** Hex-Dez-Zustand.
*
* Diese Methode ändert den Modus Hexadezimal oder
* Dezimal.
*
* @return Neuer Zustand (hex)
* @see #setHex(boolean)
*/
public boolean isHex() {
return this.hex;
} // invHex()
/** Vertauschen von x und y.
*
* Diese Methode vertauscht den Inhalt der beiden unteren Stackregister.
* t und z bleiben unverändert.
*/
public void chgXY() {
double tmp = x;
x = y;
y = tmp;
autoEnter = true;
afterDot = false;
} // chgXY()
/** Herunterrollen des Stack (t wird urspr. x).
*
* Diese Methode rollt den Stack nach unten bzw. nach x,
* setzt aber den ursprünglichen x-Inhalt nach t.
*
* Nach viermaliger Anwendung ist der Ausgangszustand wieder erreicht.
*/
public void rollDown() {
double tmp = x;
x = y;
y = z;
z = t;
t = tmp;
autoEnter = true;
afterDot = false;
} // rollDown()
/** Push-Operation beziehungsweise Enter.
*
* Diese Methode schiebt den Inhalt des Stacks um eins hoch.
* x wird nach y kopiert; der bisherige Inhalt von t geht verloren.
*
* Im Fehlerzustand wird nur X und der Fehler gelöscht.
*/
public void enter() {
enterTo0 = true;
autoEnter = false;
afterDot = false;
if (error) {
x = 0;
error = false;
errText = null;
return;
}
t = z;
z = y;
y = x;
} // enter()
/** Rücksetzen in den Einschaltzustand.
*
* Diese Methode löscht alle Stack-Register auf 0 und setzt den
* Modus auf Dezimal.
*
*/
public void reset() {
hex = false;
clrAll();
} // reset
/** Löschen des X-Registers.
*
* Diese Methode löscht nur das X-Register.
* Ein Fehlerzustand wird gelöscht.
*/
public void clrX() {
x = 0;
enterTo0 = true;
autoEnter = false;
afterDot = false;
error = false;
errText = null;
} // clrX()
/** Setzen des X-Registers auf einen Wert.
*
* Diese Methode setzt nur das X-Register.
* Ein Fehlerzustand wird gelöscht.
*/
public void setX(double x) {
if (autoEnter || ! enterTo0) enter();
this.x = x;
enterTo0 = true;
autoEnter = true;
afterDot = false;
error = false;
hex = false;
errText = null;
} // clrX()
/** Löschen von allen Registern.
*
* Diese Methode löscht alle Stack-Register auf 0.
*/
public void clrAll() {
t = z = y = 0;
clrX();
} // clrXclrAll
} // class Rechner (07.11.2001; 23.03.2004; 11.01.2010)