2.3 Arbeit mit numerischen Ausdrücken

In diesem Kapitel erfahren Sie alles über die Arbeit mit mathematischen Ausdrücken. Vorher sollten Sie das Kapitel 2.2.2 (Numerische Variablen) gelesen haben.

^

2.3.1 Grundlagen und Überblick

Die Verarbeitung von Zahlen und mathematischen Funktionen gehört zu den Kernaufgaben einer Programmiersprache. Hier finden Sie eine Zusammenstellung der wesentlichen Dinge, die beim Verarbeiten von Zahlen mit R-BASIC zu beachten sind.

Für Zahlen gelten die folgenden Regeln

  • Einfache Zahlen sind z.B. 12 oder 4.89
    Als Dezimaltrenner wird immer der Punkt '.' verwendet, egal was Sie in den PC/GEOS Voreinstellungen festgelegt haben. Dadurch kann man BASIC-Programme auf allen PC/GEOS-Rechnern sofort laufen lassen.

  • Vor jede Zahl darf ein Vorzeichen (+ oder -) gesetzt werden.

  • Für Zahlen mit 10er-Potenzen wird das E (oder e) verwendet.
    -3,78 * 1012 wird also so geschrieben: -3.78E12
    6,673 * 10-11 sieht so aus: 6.673E-11
    Entsprechendes gilt auch für die Ausgabe von Zahlen durch R-BASIC.

  • Leerzeichen innerhalb von Zahlen sind unzulässig.

  • Zahlen können auch in binärer Schreibweise (Vorsatz &B, z.B. 5 als &B101) und in hexadezimaler Schreibweise (Vorsatz &H, z.B. 243 als &HF3) dargestellt werden. In diesen Fällen sind 32 Bit oder 8 Hexadezimalstellen zulässig (Zahlenbereich DWord). Zahlen in dieser Schreibweise werden grundsätzlich als positive Zahlen behandelt.

  • Achtung!
    Weisen Sie einer vorzeichenbehafteten Variablen (Integer, Longint) einen Wert zu, der außerhalb ihres Wertebereichs liegt, so wird die Variable auf den größten (oder kleinsten) möglichen Wert gesetzt.

    Weisen Sie einer vorzeichenlosen Variablen (Byte, Word, DWord) einen zu großen Wert zu, wird die MODULO-Operation zur Zuweisung verwendet.

    Siehe auch: Technische Hintergründe und Grenzen

Mathematische Operatoren und Vergleiche:

Neben den Grundrechenarten ( +, -, *, / ) beherrscht R-BASIC die Exponentendarstellung ( ^ , z.B. 24 = 2^4), die Modulo-Operation (MOD, Rest nach Division) sowie die Vergleichsoperatoren =, <, > , <= , >= und <>. Das Ergebnis eines Vergleichs ist immer wahr (TRUE, siehe unten, numerische Konstanten) oder falsch (FALSE). Eine ausführliche Darstellung der Zusammenhänge finden Sie im Kapitel 2.3.3 (Vergleiche und Operatoren).

Mithilfe von logischen Operatoren (NOT, AND, OR , XOR) und Bit-Operationen (SHL(x, n), SHR(x, n), Shl32(x, n), Shr32(x, n)) können einzelne Bits manipulieren. Mit diesem Thema beschäftigen sich das Kapitel 2.3.5.

Mathematische Funktionen

  • R-BASIC verfügt über eine Vielzahl von mathematischen Funktionen. Diese können beliebig verknüpft werden, wobei R-BASIC die üblichen Vorrangregeln (Punktrechnung vor Strichrechnung, Klammern gehen vor usw.) beachtet.

    Beispiele:

y = 4 * sin(5 * x) + 7
y = sqr( 1 + tan(z))
  • Überall dort, wo in den Beispielen Zahlen oder numerische Variablen verwendet wurden, können auch komplexe numerische Ausdrücke stehen.

  • Zu den mathematischen Funktionen gehören zum Beispiel ABS(x) (absoluter Betrag), INT(x) (ganzzahliger Anteil), SQR(x) (Square root - Quadratwurzel) und SIN(x) (Sinus). Eine vollständige Liste finden Sie im nächsten Abschnitt.

Numerische Konstanten

R-BASIC enthält viele vordefinierte symbolische Konstanten, die anstelle ihrer Zahlenwerte verwendet werden können. In vielen Fällen kann dadurch die Lesbarkeit des Programms verbessert werden. Dazu gehören zum Beispiel Konstanten für die Farbwerte (Farbkonstanten), für Zeichensätze (Fonts) und vieles mehr. Diese Konstanten werden im Zusammenhang mit den entsprechenden Themen besprochen.

Zusätzlich gibt es noch einige "allgemeine" Konstante, die hier aufgeführt sind.

Hinweise:

  • Vergleichsausdrücke liefern immer TRUE (-1) oder FALSE (Null) zurück

  • R-BASIC behandelt in Entscheidungssituationen (IF...THEN) alle Ausdrücke, die Null ergeben als "falsch", alle Ausdrücke die nicht Null ergeben als "wahr".

  • Mit der Anweisung CONST (siehe Kapitel 2.2.10) können Sie sich beliebige Konstanten für eigene Zwecke definieren.

Hierarchie der mathematischen Operatoren

Die mathematischen Operatoren in R-BASIC werden nach einer bestimmten Priorität abgearbeitet. Aus der Schule kennen Sie das als "Punktrechnung geht vor Strichrechnung".

Priorität der Operatoren, hochpriorisierte Operatoren stehen oben:

  1. Klammern

  2. Exponenten ^

  3. Vorzeichen - , +

  4. Multiplikation und Division: *, /, MOD

  5. Addition, Subtraktion: +, -

  6. Vergleichsoperatoren =, <, >, <=, >=, <>

  7. NOT,

  8. AND,

  9. OR,

  10. XOR
Gleichwertige Operatoren werden von links nach rechts abgearbeitet.

Beispiele

Die Prioritäten sichern ab, dass folgende Ausdrücke so abgearbeitet werden, als wären die im Kommentar angegebenen Klammern gesetzt:

! Punktrechnung vor Strichrechnung:
  4*A + 7*B                     ! --->  (4*A) + (7*B)
 
! Exponenten-Operator ^ vor den Vorzeichen:
  -5^2                          ! --> -(5^2)
  5^-2                          ! --> 5^(-2)

! Rechenoperationen vor den Vergleichsoperatoren:
  IF 4A <= B-1 THEN ..           ---> IF (4A) <= (B - 1) THEN

! Vergleichsoperatoren vor den logischen Operatoren:
  IF a>4 OR B<2 THEN ..          ---> IF (a>4) OR (B<2 )THEN

! NOT hat die höchste Priorität unter den logischen Operationen
  IF NOT A  AND  NOT B THEN ..  ! ---> IF (NOT A)  AND  (NOT B) THEN ..
Anmerkung: Ausdrücke mit mehreren verschiedenen logischen Operatoren sind sehr unübersichtlich. Außerdem kommt es sehr schnell zu Fehleinschätzungen der Abarbeitungs-Priorität. Deswegen gibt der Compiler eine Warnung aus, wenn Sie verschiedene logische Operatoren in der gleichen Klammerebene verwenden.

^

2.3.2 Mathematische Funktionen

Dieses Kapitel beschreibt alle in R-BASIC verfügbaren mathematischen Funktionen. Mathematische Funktionen sind BASIC-Anweisungen, die einen numerischen Wert berechnen. Sie werden in der Form y = ABS(x) verwendet (Ausnahme: RANDOMIZE), wobei y eine numerische Variable ist. Die Grundlagen zu numerischen Variablen finden Sie im Kapitel 2.2.2.

R-BASIC arbeitet mit REAL-Zahlen im Bereich von ± 3.9999 * 104931. Einige der mathematischen Funktionen haben einen eingeschränkten Definitionsbereich, d.h. sie sind für Argumente (x-Werte) außerhalb eines bestimmten Zahlenbereichs nicht anwendbar. Übergibt man einen x-Wert außerhalb des Definitionsbereichs so liefern die Funktionen einen spezielle "Fehlerwert", es kommt nicht zum Programmabbruch! Eine Auflistung der Definitionsbereiche und Fehlerwerte finden Sie im Anhang.

Rechnet man mit den Fehlerwerten (Fehler, Unterlauf und Überlauf) weiter, so bleibt der Fehlerwert erhalten. Gibt man einen Fehlerwert aus (Z.B. PRINT oder Str$(x) ), so wird der entsprechende Text ("Fehler", "Überlauf", "Unterlauf" ausgeben.

Beispiel:

PRINT SQR(-3)  ! Das Wort "Fehler" erscheint
Einfache mathematische Funktionen:

Beispieltabelle für die einfachen mathematischen Funktionen:

Anmerkungen:

  • ROUND verwendet bei x.5 "Gerade-Zahl-Regel". Das bedeutet, dass auf die nächste gerade Zahl gerundet wird, auch bei negativen Zahlen. Beispiele:
ROUND(3.5)    -->  4
ROUND(2.5)    -->  2
ROUND(1.5)    -->  2
ROUND(-2.5)   --> -2
  • INT(x), TRUNC(x) und FRAC(x) führen vorher keine Rundung aus, sondern nehmen der Wert, wie er intern vorhanden ist. Beim Ausgeben eine Zahl (Print oder Str$) wird jedoch gerundet. Das kann zu scheinbaren Widersprüchen führen:
PRINT 4.999999999999        --> 5
PRINT INT(4.999999999999)   --> 4
PRINT FRAC(4.999999999999)  --> 1
Sollte das ein Problem sein, runden Sie den Wert vorher.

Zufalls-Zahlen:

Tipps:

  • Initialisieren Sie den Zufallsgenerator nur einmal im Programm, am besten am Programmanfang:
RANDOMIZE
  • Ganzzahlige Zufallszahlen im Bereich von 0...n-1 (jeweils einschließlich) erhält man mit:
y = INT( n * RND())
  • Warnung! RANDOMIZE und RND() verwenden den GEOS-internen Zufallsgenerator. Der Programmierer von R-BASIC kann daher nicht garantieren, dass bei verschieden Systemversionen die RND() -Funktion bei gleichem Initialisierungswert von RANDOMIZE wirklich die gleiche Zufallszahlenfolge liefert. Diese Warnung ist z.B. für kryptografische Programme bedeutsam. Der Programmierer übernimmt diesbezüglich keinerlei Haftung!

INCR und DECR

Die Anweisungen INCR (engl. increment, Zuwachs, Vergrößerung) und DECR (engl. decrement, Verringerung) vergrößern oder verkleinern den Wert einer numerischen Variablen um 1 oder um einen vorgegeben Wert n. N muss ganzzahlig sein, im Bereich von -32768 bis +32767 liegen und zur Compilezeit berechenbar sein. Einfache Berechnungen (+, -, *, /, Klammern, ^ (Exponent) , MOD (Modulo-Division), OR, AND, NOT, XOR und die Funktionen INT(), ASC() und SizeOf() ) sowie negative Werte sind zugelassen. Variablen und sonstige Funktionen sind nicht erlaubt.

Beispiele:

DIM x as REAL
DIM w as WORD
CONST D_X = 18

INCR x           ' entspricht x = x + 1
DECR w, 12       ' entspricht w = w - 12
INCR w, D_X + 2  ' entspricht w = w + 20
INCR und DECR laufen deutlich schneller als ihre Entsprechungen x = x + n bzw. x = x - n.

Transzendente Funktionen:

Trigonometrische Funktionen:

Im Bogenmaß hat ein Vollkreis nicht 360°, sondern den Wert 2. Die Umrechnungsformel lautet:

wert_im_bogenmaß = wert_im_gradmaß * PI / 180
Wenn Sie das Argument im Gradmaß haben und mit einer Genauigkeit von 4 Stellen nach dem Komma auskommen können Sie statt der in der Tabelle angegeben Funktionen auch eine der WWFixed-Funktionen FixSin, FixCos, FixTan und FixAsn verwenden. Diese Funktionen können direkt (d.h. ohne Konvertierungsfunktion) in Real-Ausdrücken verwendet werden und erwarten das Argument im Gradmaß. Details zu den WWFixed-Funktionen finden Sie im Kapitel 2.3.6.

Hyperbolische Funktionen:


^

2.3.3 Operatoren und Vergleiche

R-BASIC verfügt über die im Folgenden angegebenen mathematischen Operatoren. Eine Übersicht über die Hierarchie (Abarbeitungsreihenfolge) der Operatoren finden Sie vorn, im Kapitel 2.3.1 (Grundlagen)

Einfache Operatoren:

Tipp: Die Zeichen ^ (Exponent) * (Sternchen für Multiplikation) und - (Minus) sind eventuell nicht oder nur schwer am Bildschirm zu identifizieren. R-BASIC unterstützt daher für diese Zeichen Ersatz-Zeichen, die Sie stattdesen schreiben können, um die Lesbarkeit Ihres Codes zu verbessern.

    ^ : Exponent-Ersatzzeichen : ** (zwei Sternchen)

    * : Multiplikation-Ersatzzeichen : (AltGr+Shift+8, ASCII-Code 165)

    - : Minus-Ersatzzeichen : - (AltGr+Minus, ASCII-Code 208)

Vergleichsoperatoren

Vergleichsoperationen liefern Wahr (TRUE, -1 ) oder Falsch (FALSE, 0 )

Die Vergleichsoperatoren ( <, <=, >, >=, = <> ) stehen auch für Zeichenketten zur Verfügung. Für Variablen vom Typ FILE, HANDLE oder OBJECT sowie für Strukturen stehen die Vergleichsoperatoren = und <> zur Verfügung.

Hinweis: Statt A = B kann man für Vergleich auch ein doppeltes Gleichheitszeichen schreiben ( A == B ). Das verbessert gelegentlich die Lesbarkeit.

Logische Operatoren

Logische Operatoren wirken bitweise auf die Operanden. Eine ausführliche Erklärung sowie Beispiele finden Sie im nächsten Kapitel.

Beispiele:

Da Vergleiche höher priorisiert sind benötigt man hier keine Klammern.

NOT 4 > 7         ' liefert Wahr
3 > 7 OR 5 > -2   ' liefert Wahr
3 > 7 AND 5 > -2  ' liefert Falsch
3 > 7 XOR 5 > -2  ' liefert Wahr

^

2.3.4 Bits, Bytes, Binär- und Hexadezimalzahlen

Als fortgeschrittener Programmierer kommt man letztlich um binär und Hexadezimaldarstellungen nicht herum. Als Anfänger sollte man dieses Kapitel zumindest überfliegen, damit man eine Vorstellung davon bekommt, was das ganze eigentlich soll.

Um zu verstehen, wie Computer Zahlen darstellen, müssen wir uns zunächst darüber klar werden, wie wir das eigentlich selber im täglichen Umgang mit Zahlen machen.

Unser "normales" Dezimalsystem hat 10 Ziffern: 0 bis 9 - damit könnten wir genau 10 Zahlen darstellen, nämlich 0 bis 9. Wenn wir größere Zahlen darstellen wollen, setzen wir einfach weitere Ziffern davor - in 47 bedeutet die 4 eigentlich 4 * 10 und in 398 bedeutet die 3 in Wirklichkeit 3 * 100. Das hat man so vereinbart und jeder hält sich daran.

Da 100 = 102 ist, 10 = 101 und 1 = 100,
kann man sagen, dass gilt:

398 = 3 * 102 + 9 * 101 + 8 * 100

Dieses Prinzip wenden wir auf alle Zahlen an, wobei die 10er-Potenzen daher kommen, dass wir eben 10 Ziffern (0 bis 9) haben. Man beachte, dass, obwohl wir 10 Ziffern haben, bereits die Zahl 10 zweistellig ist - weil wir ja mit Null beginnen.

Computer kennen nur zwei Ziffern: 0 und 1 (entsprechend Strom an und Strom aus). Sie sind also gezwungen bereits eine Ziffer "davor" zu setzen, wenn sie die Zahl Zwei darstellen wollen. Die Zahlendarstellung mit nur zwei Ziffern nennen wir "binär" (bzw. Binärsystem).

Analog zur unserer üblichen Vereinbarung, dass

40 = 4 * 101 + 0 * 100
ist, gilt für Binärzahlen ebenfalls
10 = 1 * 21 + 0 * 20 bzw. 11 = 1 * 21 + 1 * 20
Wir verwenden Zweier-Potenzen, da wir genau zwei Ziffern (0 und 1) haben.

Dieses Prinzip kann man auf beliebig lange Binärzahlen anwenden. Eine weitere Vereinbarung aus unserem üblichen Dezimalsystem, nämlich dass führende Nullen zulässig sind (es ist egal ob wir 7 oder 007 schreiben), ermöglicht uns, die folgende Tabelle aufzustellen:

Jede Zahl kann man als Summe dieser "elementaren" Zweierpotenzen darstellen, z.B. ist

1010 = 23 + 21 = 8 + 2 = 10
In der Computertechnik wird eine einzelne Binärstelle als Bit bezeichnet. Ist der Wert 1, sagt man, das Bit ist "gesetzt", andernfalls ist es "nicht gesetzt". Es ist üblich, die Bits von rechts beginnend durchzunummerieren, wobei die ganz rechte Stelle als Bit Null bezeichnet wird. Das hat für den Mathematiker den Vorteil, dass die Bitposition gleich dem Potenzwert ist (Bit 0 : 20, Bit 1 : 21 usw.).

Im Beispiel oben (1010) sind also die Bits 1 und 3 gesetzt.

Mit einem Bit kann man 21 = 2 Zahlen darstellen, bei zwei Bit sind es bereits 22 = 4 Zahlen (00, 01, 10 und 11) und mit 4 Bit sind es 24 = 16 Zahlen. Das ist noch nicht sehr viel. Daher fasst man 8 Bit zu einem Byte zusammen. Ein Byte enthält also die Bits 0 bis 7:

Damit kann man 28 = 256 verschiedene Zahlen darstellen (0 bis 255). Wenn das nicht reicht, nimmt man 16 Bit, ein sogenanntes Word. Hier kommt man auf 216 = 65536 Zahlen (0 bis 65535). Für gehobene Ansprüche gibt es noch das DWord (Double word) mit 32 Bit, dort reicht der Zahlenbereich bis 4294967295.

Bereits bei einem Byte wird die Binärdarstellung unübersichtlich. Man erfasst den Unterschied zwischen 10010101 (= 149) und 10101001 (=169) nicht mehr auf den ersten Blick. Deswegen hat es sich als praktisch erwiesen, jeweils 4 Binärziffern zusammenzufassen. Mit vier Binärziffern (4 Bit) kann man aber 16 Zahlendarstellen - die Ziffern 0 bis 9 reichen da nicht mehr. Man behilft sich daher mit den ersten Buchstaben des Alphabets (konkret A bis F). Diese Darstellung nennt man hexadezimal (hexa = 6, dezi = 10).

Nach einiger Übung kommt man mit dieser zunächst sehr exotisch anmutenden Zahlendarstellung gut zurecht und wird bald die Vorteile zu schätzen wissen

Einige Beispiele:

1001 0101 = 95 (hex.) (= 149 dez.)
1010 1001 = A9 (hex.) (= 169 dez.)
1111 1111 = FF (hex.) (= 255 dez.)
1100 0111 = C7 (hex.) (= 199 dez.)
Aus der Tabelle wird ein Problem ersichtlich: ohne Kommentar kann man nicht entscheiden, ob z.B. 1001 dezimal oder binär gemeint ist (oder sogar hexadezimal?). Daher ist es in Programmiersprachen übliche, das Zahlensystem zu kennzeichnen. In R-BASIC gilt folgende Vereinbarung:
ohne Kennung: dezimal    z.B. 12
Kennung &H: hexadezimal  z.B. &H95   (= 149 dez.)
Kennung &B: binär        z.B. &B1100 (= 12 dez.)
Rein formal kann man auch beim Hexadezimalsystem mit der Potenzdarstellung arbeiten, nur dass hier die Basis 16 verwendet werden muss (beachte: 160 = 1):
 &h95 = 9 * 161 + 5 * 160 = 144 + 5 = 149
 &hA9 = A * 161 + 9 * 160 = 10 * 161 + 9 * 160 = 160 + 9 = 169
Dieses Verfahren kann man verwenden, wenn man Hexadezimalzahlen "von Hand" in Dezimalzahlen umwandeln muss. Die meisten wissenschaftlichen Taschenrechner verfügen aber heute über entsprechende Funktionen.

R-BASIC bietet über das Menü "Extras" -> "Tools" ein kleines Programm an (HBDConverter, © by John Howard and used by permission), mit dem man Binär-, Dezimal- und Hexadezimalzahlen ineinander umrechnen kann. Das Programm ist in der Standardinstallation von R-BASIC nicht enthalten, es muss separat von der R-BASIC-Webseite heruntergeladen werden.

Außerdem gibt es die Stringfunktionen Hex$( ) und Bin$( ), mit denen Sie Zahlen in hexadezimaler und binärer Darstellung ausgeben können.

Was passiert eigentlich, wenn man bei einem Byte zu der größten darzustellenden Zahl (255 = &HFF) noch Eins addiert? Eigentlich kommt ja 256 (=&H100) heraus. Im Binärsystemsieht das so aus:

Diese Zahl hat 9 Bit und kann in einem Byte nicht mehr dargestellt werden. Man hat festgelegt, dass in einem solchen Fall, die wir Überlauf nennen, die führenden Bits, die nicht in das Byte passen, ignoriert werden: 255 + 1 ist also in diesem Fall Null. "In diesem Fall" heißt, dass wir das Ergebnis in einem Byte speichern wollen. Haben wir ein Word (16 Bit) zur Verfügung, können wir das Ergebnis sehr wohl abspeichern und es kommt 256 heraus. Erst 65535 + 1 ergäbe 65536, was nicht mehr in ein Word passt und daher wieder Null ergibt. Dieses Phänomen muss man kennen, wenn man mit Bits und Bytes direkt arbeitet.

Das Problem des Überlaufs führt immer wieder zu schwer auffindbaren Fehlern. In R-BASIC sollte daher nach Möglichkeit der Datentyp REAL (Genauigkeit 10 Byte) verwendet werden. Da intern alle Berechnungen mit REAL-Zahlen ausgeführt werden, ist dieser Datentyp auch fast am schnellsten. Nur WWFixed ist schneller.

Wenn Sie die "kleinen" Datentypen verwenden müssen, stehen Ihnen in R-BASIC die Typen Byte, Word , Integer, DWord, LongInt (4 Byte, mit Vorzeichen) sowie der Typ WWFixed zur Verfügung. Im Kapitel 2.2.2 (Numerische Datentypen und numerische Ausdrücke) finden Sie weitere Informationen dazu.

Und nun noch die verrückten Mathematiker ... (oder: Futter für Fortgeschrittene)

Ein Mathematiker wird sich schnell beschweren, dass es keine negativen Zahlen gibt. Aber ihm kann geholfen werden. Wie bereits mehrfach erwähnt, basiert bei der Zahlendarstellung sehr viel auf Vereinbarungen.

Wie wir gerade gesehen haben ergibt, wenn wir ein Byte binär betrachten,

1111 1111 + 1 = 0
Also muss gelten:
0 - 1 = 1111 1111
0-1 ist aber -1. Es macht daher Sinn, wenn man negative Zahlen benötigt, festzulegen, dass alle Zahlen, deren führendes Bit gesetzt ist (beim Byte also Bit 7, beim Word das Bit 15), negative Zahlen sein sollen.
0000 0000 =  0
1111 1111 = -1
1111 1110 = -2
usw. bis
1000 0000 = -128
Man kann in einem Byte also Zahlen von -128 bis +127 darstellen - insgesamt wieder 256 verschiedene Zahlen. Man nennt diese Darstellung "Zweierkomplement".

Offensichtlich ist es nur eine Frage der Vereinbarung, ob man die Binärzahl 1111 1111 als -1 oder als + 255 auffasst. Das ist sicher anfänglich sehr verwirrend und zum Glück benötigt man diese Informationen nur sehr selten.

Dem Computer ist das letztlich egal, denn die Rechenregeln sind so aufgestellt, dass er immer so tun kann, als seien alle Zahlen positiv. Tun wir es ihm nach.

^

2.3.5 Logische Operatoren und Bit-Operationen

In R-BASIC sind die folgenden bitweisen logischen Operatoren und Funktionen definiert:

Zur Arbeit mit den bitweisen logischen Operationen sind die folgenden Konstanten hilfreich:

TRUE ist als -1 definiert weil in der Binärdarstellung dann alle Bits gesetzt sind. Das ermöglich eine einfache Zusammenarbeit von Vergleichen (sie liefern TRUE oder FALSE) und logischen Operationen (z.B. AND oder OR).

^

2.3.5.1 Logische Ausdrücke in Entscheidungen

In einigen Situationen (z.B. bei den Anweisungen IF und WHILE, siehe Kapitel 2.5) muss R-BASIC Entscheidungen treffen. Dazu wird ein numerischer Ausdruck ausgewertet. In vielen Fällen ist das einfache Vergleichsoperation.

Beispiele:

 IF A > B THEN ...
 IF (A + B) > 12 THEN ...
 WHILE A > 0
   ...
 WEND
Gelegentlich müssen aber mehrere Bedingungen erfüllt sein. Zum Beispiel kann es sein, dass A > B und C < 0 gleichzeitig gelten muss. Oder es reicht aus wenn eine der Bedingungen X > Y oder Z < 0 erfüllt ist.

Natürlich kann man die Bedingungen nacheinander abfragen. Aber eleganter und effizienter ist es, die Bedingungen durch logische Operationen zu verknüpfen.

Wenn R-BASIC eine Vergleichsoperation ausführt kann das Ergebnis wahr (TRUE) oder falsch (FALSE) sein. Für die Verknüpfung mithilfe logischer Operatoren gilt folgendes:

  • NOT A ist wahr, wenn A falsch ist und umgekehrt.

  • A AND B ist wahr wenn sowohl A als auch B wahr sind

  • A OR B (logsiches ODER) ist wahr wenn A oder B, oder beide wahr sind

  • A XOR B (exklusives ODER) ist wahr wenn entweder A oder B wahr sind. Sind beide wahr liefert A XOR B falsch.
Die folgende Tabelle verdeutlicht das. A und B seien Ergebnisse einer Vergleichsoperation, die wahr (W, TRUE, -1) oder falsch (F, FALSE, 0) sein können.

Beispiele

Da die Vergleichsoperatoren höher priorisiert sind als die logischen Operatoren führt R-BASIC zuerst die Vergleiche aus und verknüpft deren Ergebnisse anschließend mit den logischen Operationen. Wenn Sie mehrere logische Operatoren verwenden sollten Sie Klammern setzten.

IF A > 0 THEN ...
IF A > 0 OR Name$ = "Paul" THEN ...
IF ( A >= 0 AND A <= 9 ) OR ( A >= 100 AND A <= 109 ) THEN ...

REPEAT
 ...
UNTIL C > 0 AND D = 7
Wenn R-BASIC eine Entscheidung trifft (IF, WHILE, UNTIL) prüft es, ob der entsprechende numerische Ausdruck Null ist oder nicht. Jeder Wert, der nicht Null ist, wird als wahr angesehen. Folgende Formulierungen sind daher gleichwertig:
IF A <> 0 THEN ...
IF A THEN ...
Ein Wert kann also "wahr" sein (z.B. 12) ohne TRUE (-1) zu sein. Vermeiden Sie daher Formulierungen wie die folgende, das kann zu schwer zu findenden Fehlern führen.
' Möglicherweise fehlerhafter Code:
IF A = TRUE THEN ..   ' ist nur erfüllt, wenn A den Wert -1 hat

^

2.3.5.2 Anwendung der logischen Operatoren auf Zahlen

Achtung! Das ist ein sehr komplexes, aber auch ein sehr leistungsfähiges Thema. Kenntnisse in Logik, der Binär- und Hexadezimal-Darstellung von Zahlen sind hilfreich.

Intern werden die logischen Operatoren bitweise auf 16-Bit Zahlen (Datentyp Word) angewandt. Andere Datentypen werden vorher in den Datentyp Word konvertiert. Dadurch können die logischen Operatoren auch auf alle Zahlen angewendet und in numerischen Ausdrücken verwendet werden.

Beispiele:

DIM A, B, Y
 A = 3        ' einfache Zuweisung
 B = 7 AND A
 Y = B OR 4
 Y = NOT ( ( A + 5 ) AND 7 )
Wichtig ist das Setzen von Klammern. Der Compiler hat zwar eine bestimmte Hierarchie bei der Abarbeitung der logischen Operatoren, es kommt hier jedoch sehr schnell zu Fehleinschätzungen von Seiten des Programmierers.

Zum Verständnis der Wirkung von logischen Operatoren auf Zahlen muss man die Zahlen in die Binär-Darstellung umwandeln. Binärzahlen sind im Kapitel 2.3.4 erklärt.

Bei der logischen Verknüpfung von Zahlen passiert folgendes:

  • Die Operanden werden in ein 16-Bit-Bitmuster umgewandelt (Datentyp: Word)

  • Die Bitmuster werden entsprechend der folgenden Tabelle bitweise miteinander verknüpft.
Logische Operatoren bei Anwendung auf einzelne Bits

Beispiel für die Anwendung logischer Operatoren auf Zahlen. Aus Platzgründen werden in der Binärdarstellung nur die unteren 4 Bit betrachtet. In Klammern steht die zugehörige Dezimalzahl.

Die logische Operation NOT negiert alle Bits. Die folgende Tabelle verdeutlicht das.

Wenn Sie mit Hilfe der logischen Operatoren Bit-Manipulationen vornehmen, sollten Sie Variablen vom Datentyp WORD oder BYTE verwenden, um unerwartete Ergebnisse zu vermeiden. Insbesondere kann es passieren, dass negative Zahlen auftreten. Dies ist kein Fehler, denn es ist auch möglich, negative Zahlen mit logischen Operatoren zu verknüpfen. Dazu muss man folgendes wissen:

  • Logische Operatoren arbeiten gleichwertig mit vorzeichenbehafteten und mit vorzeichenlosen 16-Bit-Zahlen.

  • Eine vorzeichenbehaftete 16-Bit-Zahl ist negativ, wenn das höchstwertige Bit (Bit 15) gesetzt ist.

  • Die Zusammenarbeit von logischen Operatoren mit den Vergleichsoperatoren funktioniert deshalb, weil in - 1 alle Bits gesetzt sind, während in der Null kein Bit gesetzt ist. Deswegen ist TRUE als - 1 definiert

  • Die bitweise Verwendung von vorzeichenbehafteten Ganzzahlen macht selbst erfahrenen Programmieren oft Mühe.
Mann kann die logischen Verknüpfungen von Zahlen auch direkt in einer IF-Anweisung (bzw. WHILE-WEND oder REPEAT-UNTIL-Anweisung) verwenden. Allerdings muss man hier beachten, dass jede Zahl, die nicht Null ist, als "wahr" interpretiert wird. Im folgenden Codefragment wird deshalb der THEN-Zweig nicht abgearbeitet. Der Grund ist, das die logische Verknüpfung 4 AND 2 den Wert Null liefert.
DIM A, B
 A = 4
 B = 2
 IF A AND B THEN
   ...
 End IF

^

2.3.5.3 Bit-Schiebe-Operationen

Um die in diesem Abschnitt beschriebenen Kommandos verwenden zu können sollten Sie sich mit der Binärdarstellung von Zahlen (siehe Kapitel 2.3.4) auskennen.

SHL, Shl32

Die Funktion SHL (Shift Left - schiebe nach links) führt eine bitweise Schiebeoperation auf ein 16-Bit-Word aus. Shl32 führt diese Operation auf ein 32-Bit-DWord aus. Die niederwertigen Bits werden mit Null aufgefüllt, die höchstwertigsten Bits gehen verloren.
Syntax:
<numVar> = SHL (x, n)
<numVar> = Shl32 (x, n)
x: numerischer Ausdruck
16-Bit-Word bei SHL, 32-Bit-DWord bei Shl32
n: Anzahl der Bits, um die geschoben werden soll.


Beispiel:
y = SHL(7, 2)  ' 7 ist binär 000111, also ist y = 011100 (binär), d.h. y = 21

SHR, Shr32

Die Funktion SHR (Shift Right - schiebe nach rechts) führt eine bitweise Schiebeoperation auf ein 16-Bit-Word aus. Shr32 führt diese Operation auf ein 32-Bit-DWord aus. Die höchstwertigen Bits werden mit Null aufgefüllt, die niederwertigsten Bits gehen verloren.
Syntax:
<numVar> = SHR (x, n)
<numVar> = Shr32 (x, n)
x: numerischer Ausdruck
16-Bit-Word bei SHL, 32-Bit-DWord bei Shl32
n: Anzahl der Bits, um die geschoben werden soll.


Beispiel:
y = SHR(12, 2)  ' 12 ist binär 001100, also ist y = 000011 binär, d.h. y = ???

^

2.3.5.4 Sonderfall: Bitflags

In vielen Fällen ist es so, dass ein Wert vom Datentyp WORD so interpretiert werden muss, dass jedes einzelne Bit eine eigene Bedeutung hat. Jedes Bit zeigt an, ob eine bestimmte Eigenschaft vorhanden ist oder nicht. Es ist wie eine Flagge (englisch: flag), die gesetzt sein kann (das Bit ist 1) oder nicht (das Bit ist Null). In dieser Situation sagt man, der Wert enthält Bitflags. Alternativ wird auch der Begriff Flagbits verwendet.

Ein Beispiel ist die globale Variable printFont.style. Die einzelnen Bits enthalten jeweils die Information ob der Text zum Beispiel fett (Bit TS_BOLD gesetzt), unterstrichen (TS_UNDERLINE gesetzt) oder kursiv (Bit TS_ITALIC gesetzt) ausgegeben werden soll. Sind alle drei Bits gesetzt, so wird der Text fett kursiv und unterstrichen ausgegeben.

Ein anderes Beispiel ist die Instancevariable csFeatures des ColorSelector-Objekts. Sie enthält für jedes UI-Element, dass der ColorSelector darstellen kann, ein Bit, das angibt, ob dieses UI-Element gezeigt oder verborgen werden soll. Gerade bei Instancevariablen und UI-Objekten kommen Bitflags relativ häufig vor.

Die Herausforderung bei Bitflags besteht darin, dass einzelne Bits gesetzt, zurückgesetzt oder angefragt werden müssen, ohne dass die anderen Bits beeinflusst werden. Hier helfen uns die logischen Operatoren (NOT, AND, OR, XOR) weiter.

Um ein Bit zu setzen verwenden wir die Operation OR. Das Ergebnis einer OR-Operation ist wahr, wenn mindestens einer der Operanden wahr ist.

neueBitFlags  = alteBitFlags OR bitsZuSetzen
Beispiele zum Setzen von Bits mit OR

Beispiel: Setzen des Bits TS_BOLD in der globalen Variablen printFont.style. Die Textausgabe erfolgt anschließend fett, egal ob sie vorher schon fett erfolgte oder nicht.

printFont.style = printFont.style OR TS_BOLD
Es ist möglich mehrere Bits gleichzeitig zu setzen. Das folgende Codefragment stellt sicher dass sowohl das Bit TS_BOLD als auch das Bit TS_ITALIC gesetzt sind.
printFont.style  = printFont.style OR TS_BOLD OR TS_ITALIC
Um ein Bit zu zurückzusetzen (zu löschen) verwenden wir die Operatoren AND und NOT. Zuerst invertiert die NOT-Operation alle zu löschenden Bits, dann setzt die AND-Operation die zum Löschen vorgesehenen Bits auf Null.
neueBitFlags  = alteBitFlags AND ( NOT bitsZuLöchen )
Die Klammern sind eigentlich nicht nötig, da die NOT-Operation höher priorisiert ist, als die AND-Operation. Es wird aber dringend empfohlen bei Verwendung von mehreren logischen Operatoren innerhalb einer Anweisung Klammern zu setzen. Der Compiler vertut sich niemals mit der Hierarchie, der Programmierer schon.

Beispiele zum Löschen von Bits mit AND und NOT

Beispiel: Löschen des Bits TS_BOLD in der globalen Variablen printFont.style. Die Textausgabe erfolgt anschließend nicht fett, egal ob sie vorher fett erfolgte oder nicht.

printFont.style  = printFont.style AND ( NOT TS_BOLD )

Es ist möglich, mehrere Bits gleichzeitig zu löschen. Dazu müssen die zu löschenden Bits zunächst OR-Verknüpft werden. In diesem Fall ist notwendig, um die zu löschenden Bit eine Klammer zusetzen, weil OR niedriger priorisiert ist als NOT. Der Compiler gibt daher eine Warnung aus, wenn wir die Klammern vergessen.

Das folgende Codefragment stellt sicher dass sowohl das Bit TS_BOLD als auch das Bit TS_ITALIC gelöscht sind.

printFont.style  = printFont.style AND \
                 ( NOT ( TS_BOLD OR TS_ITALIC ) )
Um ein Bit zu invertieren verwenden wir die Operation XOR. Das Ergebnis einer XOR-Operation ist nur dann wahr wenn genau einer der Operanden wahr ist. Sind beide wahr ist das Ergebnis falsch.
neueBitFlags  = alteBitFlags XOR bitsZuInvertieren
Beispiele zum Invertieren von Bits mit XOR

Beispiel: Invertieren des Bits TS_UNDERLINE in der globalen Variablen printFont.style. Die Textausgabe erfolgt anschließend unterstrichen wenn sie vorher normal erfolgte. War sie vorher unterstrichen erfolgt sie jetzt normal.

printFont.style  = printFont.style XOR TS_UNDERLINE
Es ist möglich mehrere Bits gleichzeitig zu invertieren. Dazu müssen die zu invertierenden Bits zunächst OR-Verknüpft werden. In diesem Fall ist notwendig, um die zu löschenden Bit eine Klammer zusetzen, weil OR niedriger priorisiert ist als NOT. Der Compiler gibt daher eine Warnung aus, wenn wir die Klammern vergessen.

Das folgende Codefragment schaltet sowohl das Bit TS_BOLD als auch das Bit TS_ITALIC um.

printFont.style  = printFont.style XOR ( TS_BOLD OR TS_ITALIC )
Um ein Bit abzufragen verwenden wir die Operation AND. Das Ergebnis einer AND-Operation ist wahr, wenn beide Operanden wahr sind.
ergebnis  = bitFlags AND bitsZuTesten
Beispiele zum Abfragen von Bits mit AND

In der letzten Zeile der Tabelle ist zu sehen, dass das Ergebnis ungleich Null ist, obwohl nur eins der zu testenden Bits gesetzt ist. In einer IF-Anweisung wird aber jeder Wert ungleich Null als wahr angesehen. Deswegen müssen wir beim Testen von mehreren Bits unterscheiden, ob es uns reicht, dass eins der zu prüfenden Bits gesetzt ist oder ob alle Bits gesetzt sein müssen.

Beispiel: Testen, ob das Bit TS_BOLD in der globalen Variablen printFont.style gesetzt ist. Der THEN-Zweig wird ausgeführt wenn das Bit gesetzt ist, egal wie die anderen Bits aussehen.

IF printFont.style AND TS_BOLD THEN
 ...
END IF

Abfrage von mehreren Bits

Wenn es ausreicht zu wissen, ob eins der zu prüfenden Bits gesetzt ist, reicht eine einfache Abfrage mit AND aus (siehe auch Tabelle vorn). In der Zahl 3 sind die Bits Null (20 = 1) und Eins (21 = 2) gesetzt. Das folgende Codefragment fragt ab, ob in der Variablen A das Bit Null oder das Bit Eins (oder beide) gesetzt sind.
IF A AND 3 THEN
 ....
END IF

Beispieltabelle für das Codefragment oben

Wenn wir sicherstellen wollen, dass alle zu prüfenden Bits gesetzt sind, müssen wir das Ergebnis der AND-Verknüpfung mit den zu prüfenden Bits vergleichen. Das folgende Codefragment zeigt das wieder am Beispiel der Bits Null und Eins (Vergleichswert: 21 + 20 = 3). Die Klammern sind erforderlich, weil Vergleiche höher priorisiert sind als die AND-Operation!

IF ( A AND 3 ) = 3 THEN
 ....
END IF
Beispieltabelle für das Codefragment oben. Beachten Sie die letzte Zeile!


^

2.3.6 Schnelle Mathematik mit WWFixed

Der hohen Genauigkeit und dem großen Wertebereich des Zahlenbereichs REAL, mit der R-BASIC im Normalfall rechnet, steht als Nachteil eine höhere Rechenzeit gegenüber. R-BASIC bietet deswegen mit den Datentyp WWFixed (Word-Word-Fixed) die Möglichkeit, von der schnelleren Ganzzahlarithmetik zu profitieren. Da der Zeitbedarf zum Lesen und Schreiben von Variablen sowie der Analyse des mathematischen Terms gleich bleibt hängt der erreichbare Geschwindigkeitsvorteil etwas von der Situation ab. Reine WWFixed-Berechnungen laufen ca. 25% bis 30% schneller. Wenn Sie innerhalb eines WWFixed-Ausdrucks auf Real-Variablen zugreifen verringert sich der Laufzeitvorteil wegen der notwendigen Konvertierungen geringfügig.

Im Folgenden werden "normale" numerische Ausdrücke mit den Datentypen REAL, Byte, Word, DWord, Integer und LongInt als "Real"-Ausdrücke bezeichnet. Hier rechnet R-BASIC immer mit 10-Byte Real-Zahlen. Im Gegensatz dazu stehen die "WWFixed"-Ausdrücke, in denen R-BASIC die schnellere Ganzzahlarithmetik verwendet.

Konvertierungsfunktionen

WWFixed-Werte sind nur begrenzt zuweisungskompatibel mit den anderen numerischen Datentypen. Das ist Absicht, damit nicht durch die gemischte Verwendung von Real- und WWFixed-Werten der Performancegewinn unabsichtlich aufgebraucht wird.

Wenn Sie das Ergebnis einer WWFixed-Rechnung in einem Real-Ausdruck verwenden wollen oder einen Real-Wert in eine WWFixed-Rechnung einbinden möchten müssen Sie in meistes die folgenden schnellen Konvertierungsroutinen benutzen. Es gibt jedoch auch Ausnahmen, die weiter unten beschrieben sind.

Beispiele

DIM f1, f2 AS WWFixed
DIM a as REAL
 f1 = MakeFixed( MyNumberObj.value )
 f2 = MakeFixed( ASC( "A" ) )
 LINE 0, 0, FixToWord( f1 ), FixToWord ( f1 + f2 )
 MyNumberObj.value  = FixToReal ( f1 * f2 )
 a = FixToReal (f1/f2)
Der Datentyp WWFixed besteht intern aus einem DWord. Das höherwertige Word wird als vorzeichenbehafteter ganzzahliger Anteil interpretiert (Wertebereich: Integer), das niederwertige Word ist der gebrochene Anteil. Ein Bit entspricht damit einem Wert von 1,52610-5. Daraus ergibt sich ein Wertebereich von
- 32768.0000 <= x <= 32767.99999
mit einer Genauigkeit von 4 Stellen nach dem Komma. Diese Genauigkeit ist für viele Anwendungen völlig ausreichend.

Sie können Berechnungen mit WWFixed-Werten genau so programmieren, wie mit jedem anderen numerischen Datentyp. Es gibt jedoch drei Ausnahmen:

  • Die Verwendung von einigen mathematischen Funktionen ist nicht zulässig. In den Tabellen unten finden Sie die zugelassenen Funktionen.

  • Das Lesen von numerischen Instancevariablen ist nicht zulässig.

  • Die Verwendung der Operationen MOD und ^ (x-hoch-y) ist nicht möglich. Sie müssen in diesen Fällen die Konvertierungsfunktion MakeFixed( ) benutzen.
Der Compiler erwartet eine WWFixed-Ausdruck in zwei Fällen
  1. Wir haben eine Zuweisung zu einer WWFixed Variablen.

  2. Wir haben eine Sund oder Function, die einen WWFixed Paramter erwartet. ???
Zulässig für WWFixed-Ausdrücke sind:
  • Zahlen (in beliebiger Schreibweise, auch mit binär, hexadezimal und mit Exponent)

  • Numerische BASIC-Konstanten (wie z.B. PI oder GREEN) und selbst definierte Konstanten (Anweisung: CONST). Der R-BASIC Compiler rechnet den Wert automatisch in eine WWFixed-Zahl um.

  • Grundrechenarten und Klammern

  • Variablen vom Typ WWFixed

  • Funktionen (auch selbst definiert) mit dem Rückgabetyp WWFixed

  • Logische Operatoren

  • Vergleichsoperatoren
Um den extensiven Gebrauch der Konvertierungsfunktionen zu vermeiden sind zusätzlich folgende Elemente zulässig:
  • Variablen der anderen numerischen Datentypen. Die Werte werden von R-BASIC automatisch in den Datentyp WWFixed konvertiert.

  • Die in den Tabellen unten ausgewiesenen numerischen Funktionen. R-BASIC verwendet in diesem Fall nicht den gleichen Code wie für Real-Funktionen sondern spezielle, für die Verwendung von WWFixed-Werten angepasste Funktionen.
Berechnungen mit WWFixed Werten führt R-BASIC mit der schnellen 32 Bit Ganzzahlarithmetik durch. Es erfolgt keine Fehlerprüfung. Das bedeutet:
  • Überträge werden nicht erkannt. Multipliziert oder addiert man zum Beispiel zwei WWFixed-Zahlen und das Ergebnis ist größer als 32768, so werden die höherwertigsten Bits abgeschnitten. Das Ergebnis ist selbst für erfahrene Programmierer schwer vorherzusehen. Häufig entstehen sogar negative Zahlen.

  • Division durch Null oder die Wurzel aus einer negativen Zahl führt nicht zu einem Fehler sondern zu einem zufälligen Wert.

  • Zuweisung von Werten außerhalb des gültigen Wertebereichs führt häufig zu "unerwarteten" Ergebnissen.
Prüfen Sie vor der Verwendung von WWFixed-Berechnungen unbedingt, ob die Berechnungen den zulässigen Wertebereich nicht überschreiten können. Die Verletzung dieser Regel kann zu schwer auffindbaren Fehlern führen!

Rechenoperationen

Innerhalb von WWFixed-Ausdrücken sind die folgenden Rechenoperationen erlaubt:

Die Operationen MOD (Division mit Rest) und ^ (x-hoch-y) sind innerhalb von WWFixed-Ausdrücken nicht zulässig.

Beispiele:

DIM a, b, c AS WWFixed
CONST f = PI/2
 a = 12.5
 b = 180 * f * a
 c = 12 *( a + b) / PI
 PRINT "Ergebnis = "; FixToReal(c)
DIM a, b, c AS WWFixed
 b = a OR 7
 c = a AND 2
Die logischen Operationen liefern WWFixed-Werte, wenn Sie in WWFixed-Ausdrücken verwendet werden. Auch hier müssen Sie die Konvertierungsfunktion FixToReal benutzen, wenn Sie logische Operationen mit WWFixed-Werten innerhalb einer Entscheidungsanweisung verwenden.

Beispiele:

DIM fa, fb AS WWFixed
 fa = fb OR 4   ' einfache Zuweisung
 IF FixToReal( fa AND 2 ) THEN ...
 WHILE FixToReal( fa AND 1 )
   ....
 WEND
Die Vergleichsoperationen liefern TRUE (numerischer Wert: -1) oder FALSE (numerischer Wert: 0). Das Ergebnis ist ein WWFixed-Wert. Da IF-Anweisungen (und andere Entscheidungsoperationen wie WHILE) einen Real-Ausdruck erwarten müssen Sie hier die Konvertierungsfunktion FixToReal benutzen.

Beispiele:

DIM fa, fb AS WWFixed
 IF FixToReal( fa > fb ) THEN ...
 WHILE FixToReal( fa < 0 )
   ....
 WEND

Einfache mathematische Funktionen

Um den gehäuften Aufruf der Konvertierungsfunktionen zu vermeiden, können innerhalb von WWFixed-Ausdrücken die folgenden einfachen numerischen Funktionen verwendet werden. Der Compiler erkennt dabei, dass es sich um einen WWFixed-Ausdruck handelt und compiliert den Aufruf einer für WWFixed optimierten Routine. Dadurch profitieren diese Funktionen ebenfalls vom Geschwindigkeitsvorteil der WWFixed-Mathematik. Syntaktisch unterscheidet sich die Verwendung der Funktionen nicht von ihren Real-Versionen. Ausnahme ist die Round-Funktion. Hier ist kein zweiter Parameter zulässig und bei x.5 wird immer nach unten gerundet.

Beispiele:

DIM a, b, c, d as WWFixed
 a = 12.3
 b = INT(a)
 c = FRAC(a)
 d = 4 * ROUND(a) - b * SizeOf(WWFixed)

Höhere mathematische Funktionen

Für WWFixed-Ausdrücke sind die folgenden höheren Funktionen definiert. R-BASIC verwendet zur Berechnung dieser Funktionen die schnelle Ganzzahlarithmetik.

Für das Argument der Winkelfunktionen sind auch Werte außerhalb des Bereichs 0 bis 360° zulässig. Das gilt auch für negative Werte. FixAsn und FixSqr arbeiten nur für positive Argumente korrekt. Negative Argumente führen zu fehlerhaften Ergebnissen, aber nicht zu einer Fehlermeldung.

Alle in der Tabelle oben angegeben Funktionen sind auch innerhalb von Real-Ausdrücken zulässig. Der R-BASIC Compiler erkennt den Aufruf dieser Fixed-Funktionen und compiliert automatisch den Aufruf der Konvertierungsfunktion FixToReal( ).

Die Winkelfunktionen für WWFixed-Ausdrücke unterscheiden sich von den Winkelfunktionen der Real-Ausdrücke dadurch, dass sie das Argument im Gradmaß (der Vollkreis hat 360°) erwarten. Die Real-Winkelfunktionen erwarten das Argument dagegen im Bogenmaß (ein Vollkreis entspricht 2). Wenn Sie das Argument im Bogenmaß haben brauchen Sie es nicht selbst ins Gradmaß umzurechnen. Stattdessen können Sie innerhalb von WWFixed-Ausdrücken die in der folgenden Tabelle angegebenen Real-Winkelfunktionen direkt verwenden. R-BASIC erkennt, dass es sich um einen WWFixed-Ausdruck handelt, rechnet das Argument automatisch ins Bogenmaß um und ruft dann die entsprechende Fixed-Funktion auf. Da ist sogar noch etwas schneller als die manuelle Umrechnung.

Beispiele:

DIM x, y AS WWFixed
 y = 50 * FixSin(x) + 150   ' x im Gradmaß
 y = 1/TAN(x)               ' Cotangens, x im Bogenmaß

^

2.3.7 Exkurs: Vergleiche innerhalb numerischer Ausdrücke

Achtung! Die folgenden Ausführungen richten sich an fortgeschrittene Programmierer. Sie sind daher möglicherweise etwas abstrakt. Ihr Verständnis kann hilfreich sein, ist aber zur Anwendung innerhalb von Entscheidungsausdrücken nicht unbedingt erforderlich.

Intern behandelt R-BASIC Vergleichsausdrücke und logische Ausdrücke als Zahlen. Das hat Konsequenzen: Jeder Vergleich liefert entweder TRUE (wahr, -1) oder FALSE (falsch, Null). Es ist deshalb möglich, das Ergebnis eines Vergleichs in einer numerischen Variablen abzuspeichern.

Beispiele (DIM A, B, Y vorausgesetzt):

Y = A > 0
Der Compiler erkennt die Zuweisung "Y =" und berechnet den numerischen Ausdruck auf der rechten Seite. Da "A > 0" ein gültiger numerischer Ausdruck ist, der TRUE (-1) oder FALSE (0) liefern kann, wird Y der Wert 0 oder -1 zugewiesen, je nachdem ob A größer Null ist, oder nicht.
Y = Name$ = "Paul"
Der Compiler erkennt wieder die Zuweisung "Y =" und berechnet den rechten Ausdruck (den Vergleich Name$ = "Paul"), der wiederum TRUE (-1) oder FALSE (0) ergeben kann.

In diesem Zusammenhang sind Vergleichsausdrücke nur spezielle numerische Ausdrücke:

Beispiel 1:

Y = (B < 7) AND (Name$ = "Paul")
Der Compiler berechnet die Ausdrücke (B < 7) und (Name$ = "Paul"), die jeweils TRUE (-1) oder FALSE (0) ergeben. Anschließend wird die logische Verknüpfung AND ausgeführt. AND ist zwar eine bitweise Funktion, aber das Zusammenspiel funktioniert, da in TRUE alle 16 Bit gesetzt sind, während in FALSE alle 16 Bit Null sind. Y wird TRUE, wenn beide Bedingungen erfüllt sind und FALSE, wenn mindestens eine Bedingung nicht erfüllt ist.

Beispiel 2:

Y = ( A > 5 ) AND 7    ' Liefert 0 oder 7, je nach A

^

Weiter...