Programmieren mit Harald R. Haberstroh

Hier finden Sie ein paar Übungsbeispiele zu Gleitkommazahlen sowie die dazugehörige Lösung. Zunächst Konvertierung von Dezimalzahlen in Gleitkommazahlen. Es sind die Zahlen immer alle drei Formate zu bestimmen:

-0,15087890625

Nachkommateil:
0.15087891 | 0
0.30175781 | 0
0.60351562 | 1
0.20703125 | 0
0.41406250 | 0
0.82812500 | 1
0.65625000 | 1
0.31250000 | 0
0.62500000 | 1
0.25000000 | 0
0.50000000 | 1
Gesamt: 1 ,00100110101                (die 1 steht für das Vorzeichen -)
Mantisse wäre: 1001101010
Exponent wäre: -2
Exponent umwandeln:
         2 | 0
         1 | 1
Exponent unbeschränkt positiv: 10
Exponent mit führenden Nullen: 0010
Zweierkomplement:
   Einerkomplement:            1101
                                  1
   Zweierkomplement:           1110
Exponent: 1110, Vorzeichen: 1

vm m  m  m  m  m  m  m  m  m  m  ve e  e  e  e  
1  1  0  0  1  1  0  1  0  1  0  1  1  1  1  0 

vm ve e  e  e  e  m  m  m  m  m  m  m  m  m  m  
1  1  1  1  1  0  1  0  0  1  1  0  1  0  1  0 

ve e  e  e  e  vm m  m  m  m  m  m  m  m  m  m  
1  1  1  1  0  1  1  0  0  1  1  0  1  0  1  0 

33

ganzzahliger Teil:
        33 | 1
        16 | 0
         8 | 0
         4 | 0
         2 | 0
         1 | 1
Nachkommateil:
Gesamt: 0 100001,                (die 0 steht für das Vorzeichen + - beachte den Abstand)
Mantisse wäre: 1000010000
Exponent wäre: 6
Exponent umwandeln:
         6 | 0
         3 | 1
         1 | 1
Exponent unbeschränkt positiv: 110
Exponent: 0110, Vorzeichen: 0

vm m  m  m  m  m  m  m  m  m  m  ve e  e  e  e  
0  1  0  0  0  0  1  0  0  0  0  0  0  1  1  0 

vm ve e  e  e  e  m  m  m  m  m  m  m  m  m  m  
0  0  0  1  1  0  1  0  0  0  0  1  0  0  0  0 

ve e  e  e  e  vm m  m  m  m  m  m  m  m  m  m  
0  0  1  1  0  0  1  0  0  0  0  1  0  0  0  0 

470,171875

ganzzahliger Teil:
       470 | 0
       235 | 1
       117 | 1
        58 | 0
        29 | 1
        14 | 0
         7 | 1
         3 | 1
         1 | 1
Nachkommateil:
0.17187500 | 0
0.34375000 | 0
0.68750000 | 1
0.37500000 | 0
0.75000000 | 1
0.50000000 | 1
Gesamt: 0 111010110,001011
Mantisse wäre: 1110101100
Exponent wäre: 9
Exponent umwandeln:
         9 | 1
         4 | 0
         2 | 0
         1 | 1
Exponent unbeschränkt positiv: 1001
Exponent: 1001, Vorzeichen: 0

vm m  m  m  m  m  m  m  m  m  m  ve e  e  e  e  
0  1  1  1  0  1  0  1  1  0  0  0  1  0  0  1 

vm ve e  e  e  e  m  m  m  m  m  m  m  m  m  m  
0  0  1  0  0  1  1  1  1  0  1  0  1  1  0  0 

ve e  e  e  e  vm m  m  m  m  m  m  m  m  m  m  
0  1  0  0  1  0  1  1  1  0  1  0  1  1  0  0 

-17,2145

ganzzahliger Teil:
        17 | 1
         8 | 0
         4 | 0
         2 | 0
         1 | 1
Nachkommateil:
0.21450000 | 0
0.42900000 | 0
0.85800000 | 1
0.71600000 | 1
0.43200000 | 0
0.86400000 | 1
0.72800000 | 1
0.45600000 | 0
0.91200000 | 1
0.82400000 | 1
0.64800000 | 1
0.29600000 | 0
0.59200000 | 1
0.18400000 | 0
0.36800000 | 0
0.73600000 | 1
0.47200000 | 0
0.94400000 | 1
Gesamt: 1 10001,001101101110100101
Mantisse wäre: 1000100110
Exponent wäre: 5
Exponent umwandeln:
         5 | 1
         2 | 0
         1 | 1
Exponent unbeschränkt positiv: 101
Exponent: 0101, Vorzeichen: 0

vm m  m  m  m  m  m  m  m  m  m  ve e  e  e  e  
1  1  0  0  0  1  0  0  1  1  0  0  0  1  0  1 

vm ve e  e  e  e  m  m  m  m  m  m  m  m  m  m  
1  0  0  1  0  1  1  0  0  0  1  0  0  1  1  0 

ve e  e  e  e  vm m  m  m  m  m  m  m  m  m  m  
0  0  1  0  1  1  1  0  0  0  1  0  0  1  1  0 

-0,015625

ganzzahliger Teil:
Nachkommateil:
0.01562500 | 0
0.03125000 | 0
0.06250000 | 0
0.12500000 | 0
0.25000000 | 0
0.50000000 | 1
Gesamt: 1 ,000001
Mantisse wäre: 1000000000
Exponent wäre: -5
Exponent umwandeln:
         5 | 1
         2 | 0
         1 | 1
Exponent unbeschränkt positiv: 101
Exponent mit führenden Nullen: 0101
Zweierkomplement:
   Einerkomplement:            1010
                                  1
   Zweierkomplement:           1011
Exponent: 1011, Vorzeichen: 1

vm m  m  m  m  m  m  m  m  m  m  ve e  e  e  e  
1  1  0  0  0  0  0  0  0  0  0  1  1  0  1  1 

vm ve e  e  e  e  m  m  m  m  m  m  m  m  m  m  
1  1  1  0  1  1  1  0  0  0  0  0  0  0  0  0 

ve e  e  e  e  vm m  m  m  m  m  m  m  m  m  m  
1  1  0  1  1  1  1  0  0  0  0  0  0  0  0  0 

12739

ganzzahliger Teil:
     12739 | 1
      6369 | 1
      3184 | 0
      1592 | 0
       796 | 0
       398 | 0
       199 | 1
        99 | 1
        49 | 1
        24 | 0
        12 | 0
         6 | 0
         3 | 1
         1 | 1
Nachkommateil:
Gesamt: 0 11000111000011,
Mantisse wäre: 1100011100
Exponent wäre: 14
Exponent umwandeln:
        14 | 0
         7 | 1
         3 | 1
         1 | 1
Exponent unbeschränkt positiv: 1110
Exponent: 1110, Vorzeichen: 0

vm m  m  m  m  m  m  m  m  m  m  ve e  e  e  e  
0  1  1  0  0  0  1  1  1  0  0  0  1  1  1  0 

vm ve e  e  e  e  m  m  m  m  m  m  m  m  m  m  
0  0  1  1  1  0  1  1  0  0  0  1  1  1  0  0 

ve e  e  e  e  vm m  m  m  m  m  m  m  m  m  m  
0  1  1  1  0  0  1  1  0  0  0  1  1  1  0  0 

Zurückrechnen

Gegeben sind die Zahlen im 2. Format, m = 9 und e = 3:
0 0 1 0 1 1 1 1 1 1 0 0 0 0
Beide Vorzeichen positiv
Mantisse: 111110000₂
positiver Exponent: 101₂ = 5₁₀
Zahl in normierter Gleitkommadarstellung: 0,11111₂ * 2⁵ = 11111₂
Ergebnis: 31

1 0 1 1 1 1 1 0 0 1 0 1 0 1
Vorzeichen der Mantisse negativ, daher ist die Zahl negativ
Mantisse: 110010101₂
positiver Exponent: 111₂ = 7₁₀
Zahl in normierter Gleitkommadarstellung: -0,110010101₂ * 2⁷ = 1100101,01₂
Ergebnis: -101,25

1 1 1 1 0 1 0 0 1 1 0 1 0 1
beide Vorzeichen negativ, daher ist die Zahl negativ und der Exponent negativ
negative Mantisse: -100110101₂
negativer Exponent, daher Zweierkomplement des Exponenten: 010₂ = -2₁₀
Zahl in normierter Gleitkommadarstellung: -0,100110101₂ * 2^-2 = 0,00100110101₂
Ergebnis: -0.15087890625
(Vergleichen Sie das mit dem Ergebnis des Beispiels ganz oben!)

Zahlenbereich

Die Formel aus der Schulübung:

Labels: POS1-1

Implementieren Sie die Klassen aus dem Buch Kapitel 7.
Machen Sie die Übung 7.10 (Seite 87).
Zeichnen Sie zu Übung 7.10 das passende UML-Klassendiagramm.

Sehen Sie sich auch die folgenden Einträge an:

• Vererbung
  
• Objektorientiertes Programmieren
  

Labels: Java, POS1-2

Da bei normalen "Remote-Objekten" immer ganze Objekte übertragen werden, hat man echtes Call-By-Value. Man arbeitet also mit Kopien von Objekten. Das gilt sowohl für Objekte, die an eine Methode eines Remote-Objekts übergeben werden als auch für Objekte als Returnwerte.
Normalerweise werden innerhalb einer JVM Objekte immer als Referenz übergeben bzw. zurückgegeben. Über RMI werden die Objekte immer serialisiert und komplett übertragen.
Das wirkt sich bei unserem "Data-Beispiel" so aus, dass Updates erst "sichtbar" werden, wenn die Daten auch wieder von der Datei geladen werden. Sollte das Locking direkt in der Record-Implementierung erfolgen, so muss man bedenken, dass auch immer ein Record-Objekt übertragen wird und der Client mit einer Kopie arbeitet. Damit bekommt er immer den Lock!
Abhilfe?
Man darf dem Client nur Referenzen zur Verfügung stellen. Nur der Server arbeitet mit den "echten" Objekten. - Klar, und wie geht das?
Das herauszufinden war nicht einfach, die Java-Dokumentation von Sun (Oracle) schweigt sch diesbezüglich aus, zumindest was direkte Lösungsvorschläge und Beispielcode angeht.

Grundsätzliche Erklärung und Beispiele zur Funktionsweise von RMI hilft etwas: jGuru: Remote Method Invocation (RMI) aber die letzte zündende Idee bekommt man durch How to return object and return object reference in Java RMI

Der Unterschied liegt in der Klassendefinition. Wenn die Klasse eine Unterklasse von UnicastRemoteObject ist, so ist sie damit RMI-fähig (kann RMI-Service anbieten). In diesem Fall wird also eine Referenz zurückgegeben werden. Wenn die Klasse nur Serializable implementiert, so ist die Klasse nicht für RMI-Aufrufe geeignet (kein RMI-Service) und es wird das Objekt zurückgegeben werden.

Ein Beispiel wird in Kürze geliefert.

Labels: Java, PR5

Remote Method Invocation funktioniert nur für Objekte, welche serialisiert werden können (die also das Interface Serializable implementieren). Wird innerhalb eines Objekts, welches über RMI gebunden werden soll, eine Referenz auf ein nicht serialisierbares Objekt benötigt, so bekommt man immer eine Exception der Art (z.B. für RandomAccessFile):

sun.rmi.registry.RegistryImpl_Stub.rebind(Unknown Source)
java.rmi.Naming.rebind(Naming.java:177)
rmi.Server.run(Server.java:43)
rmi.Server.main(Server.java:68)
error marshalling arguments; nested exception is: 
 java.io.NotSerializableException: java.io.RandomAccessFile

RandomAccessFile ist nicht serialisierbar, weil der innere Zustand so eines Objekts von der Laufzeitumgebung (Betriebssystem, Dateisystem, etc.) abhängt. Eine Referenz auf ein RandomAccessFile-Objekt muss als transient deklariert werden. Wenn nötig, dann muss der Zustand selbst gespeichert bzw. wiederhergestellt werden, z.B. in Form des Dateinamens und der Position innerhalb der Datei.
Dazu kann man die Methoden des Interfaces Serializable implementieren:

private void writeObject(java.io.ObjectOutputStream out)
    throws IOException
private void readObject(java.io.ObjectInputStream in)
    throws IOException, ClassNotFoundException;
private void readObjectNoData() 
    throws ObjectStreamException;

Für die Zwecke der Data-Klasse genügen die ersten beiden Methoden. Folgender Ausschnitt aus der Data-Klasse soll dies verdeutlichen:

public class Data implements DB, Header, Serializable {

    private static final long serialVersionUID = -8958941842720498616L;
    private transient RandomAccessFile database;
    private String filename;
    private transient Logger log = Logger.getLogger(LOGURL);
    private DBHeader header;
    private TreeMap data;
    private int lastDeleted = -1; // zuletzt gelöschter Datensatz

    private void writeObject(ObjectOutputStream stream) throws IOException {
        stream.defaultWriteObject();
        stream.writeLong(database.getFilePointer());
    }

    private void readObject(ObjectInputStream stream) throws IOException {
        try {
            stream.defaultReadObject();
        } catch (ClassNotFoundException e) {
            String msg = "Unable to find class";
            if (e.getMessage() != null)
                msg += ": " + e.getMessage();
            throw new IOException(msg);
        }
        database = new RandomAccessFile(filename, "rw");
        database.seek(stream.readLong());
        log = Logger.getLogger(LOGURL);
    }

//... weiterer Code entfernt
}

Hier ist auch der Logger transient, da auch der Logger vom Dateisystem abhängt und nicht serialisiert werden kann.

Labels: Java, PR5

Verwenden Sie unbedingt das Package data für die Klassen und Interfaces DB, Data, Header und Record. Nur so kann der Datenteil automatisch getestet werden.

Labels: Aufgabe, Java, PR5

Um einfacher automatisch testen zu können, soll das Interface Record (anstatt einer Klasse Record) bei der Datenklasse Data verwendet werden.

package data;

/**
 * RuD-Übung 2011
 *
 * data.Record.java
 * @author (c) 2011, Harald R. Haberstroh
 * 1.3.2011
 */

import java.rmi.Remote;
import java.rmi.RemoteException;

/**
 * @author Harald R. Haberstroh (hh)
 * 
 */
public interface Record extends Remote {
    /**
     * @return Anzahl der Felder dieses Datensatzes z.B. 8
     */
    public int getCntFields() throws RemoteException;

    /**
     * @return liefert alle Felder verkettet in einen String mit ';' getrennt
     *         z.B.
     *         "12;49.82012,17.260019;47.81497,16.260409;523;201102131510;67;2345121269;O"
     *         Strings sind unter Hochkomma zu setzen. z.B.
     *         "\"wlr1\";\"Werk Laderoboter 1\";\"   50\";\"   50\""
     */
    public String getCsvString() throws RemoteException;

    /**
     * Setzt die Felder auf die gegebenen Strings. Gegebenenfalls sind die
     * Strings abzuschneiden. Die Anzahl der Strings stimmt beim Aufruf von
     * setFields() auf alle Fälle mit getCntFields() überein (Prüfung braucht
     * nicht zu erfolgen).
     * 
     * @param fields
     *            Array mit den Feldwerten.
     * @throws RemoteException
     */
    public void setFields(String[] fields) throws RemoteException;
}

Damit kann per JUnit-Test ganz einfach der Inhalt eines Datensatzes und die Anzahl der Felder geprüft werden.
Überdies wird hier Refactoring geübt, da das Programm (die Klassen) entsprechend angepasst werden müssen (Ihre Record-Klasse muss umbenannt werden und eben das gegebene Interface implementieren).

Labels: Aufgabe, Java, PR5

Heuer sind wir mit 3 Teams zu diesem Bewerb gefahren und haben bei einem Bewerb sogar den dritten Platz erreicht. Hier ein paar Eindrücke:

Die ersten Bilder zeigen das Zimmer, die Vorbesprechung am Abend des Anreisetags und ein paar Bilder von Wels. Dann gibt es jede Menge Eindrücke vom Bewerb.
Weitere Informationen gibt es unter robocupjunior.at und www.robo4you.at (diese Seite ist noch im Entstehen).

Labels: RoboCup, Robotik

Schreiben Sie eine Java-Klasse Grw.java, welches aus dem Datenbestand ski.csv die beigelegte Statistik erzeugt.



Lesen Sie die csv -Datei zeilenweise und erstellen Sie aus jeder Zeile ein Objekt einer Klasse SkiDaten, die alle notwendigen Attribute (Klasse, Name, Geb.Datum,....) enthält.
Nennen Sie das Projekt grwski (also insgesamt z.B. 2ad-haberstroh-grwski).
Sollte eine neue Sortierung des Sätze notwendig sein, bitte mit OpenOffice Calc oder Excel sortieren. 1-er Kandidaten sortieren bitte mit eigenem Sortprogramm.
INFO: es handelt sich um einen zweistufigen Gruppenwechsel mit den Gruppen

KLASSE und GESCHL

und einer Gesamtdarstellung des Durchschnitts!
Eine Einführung in den Gruppenwechsel finden Sie in der Datei gruppenwechsel.pdf
Aufruf des Programms:

java Grw [-h | -o ausgabedat] [-d] eingabedatei

Die Option -d bewirkt die Ausgabe der Detailzeilen, ohne -d nur Summenzeilen ausgeben!
Beispiel Statistik:

------------------------------------------------------------------
STATISTIK zum Schuelerrennen der HTL am SKIKURS 2006 in OBERTAUERN
------------------------------------------------------------------

AMINGER                   Georg                            0.02
ELIAS                     Thomas                           0.97
GALAVICS                  Marcus                           0.15
GALLAUNER                 Alexander                        0.26
HECHER                    Markus                           0.58
HERMANN                   Gregor                           0.65
KAMPER                    Raphael                          0.55
KRIVOKUCA                 Milan                            7.73
MOSER                     Christoph                        2.34
NEPOLA                    René                             0.14
PRIELER                   Stefan                           0.63
RECHBERGER                Christian                        3.11
RIEGLER                   Mario                            0.87
SCHNEEBERGER              Joerg                            1.22
SENN                      Bernhard                         0.65
WIESSNER                  Maximilian                       1.61
ZENZ                      Markus                           2.04

die durchschnittliche Zeitdifferenz bei den MAENNERN betraegt:  1.38

die KLASSE 2AHDV   erreichte eine Durchschnittsdifferenz von  1.38 Sekunden


CMUND                     Katharina                        2.81
HARATHER                  Alice                            1.87
KONLECHNER                Viktoria                         0.39
RIEGER                    Jennifer                         0.63
RINNHOFER                 Elisabeth                        1.65
...........................................................

...........................................................
REICHHART                 Thomas                           0.30
RIEDER                    Dominik                          1.07
SCHERMANN                 Georg                            0.85
STANGL                    Stefan                           1.48
STAUFER                   Andreas                          0.47

die durchschnittliche Zeitdifferenz bei den MAENNERN betraegt:  2.38

die KLASSE 3CHDV   erreichte eine Durchschnittsdifferenz von  2.36 Sekunden
************************************************GESAMT-Differenz :  1.93

Achtung: Die obige Ausgabe stellt nur einen Ausschnitt dar (Aufruf mit Option -d) und es wurde die vorletzte Zeile (Hüpfner) gelöscht, da dort extrem abweichende Zeiten vorkommen (die Schülerin ist scheinbar gestürzt). Die Gesamt-Different würde mit dieser Zeile 11,37 Sekunden betragen.

Binäres Dateiformat für Eingabe

Erstellen Sie ein neues Programm so, dass sie statt der CSV-Eingabedatei auch eine Datei im binären Datenformat verwenden können. Die Daten sind wie folgt gespeichert (C-Datentypen):

typedef struct umsatz {
    char artikel[25];
    char verkaeufer[25];
    int  vkpreis;
    int  monat; 
} umsatz_t;

Dabei ist char artikel[25] ein maximal 24-Zeichen langer String, bei dem jedes Zeichen (ASCII) als ein Byte gespeichert wird. Das Ende des Strings wird durch das Zeichen '\0' abgeschlossen (das hat tatsächlich den Wert 0). D.h. es müssen bis zu 25 Bytes gelesen werden, wobei nur die Zeichen bis exklusive '\0' (direkt) in Java-chars umgewandelt werden können (verwenden Sie z.B. RandomAccessFile.read(byte[] buf)).
int entspricht einem 32-Bit-Integer und passt zum Java-Typ int.
Die passende Datei mit Testdaten finden Sie hier: daten.dat.

Den Inhalt dieser Datei kann man nur mit einem Programm öffnen, das die Daten binär lesen kann und sinnvoll, z.B. im Hexadezimalsystem, anzeigen kann. khexedit oder das Konsolenprogramm hexdump eignen sich dafür.

Die Ausgabe von hexdump könnte so aussehen (gekürzt):

hp@L211 $ hexdump -C daten.dat 
00000000  50 72 6f 64 30 31 00 01  4c 00 ba 01 e5 e2 e6 b7  |Prod01..L.......|
00000010  00 00 00 00 e4 98 04 08  28 4d 61 69 65 72 00 08  |........(Maier..|
00000020  a0 fc f5 b7 dc e9 b9 bf  48 e9 b9 bf f1 86 04 08  |........H.......|
00000030  90 8b f8 b7 dc 00 00 00  01 00 00 00 50 72 6f 64  |............Prod|
00000040  30 32 00 01 4c 00 ba 01  e5 e2 e6 b7 00 00 00 00  |02..L...........|
00000050  e4 98 04 08 28 4d 61 69  65 72 00 08 a0 fc f5 b7  |....(Maier......|
00000060  dc e9 b9 bf 48 e9 b9 bf  f1 86 04 08 90 8b f8 b7  |....H...........|
00000070  90 01 00 00 02 00 00 00  50 72 6f 64 30 33 00 01  |........Prod03..|
00000080  4c 00 ba 01 e5 e2 e6 b7  00 00 00 00 e4 98 04 08  |L...............|
00000090  28 48 75 62 65 72 00 08  a0 fc f5 b7 dc e9 b9 bf  |(Huber..........|

Es soll wieder ein 2-stufiger Gruppenwechsel programmiert werden (Artikel und Verkäufer).
Zum Vergleich können Sie die Daten auch im CSV-Format verwenden: daten.csv.

Versuchen Sie, die beiden Varianten, jene mit den Ski-Daten und jene mit den (binären) Umsatzdaten, so zu gestalten, dass nur geringe Teile unterschiedlich sind (am Besten austauschbare Klassen mit gleichem Namen für die Daten und für die Formatierung). Der Hauptalgorithmus bleibt ja gleich.

Labels: Aufgabe, Java, POS1-2

Erstellen Sie für den Client unserer RMI-Client/Server-Anwendung eine grafische Oberfläche, welche den Inhalt der Datenbank (evtl als Ausschnitt) in einer JTable darstellt. Es soll möglich sein, einzelne Werte zu ändern, Zeilen zu löschen, neue Zeilen einzufügen und zu Suchen (eigener Dialog). Bei der Suche sind nur die gefundenen Datensätze anzuzeigen.
Das GUI könnte (minimal, die Funktionen zum Löschen, Einfügen und Suchen sind in "Edit" versteckt) etwa so aussehen:

Labels: Aufgabe, Java, PR5

Jede Laufzeitumgebung eines Programms muss beim Aufruf von Funktionen oder Methoden folgende Informationen verwalten:

• Parameter
• Rücksprungadresse (wohin kehrt Funktion zurück?)
• lokale Variable
• Objektreferenz (this- oder self-Referenz zum Objekt zu dem die Methode gehört)

public class Bar {
    private Foo[] bars = new Foo[2];
    private int n = 0;
    public static void main(String[] args) {
        Bar o = new Bar();
        for (int i = 0; i < 6; i++) {
            Foo m = new Foo("" + i);
            o.add(m);
        }
    }
    public void add(Foo m) {
        bars[n] = m;
        n++;
        if (n == bars.length) {
            for (int i = 0; i < bars.length; i++) {
                System.out.println(bars[i].getName());
            }
        }
    }
}

public class Foo {
    private String name;
    public Foo() {
        this("no name");
    }
    public Foo(String name) {
        this.name = name;
    }
    public String getName() {
        return "Foo [name=" + name + "]";
    }
}

Die Aufgabenstellung wäre: zeichnen Sie den Aufrufstack und den Heap, wenn das Programm die Zeile 10 in der Klasse Foo erreicht. Das Programm soll dabei mit folgendem Aufruf gestartet worden sein: java Bar test
Bei der folgenden Darstellung werden Strings wie primitive Werte dargestellt, also direkt bei der Variable. Richtigerweise sind Strings aber Objekte.
Die Darstellung zeigt den Speicher schematisch für die Zeilen Bar:8, Bar:14 und die gesuchte Zeile Foo:10.

Auf das Bild Klicken für weiteres Bild...

Labels: allgemeines, POS1-2