ComputerFx3600p Klassenreferenz

Die Klasse implementiert den Computer des Casio fx-3600P. Mehr ...

#include <calc_fx3600p.h>

Klassendiagramm für ComputerFx3600p:

Aufstellung aller Elemente

Öffentliche Methoden
	ComputerFx3600p (CalculatorFx3600p *cP)
	Konstruktor fuegt der Symboltabelle spezielle fx-3600P-Symbole hinzu.
bool	map (string &sym)
	Mapped das uebergebene Symbol gegebenenfalls auf ein anderes Symbol um.
bool	getIsIdxMode ()
bool	getIsLrnMode ()
bool	getIsEntMode ()
bool	getIsHltMode ()
int	getActivePrg ()
int	getIsPrgBreak ()
int	getIdxStep ()
string	getRunningPrg ()
string	getPrgMem (int i)
string	getPrgMemOrg (int i)
void	setIsIdxMode (bool isOn)
void	setIsLrnMode (bool isOn)
void	setIsEntMode (bool isOn)
void	setIsHltMode (bool isOn)
void	setActivePrg (int prg)
void	setIsPrgBreak (bool b)
void	setIdxStep (int i)
void	setPrgMem (int i, string str)
void	setPrgMemOrg (int i, string str)
void	setRunningPrg (string prg)
void	resetRunningPrg ()
bool	isPrgRunning ()
void	precedeRunningPrg (const string &pre)
Number	execPrg ()
	Fuehrt das Programm actPrg aus.
void	intgrInputAb ()
	Eingabe der Integrationsgrenzen.
void	integrate ()
	Funktion zur Berechnung von Bestimmten Integralen.
void	aftProcess2 (string &in)
	Fuehrt Aktionen nach Prozessierung des Symbols aus.
Private Methoden
void	addCasioFx3600SymsToSymTab ()
	Fuegt der Symboltabelle spezielle fx-3600P-Symbole hinzu.
bool	preProcess (string &in)
	Fuehrt Pre-Processing des Symbols durch.
bool	checkOnPrgBreak ()
	Funktion dient zum Abbrechen eines laufenden Programmes.
void	addPrgStep (const string &in)
	Speichert im Programmiermodus den naechsten Programmschritt.
double	trapzd (double a, double b, int n)
	Berechnet die n-te Verfeinerungsstufe der Erweiterten Trapezregel als Naeherungsformel der Integration.
double	qsimp (double a, double b, int &n, double &dif)
	Berechnet das Integral der Funktion funcP in den Grenzen a bis b nach der Simpson-Naeherung.
double	f (double x)
	Ermittelt den Funktionswert y der Funktion im aktuellen Programmspeicher an der Stelle x.
Private Attribute
CalculatorFx3600p *	mCalcFx3600pP
	Zeiger auf den zugehoerigen Calculator.
bool	mIsForceSciTypeB
	true, wenn SCI erst bei Zahlen kleiner 1e-7
bool	mIsIdxMode
	Rechner ist im Intagrationsmodus.
bool	mIsLrnMode
	Rechner ist im Programmiermodus.
bool	mIsEntMode
	Rechner ist im "Enter"-Modus.
bool	mIsHltMode
	Programm wurde durch "HLT"-Befehl unterbrochen.
string	mPrgMem [2]
	Speicher fuer zwei Programme.
string	mPrgMemOrg [2]
	die beiden aktuellen Programme als Volltext
int	mActivePrg
	gerade aktives Programm
string	mRunningPrg
	gerade ablaufendes Programm
bool	mIsPrgBreak
	Flag, ob laufendes Prg. durch "AC" unterbr. wurde.
int	mIdxStep
	aktueller Zustand des Integrationsprozesses
DspMode	mDspMode
	aktueller Display-Mode, zum Ruecksetzen nach Integration
int	mDigits
	aktuelle Display-Genauigkeit, zum Ruecksetzen nach Integration

---

Ausführliche Beschreibung

Die Klasse implementiert den Computer des Casio fx-3600P.

---

Beschreibung der Konstruktoren und Destruktoren

ComputerFx3600p::ComputerFx3600p (  CalculatorFx3600p *  cP  )

Konstruktor fuegt der Symboltabelle spezielle fx-3600P-Symbole hinzu.

---

Dokumentation der Elementfunktionen

void ComputerFx3600p::addCasioFx3600SymsToSymTab (   )  [private]

Fuegt der Symboltabelle spezielle fx-3600P-Symbole hinzu.

void ComputerFx3600p::addPrgStep (  const string &  in  )  [private]

Speichert im Programmiermodus den naechsten Programmschritt. Dabei ist zu beruecksichtigen, dass nicht alle Eingaben gespeichert werden duerfen. Z.B. wird "inv" nicht gespeichert, weil das Symbol ohnehin durch das entsprechende "ge-inv-te" ersetzt wird und dieses gespeichert wird. Alle Symbole, die nicht gespeichert werden duerfen, sind im String notToStore aufgezaehlt. Ein Sonderfall ist auch bei der Eingabe von Sexagesimalzahlen zu beachten: Wenn die Zahl eine Eingabe ist (also nach der "ENT"-Taste eingegeben wird), duerfen die bis zu drei "isxg"-Symbole nicht gespeichert werden, vielmehr muss die Sexagesimalzahl als eine einzige Eingabe betrachtet werden. Dabei ist ausreichend, nur die letzte Eingabezahl aufzuzeichnen, da diese bei der Ausfuehrung des Programms ohnehin durch den aktuellen Eingabewert ersetzt wird. Parameter: in  Symbol der aktuellen Taste

void ComputerFx3600p::aftProcess2 (  string &  in  )  [virtual]

Fuehrt Aktionen nach Prozessierung des Symbols aus. Im Unterschied zu aftProcess wird diese Funktion von Calculator::process() aufgerufen, NACHDEM das Display aufgefrischt wurde. Noetig bei der Integration, um die Anzeige wieder von der SCI-Notation, in der die Ergebnisse zunaechst ausgegeben werden, wieder zurueckzustellen. Parameter: in  Symbol der aktuellen Taste; wird hier zunaechst nicht benoetigt, aber vielleicht spaeter mal Erneute Implementation von ComputerBase.

bool ComputerFx3600p::checkOnPrgBreak (   )  [private]

Funktion dient zum Abbrechen eines laufenden Programmes. Sie wird bei jedem Schleifendurchlauf von execPrg() aufgerufen. Einzelheiten siehe dort. Als Konsolenanwendung wird die Standardeingabe abgefragt (nur Linux).

Number ComputerFx3600p::execPrg (   )

Fuehrt das Programm actPrg aus. Ein Programm besteht aus einem String, in dem alle aufgezeichneten Symbole durch ein Leerzeichen getrennt aufgeschrieben sind. Die Symbole werden bei der Programmausfuehrung aus dem String geholt und in einer Schleife der normalen process()-Funktion des Calculators uebergeben, so wie es immer geschieht. Bloed: Die process()-Funktion gehoert dem Calculator, dieser benutzt eigentlich den Computer; hier muss jetzt der Computer den Calculator benutzen, was eigentlich so nicht vorgesehen war. Diese gegenseitige Abhaengigkeit ist unschoen, aber scheint mir immer noch besser als im Computer die process()-Funktion zu duplizieren. Ein Problem sind die Symbole "ent" und "hlt". Bei diesen muss naemlich der Programmfluss unterbrochen werden, damit der Benutzer eine Eingabe machen kann. Um auch hier die ganz normale Algorithmik beim Eingeben von Zahlen benutzen zu koennen, wird das Programm tatsaechlich voellig beendet und die Kontrolle kehrt zur Hauptereignisschleife zurueck. Wenn der User seine Eingabe gemacht hat, drueckt er wieder die "RUN"-Taste und das Programm wird fortgesetzt, indem es erneut gestartet wird. Das funktioniert nun so: Der Benutzer startet ein Programm durch "p1" oder "p2". => Die Funktion AcPrgCtrl::processP1P2() holt zuerst den passenden Programm-String aus dem Speicher, kopiert ihn in die Membervariable mRunningPrg, setzt das Flag mActivePrg von 0 auf die Nummer des aktiven Programms (1 bzw. 2) und ruft execPrg() auf. execPrg() holt Symbol fuer Symbol aus dem String mRunningPrg; der String wird dabei abgebaut, so dass immer das naechste Symbol vorne steht. Wenn das Symbol "ent" oder "hlt" im Programm auftaucht, wird das Flag mIsEntMode bzw. mIsHltMode gesetzt und execPrg() verlassen. => Die Kontrolle geht damit wieder ganz normal an die Hauptschleife ueber. Der Anwender kann den Rechner jetzt ganz normal bedienen, insbesondere kann er im Display eine Eingabe machen. Sobald er die "RUN"-Taste drueckt, ruft PrgCtrlRun::process() wieder execPrg() auf. => Das Programm wird fortgesetzt, und zwar genau an der Stelle, an der es unterbrochen wurde, da der String mRunningPrg nicht veraendert wurde. Ein gerade laufendes Programm muss durch Druecken von "AC" abgebrochen werden koennen. Dies geschieht, indem in chkOnPrgBreak() die Funktion qApp->processEvents() aufgerufen wird, die kurz zur Qt-Hauptschleife zurueckkehrt bis alle Events abgearbeitet sind. Wenn "AC" gedrueckt wurde, wird nun wie immer auch die preProcess()-Funktion aufgerufen. Wenn diese das Symbol "ac" findet und gerade ein Programm laeuft (was an mActivePrg festgestellt wird), wird dort das Flag mIsPrgBreak gesetzt. Anschliessend kehrt die Kontrolle hierher zurueck, und das Flag wird abgefragt; falls es gesetzt ist, wird execPrg() verlassen.

double ComputerFx3600p::f (  double  x  )  [private]

Ermittelt den Funktionswert y der Funktion im aktuellen Programmspeicher an der Stelle x. Parameter: x  x-Wert, an dem die Funktion berechnet wird Rückgabe: Funktionswert an der Stelle x

int ComputerFx3600p::getActivePrg (   )  [inline]

int ComputerFx3600p::getIdxStep (   )  [inline]

bool ComputerFx3600p::getIsEntMode (   )  [inline]

bool ComputerFx3600p::getIsHltMode (   )  [inline]

bool ComputerFx3600p::getIsIdxMode (   )  [inline]

bool ComputerFx3600p::getIsLrnMode (   )  [inline]

int ComputerFx3600p::getIsPrgBreak (   )  [inline]

string ComputerFx3600p::getPrgMem (  int  i  )  [inline]

string ComputerFx3600p::getPrgMemOrg (  int  i  )  [inline]

string ComputerFx3600p::getRunningPrg (   )  [inline]

void ComputerFx3600p::integrate (   )

Funktion zur Berechnung von Bestimmten Integralen. Zur Berechnung werden die normalen Programmspeicher benutzt. Daher muss hier ein etwas kompliziertes Hin- und Herspringen erfolgen, das vom Flag mIdxStep gesteuert wird. Dieser Zaehler wird immer inkrementiert, wenn ein Schritt beendet wurde. Zunaechst wird der Rechner vom Anwender in den Intagrationsmodus geschaltet ("Mode" "1"), das heisst, das Flag mIsIdxMode ist also gesetzt. Anschliessend wird eine der beiden Funktionen P1 oder P2 ausgewaehlt, die zugehoerige process()-Funktion AcPrgCtrl::processP1P2() wird daher aufgerufen. Diese ruft wiederum zur Eingabe der Integrationsgrenzen intgrInputAb() auf. intgrInputAb() erzeugt ein neues Programm und schreibt es in mRunningPrg. Dies besteht aus der Eingabe von zwei Zahlen, die in K1 und K2 gespeichert werden. Bei jeder Eingabe wird dieses Programm wie ueblich unterbrochen und fortgesetzt, sobald die "RUN"-Taste gedrueckt wird. Die zugehoerige process()-Funktion PrgCtrlRun::process() fragt mIdxStep ab, das von intgrInputAb() auf 1 gesetzt wurde, und inkrementiert es. Auch bei der Eingabe der oberen Integrationsgrenze wird mIdxStep inkrementiert, so dass es dann auf 3 steht. Nach dem zweimaligen Inkrementieren ist die Eingabe beendet und PrgCtrlRun::process() ruft intgegrate() auf. Zuvor kann durch die Eingabe von 'Zahl' "INV" "RUN" noch eine Streifenanzahl festegelegt werden. In diesem Fall wird das Symbol "run" von preProcess() auf das Symbol "strps" gemapped und AcStrps::process() schreibt die Streifenanzahl in K3. integrate() hat nun alle Informationen, um die Integration durchzufuehren: Die Grenzen des Integrals stehen in K1 und K2, falls mit 'Zahl' "INV" "RUN" eine Streifenzahl vorgegeben wurde, steht diese in K3 (sonst dort 0). Die Integration wird jetzt mit der Simpson-Naeherung durchgefuehrt. Fuer jeden Funktionswert wird die Funktion f() aufgerufen. Sie schreibt das aktuelle Programm jedesmal in mRunningPrg und ruft execPrg() auf. Dies darf in diesem Fall die Nummer des aktuellen Programms in mActivePrg nicht wie sonst ueblich nach Abarbeitung auf 0 setzen (mIdxStep != 0 wird abgefragt). Schliesslich ist das Integral berechnet. Jetzt hat der Casio fx-3600P noch die Eigenheit, das Ergebnis zunaechst im wissenschaftlichen Format mit sechs Stellen zurueckzugeben, wobei aber der Modus "SCI" nicht aktiv ist; wenn man "=" drueckt, wird die Darstellung umgewandelt. Dieser Effekt wird hier erzielt, indem integrate() vor Ausgabe des Ergebnisses in den SCI-Modus schaltet. Der muss nun aber sofort wieder abgeschaltet (bzw. auf den alten Modus zurueckgesetzt) werden. Das macht die neue Funktion aftProcess2(), die von CalculatorBase::process() nach der Ausgabe ins Display aufgerufen wird. Da diese Funktion aber natuerlich nach jedem prozessierten Symbol aufgerufen wird, aber nur nach Ende der Integration aktiv werden soll, wird wieder die Steuervariable mIdxStep abgefragt.

void ComputerFx3600p::intgrInputAb (   )

Eingabe der Integrationsgrenzen. Es wird temporaer ein Programm angelegt und ausgefuehrt, in dem man zwei Zahlen angeben kann, die in K1 und K2 abgelegt werden. Alle anderen Speicher werden geloescht. Siehe auch integrate().

bool ComputerFx3600p::isPrgRunning (   )  [inline]

bool ComputerFx3600p::map (  string &  in  )  [virtual]

Mapped das uebergebene Symbol gegebenenfalls auf ein anderes Symbol um. Das ist z.B. noetig, wenn der Computer gerade im Invers-Modus ist. Erneute Implementation von ComputerSci.

void ComputerFx3600p::precedeRunningPrg (  const string &  pre  )  [inline]

bool ComputerFx3600p::preProcess (  string &  in  )  [private, virtual]

Fuehrt Pre-Processing des Symbols durch. Falls der Programmiermodus aktiviert ist, werden alle Eingaben in mPrgMem[] gespeichert. Rückgabewerte: in  zu mappendes Symbol Erneute Implementation von ComputerSci.

double ComputerFx3600p::qsimp (  double  a, double  b, int &  j, double &  dif )  [private]

Berechnet das Integral der Funktion funcP in den Grenzen a bis b nach der Simpson-Naeherung. Aus: Press u.a.: Numerical Recipes in C, S. 139 Parameter: a  untere Grenze des Integrals b  obere Grenze des Integrals Rückgabewerte: j  Verfeinerungsstufe, die noetig war dif  Differenz zwischen Endergebnis und der vorherigen Verfeinerung Rückgabe: Integral

void ComputerFx3600p::resetRunningPrg (   )  [inline]

void ComputerFx3600p::setActivePrg (  int  prg  )  [inline]

void ComputerFx3600p::setIdxStep (  int  i  )  [inline]

void ComputerFx3600p::setIsEntMode (  bool  isOn  )  [inline]

void ComputerFx3600p::setIsHltMode (  bool  isOn  )  [inline]

void ComputerFx3600p::setIsIdxMode (  bool  isOn  )  [inline]

void ComputerFx3600p::setIsLrnMode (  bool  isOn  )  [inline]

void ComputerFx3600p::setIsPrgBreak (  bool  b  )  [inline]

void ComputerFx3600p::setPrgMem (  int  i, string  str )  [inline]

void ComputerFx3600p::setPrgMemOrg (  int  i, string  str )  [inline]

void ComputerFx3600p::setRunningPrg (  string  prg  )  [inline]

double ComputerFx3600p::trapzd (  double  a, double  b, int  n )  [private]

Berechnet die n-te Verfeinerungsstufe der Erweiterten Trapezregel als Naeherungsformel der Integration. Aus: Press u.a.: Numerical Recipes in C, S. 137 Parameter: a  untere Grenze des Integrals b  obere Grenze des Integrals n  Verfeinerungsstufe Rückgabe: Integral

---

Dokumentation der Datenelemente

int ComputerFx3600p::mActivePrg [private]

gerade aktives Programm

CalculatorFx3600p* ComputerFx3600p::mCalcFx3600pP [private]

Zeiger auf den zugehoerigen Calculator.

int ComputerFx3600p::mDigits [private]

aktuelle Display-Genauigkeit, zum Ruecksetzen nach Integration

DspMode ComputerFx3600p::mDspMode [private]

aktueller Display-Mode, zum Ruecksetzen nach Integration

int ComputerFx3600p::mIdxStep [private]

aktueller Zustand des Integrationsprozesses

bool ComputerFx3600p::mIsEntMode [private]

Rechner ist im "Enter"-Modus.

bool ComputerFx3600p::mIsForceSciTypeB [private]

true, wenn SCI erst bei Zahlen kleiner 1e-7

bool ComputerFx3600p::mIsHltMode [private]

Programm wurde durch "HLT"-Befehl unterbrochen.

bool ComputerFx3600p::mIsIdxMode [private]

Rechner ist im Intagrationsmodus.

bool ComputerFx3600p::mIsLrnMode [private]

Rechner ist im Programmiermodus.

bool ComputerFx3600p::mIsPrgBreak [private]

Flag, ob laufendes Prg. durch "AC" unterbr. wurde.

string ComputerFx3600p::mPrgMem[2] [private]

Speicher fuer zwei Programme.

string ComputerFx3600p::mPrgMemOrg[2] [private]

die beiden aktuellen Programme als Volltext

string ComputerFx3600p::mRunningPrg [private]

gerade ablaufendes Programm

---

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Dateien:

• home/fs/cpp/almetare/almetare/special/casio_sci/fx3600p/calc_fx3600p.h
• home/fs/cpp/almetare/almetare/special/casio_sci/fx3600p/calc_fx3600p.cpp

---