The ModulaTor logo 7KB

The ModulaTor

Oberon-2 and Modula-2 Technical Publication

Ubaye's First Independent Modula-2 & Oberon-2 Journal! Nr. 3, Apr-1995


Find the minimal spanning tree (forest) in Oberon-2

by Günter Dotzel, ModulaWare

A description of the problem and a reference can be found in the module SpanMinTree. An example program run is included.


________________________________________________________________
MODULE SpanGraph;
(*
  Defines the graph data structures for the 
  minimal spanning tree (forest) algorithm.

  written by Helmut Sperber, Sep-1982.

  AS/Jan-1995 (Oberon-2 version)
  http://www.ModulaWare.com/
*)
  IMPORT CTR, STextIO, SWholeIO, SIOResult;

  CONST 
    MaxNodes *  = 100;
    NodeDigits * = 2; (* log10 (MaxNodes) *)

  TYPE
    INTEGER * = CTR.INTEGER;
    Node * = INTEGER; (* [0..MaxNodes-1] *)
    distancetype = ARRAY MaxNodes, MaxNodes OF CTR.CARDINAL;
    DistanceMatrix * = RECORD
      Length * : Node;
      Distance * : distancetype;
    END;

    predecessortype = ARRAY MaxNodes OF Node;
    Forest * = RECORD
      Length * : Node;
      Predecessor * : predecessortype;
    END;

PROCEDURE ReadInt * (VAR i: LONGINT; VAR isnumber: BOOLEAN);
BEGIN
  (* GD/21-Oct-1993: the text read procedures of the 
                 ISO M2 Std I/O-Lib
     doesn't follow the principle of least astonnishment, but
     allow to write portable programs in that the line end
     char is no char at all, but merely a status. You need
     to read the ISO M2 I/O Lib spec.
     Once you've studied it, you like it - probably. 
  *)
  SWholeIO.ReadInt(i);

  IF SIOResult.ReadResult() = SIOResult.endOfLine THEN 
    STextIO.SkipLine; (* in case of previous number was terminated 
                   with <RET> we've to skip the endOfLine first. *)
    SWholeIO.ReadInt(i);
  END;
  isnumber := SIOResult.ReadResult() = SIOResult.allRight;
END ReadInt;

END SpanGraph.
________________________________________________________________
MODULE SpanIOGraph;
(*
  written by Helmut Sperber, Erlangen, Sep-1982.
  AS/Jan-1995 (Oberon-2 version)
  http://www.ModulaWare.com/
*)

  IMPORT SG:=SpanGraph, SWholeIO, STextIO, SIOResult, CTR;

  TYPE INTEGER = SG.INTEGER;

  PROCEDURE MultipleChar (N: INTEGER;  C: CHAR);
  VAR k: INTEGER; 
  BEGIN FOR k := 1 TO N DO STextIO.WriteChar (C); END;
  END MultipleChar;

  PROCEDURE ReadTriangle * (VAR Result: SG.DistanceMatrix) : BOOLEAN;
  VAR d: INTEGER ;
    k, m: SG.Node;
    IsNumber: BOOLEAN;
  BEGIN
    (* The field Result.Length must already contain the number of nodes *)
    Result.Distance [0, 0] := 0;
    FOR k := 1 TO Result.Length-1 DO
      Result.Distance [k, k] := 0;
      STextIO.WriteLn;
      FOR m := 0 TO k-1 DO
        SG.ReadInt (d,IsNumber); 
        IF IsNumber & (d >= 0) THEN 
          (* if (d = 0) then no connection between node k and node m *)
          Result.Distance [k, m] := d;
          (* symetric matrix: *)
          Result.Distance [m, k] := d
        ELSE RETURN FALSE
        END;
      END;
    END;
    RETURN TRUE;
  END ReadTriangle;

  PROCEDURE WriteTriangle * (VAR Mat: SG.DistanceMatrix; Dig: CTR.CARDINAL);
  CONST Vertical = '|'; Horicontal = '_';
  VAR k, m: SG.Node;
  BEGIN
    STextIO.WriteLn; 
    (* assume Mat.Length > 0 *)
    MultipleChar (SG.NodeDigits, ' ');
    STextIO.WriteChar (Vertical);
    FOR k := 0 TO Mat.Length-1 DO SWholeIO.WriteCard (k, Dig+1); 
    END;
    STextIO.WriteLn;
    MultipleChar (SG.NodeDigits + 1 + Mat.Length*(Dig + 1), Horicontal);
    STextIO.WriteLn;
    FOR k := 0 TO Mat.Length-1 DO
      SWholeIO.WriteCard (k, SG.NodeDigits); STextIO.WriteChar (Vertical);
      IF k > 0 THEN
        FOR m := 0 TO k-1 DO SWholeIO.WriteCard (Mat.Distance [k, m], Dig+1);
        END;
      END;
      STextIO.WriteLn;
    END;
    STextIO.WriteLn;
  END WriteTriangle;

  PROCEDURE WriteForest * (VAR For: SG.Forest);
  VAR k: SG.Node;
  BEGIN
    STextIO.WriteLn;
    (* assume For.Length > 0 *)
    FOR k := 0 TO For.Length-1 DO
      STextIO.WriteString ("Node ="); 
      SWholeIO.WriteCard (k, SG.NodeDigits);
      STextIO.WriteString (", Predecessor =");
      SWholeIO.WriteCard (For.Predecessor [k], SG.NodeDigits + 1);
      STextIO.WriteLn;
    END;
    STextIO.WriteLn;
  END WriteForest;

  PROCEDURE PictureForest * (VAR For: SG.Forest);
  CONST Space = 2;
  VAR upper: SG.Node;
    k: SG.Node;

    PROCEDURE PictureTree (
      Root: SG.Node; 
      Indent: CTR.CARDINAL; 
      NewLine: BOOLEAN);
    VAR firstline: BOOLEAN;
      n: SG.Node;
    BEGIN
      IF NewLine THEN
        STextIO.WriteLn;
        MultipleChar (Indent * (SG.NodeDigits + Space)-1, ' ');
        IF Indent # 0 THEN STextIO.WriteChar ('\'); END;
      END;
      MultipleChar (Space, '_');
      SWholeIO.WriteCard (Root, SG.NodeDigits); 
      n := 0;
      firstline := TRUE;
      WHILE n <= upper DO
        IF ( For.Predecessor [n] = Root) & (n # Root) THEN
          PictureTree (n, Indent + 1, ~ firstline);
          firstline := FALSE;
        END;
        INC (n);
      END;
    END PictureTree;

  BEGIN (* PictureForest *)
  (* assume For.Length > 0 *)
    upper := For.Length-1;
    FOR k := 0 TO upper DO
      IF For.Predecessor [k] = k THEN (* root found *)
        PictureTree (k, 0, TRUE);
      END;
    END;
    STextIO.WriteLn;
  END PictureForest;

END SpanIOGraph.
________________________________________________________________
MODULE SpanMinTree;
(* 
Main program: find minimal spanning trees in a forest. 

Reference: Reingold, Edward M: Combinatorial algorithms, by Nievergelt, Jürg
and Deo, Narsingh. Prentice-Hall, Inc., Englewood Cliffs, New 
Jersey 07632 (USA), 1977. 

"A connected, undirected acyclic graph is called a tree, and a set of trees is 
called a forest. Trees and forests are graphs of a very special kind that play an 
important role in many applications. 

An undirected graph G is a tree if and only if there is exactly one path between 
every pair of vertices in G. Since n-1 edges are the fewest possible to connect n 
vertices and a tree with n vertices contains exactly n-1 edges, trees can be 
thought of as graphs that are minimally connected. Removing any edge from a 
tree renders it disconnected by destroying the only path between at least one 
pair of vertices. 

Of particular interest are spanning trees of a graph G, trees that are subgraphs 
of G and contain every vertex of G. If G is not connected, a set consisting of a 
spanning tree for each component is called a spanning forest of G. 

In a weighted graph G = (V,E) it is often of interest to determine a spanning tree 
(forest) of minimum total edge weight - that is, such that the sum of the weights 
of all edges is minimum. Such a tree is called a minimum spanning tree." 

 written by Helmut Sperber, Sep-1982.
 AS/Jan-1995 (Oberon-2 version)
 http://www.ModulaWare.com/
*)

IMPORT SG:=SpanGraph, SIOG:=SpanIOGraph, STextIO, SWholeIO, CTR,
 SYSTEM;
CONST Successful = TRUE;

VAR g: SG.DistanceMatrix;
  f: SG.Forest;
  kappa: CTR.CARDINAL;
  k: SG.INTEGER;
  okey : BOOLEAN;
  NextCH: CHAR;

  PROCEDURE MinSpanForest ( 
    VAR Dist: SG.DistanceMatrix;
    VAR Result: SG.Forest;
    VAR Kappa: CTR.CARDINAL);

  VAR len, m0, k0, newnode, upper: SG.Node;
    d, min: CTR.CARDINAL;
    nodes: ARRAY SG.MaxNodes OF SG.Node;
    connected: BOOLEAN;
    m, k, intermediate: SG.Node;

  BEGIN  (* assume Dist.Length > 0 *)
    Result.Length := Dist.Length;
    upper := Dist.Length - 1;

    FOR m := 0 TO upper DO nodes [m] := m END;

    len := 1;
    Result.Predecessor [0] := 0;
    Kappa := 1;
    WHILE len <= upper DO
      connected := FALSE;

      FOR m := 0 TO len-1 DO
        FOR k := len TO upper DO
          d := Dist.Distance [ nodes [m], nodes [k] ];
          IF d # 0 THEN
            IF ~ connected OR (d < min) THEN 
              min := d;
              m0 := m;
              k0 := k;
            END;
            connected := TRUE;
          END;
        END;
      END;

      IF connected THEN
        newnode := nodes [k0];
        intermediate:= nodes [m0];
        Result.Predecessor [newnode] := intermediate;
        IF k0 > len THEN  (* exchange nodes: *)
          nodes [k0] := nodes [len];
          nodes [len] := newnode;
        END;
      ELSE INC (Kappa);
        newnode := nodes [len];
        Result.Predecessor [newnode] := newnode;
      END;
    
      INC (len);
    END (* WHILE *)
  END MinSpanForest;

  PROCEDURE Weight (VAR Dist: SG.DistanceMatrix; VAR For: SG.Forest) :CTR.CARDINAL;
  VAR m,k: SG.Node;
    sum: CTR.CARDINAL;
  BEGIN
    sum := 0;
    (* assume Length > 0 *)
    FOR k := 0 TO For.Length-1 DO
      INC ( sum, Dist.Distance [k, For.Predecessor [k] ] );
    END;
    RETURN sum;
  END Weight;

  PROCEDURE P(out: ARRAY OF CHAR);
  BEGIN
    STextIO.WriteLn; STextIO.WriteString (out);
  END P;

BEGIN
  P(" Start of SpanMinTree (Forest).");
  P(" Type sequence of Integers, terminated by RET.");
  STextIO.WriteLn;
  SG.ReadInt(k, okey); 
  STextIO.WriteLn;
  IF okey & (k > 0 ) THEN
    g.Length := k;
    IF SIOG.ReadTriangle (g) = Successful THEN
      P (" Input Distance Matrix:");
      SIOG.WriteTriangle (g, 4);
      MinSpanForest (g, f, kappa);
      P (" Minimal Spanning Forest:");
      SIOG.WriteForest (f);
      P (" Tree(s) in Forest:");
      SIOG.PictureForest (f);
      STextIO.WriteString (" Edge Weight ="); 
      SWholeIO.WriteCard (Weight (g, f), 1);
      P ('Components =');
      SWholeIO.WriteCard (kappa, SG.NodeDigits); 
    ELSE STextIO.WriteString ('Distance Triangle not correct.');
    END;
  ELSE STextIO.WriteString ('Length not correct.');
  END;

  P (" --- End of SpanMinTree (Forest)"); STextIO.WriteLn;
END SpanMinTree.
________________________________________________________________

 Start of SpanMinTree (Forest)
11

481, 
462, 76, 
533, 175, 228, 
292, 464, 434, 504, 
275, 302, 283, 366, 164, 
453, 28, 48, 199, 436, 274, 
638, 248, 296, 81, 579, 441, 264, 
586, 582, 629, 405, 776, 638, 598, 347, 
426, 408, 455, 238, 602, 464, 410, 240, 174, 
614, 377, 424, 212, 708, 570, 393, 141, 219, 188, 
 Input Distance Matrix:
  |    0    1    2    3    4    5    6    7    8    9   10
__________________________________________________________
 0|
 1|  481
 2|  462   76
 3|  533  175  228
 4|  292  464  434  504
 5|  275  302  283  366  164
 6|  453   28   48  199  436  274
 7|  638  248  296   81  579  441  264
 8|  586  582  629  405  776  638  598  347
 9|  426  408  455  238  602  464  410  240  174
10|  614  377  424  212  708  570  393  141  219  188

 Minimal Spanning Forest:
Node = 0, Predecessor =  0
Node = 1, Predecessor =  6
Node = 2, Predecessor =  6
Node = 3, Predecessor =  1
Node = 4, Predecessor =  5
Node = 5, Predecessor =  0
Node = 6, Predecessor =  5
Node = 7, Predecessor =  3
Node = 8, Predecessor =  9
Node = 9, Predecessor = 10
Node =10, Predecessor =  7

 Tree(s) in Forest:
__ 0__ 5__ 4
       \__ 6__ 1__ 3__ 7__10__ 9__ 8
           \__ 2
 Edge Weight =1548
Components = 1
 --- End of SpanMinTree (Forest)

The ModulaTor Forum

A comparison of code generated on RISC/CISC

by Günter Dotzel, http://www.ModulaWare.com/

Two disassembly outputs are shown for a simple algorithm, one for the DEC Alpha AXP (run-time index checks and instruction scheduler turned off) using ModulaWare's new Oberon-2 compiler A2O V1.31. The second listing is for the Motorola 68040 as published in JMLC'94 proceedings, p120. (The Oberon program source was taken from p119.)

Both Oberon-2 compilers are based on OP2 (ETH Zuerich's portable Oberon-2 compiler front-end, designed by Regis Crelier).

To compare the code quality of AXP (RISC) and M680x0 (CISC), the Motorola machine code listing printed on the left-hand side shall be used. Also, the CISC code uses some complicated instructions, which need multiple processor cycles. On the other hand, the AXP code shown is not scheduled to make it more readable. Instruction scheduling means that independent instructions are rearranged within the same basic instruction block in order to take advantage of executing multiple instructions within the same processor cycle.

The code listed on the right-hand side of the 680x0 listing uses Michael Franz's simple code optimization technique as presented in his article in the above mentioned proceeding. It would be relatively easy, to incorporate these techniques into the AXP compiler, but unfortunately, this optimization pass is, according to the author, currently not available.

The procedure entry and exit code as well as the module body was omitted in both cases.


    1  MODULE Bubble;
    2  CONST N=100;
    3  VAR top: LONGINT;
    4     sort: ARRAY N+1 OF LONGINT;
    5  
    6  PROCEDURE Bubble;
    7  VAR i,j: LONGINT;
    8  BEGIN top:=N;
    9    WHILE top>1 DO i:=1;
   10      WHILE i<top DO
   11        IF sort[i]>sort[i+1] THEN
   12          j:=sort[i]; sort[i]:=sort[i+1];sort[i+1]:=j
   13        END;
   14        INC(i);
   15      END;
   16      DEC(top);
   17    END;
   18  END Bubble; 
   19  
   20  BEGIN
   21   Bubble;
   22  END Bubble.

AXP/VMS Oberon-2 A2O V1.31a(C) by ModulaWare - Machine Code:

 Instruction PC            Mnemonic Operands                       Line

 ____________________________________________________________________

 21FBFFA0 00030            LDA      RL,0000FFA0H(PDR)
 A5CF0000 00034            LDQ      RD,00000000H(RL)
 23DEFFF0 00038            LDA      SP,0000FFF0H(SP)               ;8
 239F0064 0003C            MOV      00000064H,R28
 B78E0030 00040            STQ      R28,00000030H(RD) (* top *) 
 47FF041F 00044            NOP                                     ;9
 217F0001 00048    4$:     MOV      00000001H,R11
 A14E0030 0004C            LDL      R10,00000030H(RD) (* top *) 
 416A09BB 00050            CMPLT    R11,R10,PDR
 E7600034 00054            BEQ      PDR,00000128H
 231F0001 00058            MOV      00000001H,R24
 B71DFFF8 0005C            STQ      R24,0000FFF8H(FP) (* i *) 
 A17DFFF8 00060    2$:     LDL      R11,0000FFF8H(FP) (* i *)      ;10
 A14E0030 00064            LDL      R10,00000030H(RD) (* top *) 
 416A09BB 00068            CMPLT    R11,R10,PDR
 E760002A 0006C            BEQ      PDR,00000118H
 A17DFFF8 00070            LDL      R11,0000FFF8H(FP) (* i *)      ;11
 4960572B 00074            SLL      R11,#00000002H,R11
 22EE0038 00078            LDA      R23,00000038H(RD)
 4177040B 0007C            ADDQ     R11,R23,R11
 A13DFFF8 00080            LDL      R9,0000FFF8H(FP) (* i *) 
 4120300A 00084            ADDL     R9,#00000001H,R10
 4940572A 00088            SLL      R10,#00000002H,R10
 22CE0038 0008C            LDA      R22,00000038H(RD)
 4156040A 00090            ADDQ     R10,R22,R10
 A12A0000 00094            LDL      R9,00000000H(R10) (* sort *) 
 A10B0000 00098            LDL      R8,00000000H(R11) (* sort *) 
 412809BB 0009C            CMPLT    R9,R8,PDR
 E7600019 000A0            BEQ      PDR,00000108H
 A17DFFF8 000A4            LDL      R11,0000FFF8H(FP) (* i *)      ;12
 4960572B 000A8            SLL      R11,#00000002H,R11
 238E0038 000AC            LDA      R28,00000038H(RD)
 417C040B 000B0            ADDQ     R11,R28,R11
 A30B0000 000B4            LDL      R24,00000000H(R11) (* sort *) 
 B71DFFF0 000B8            STQ      R24,0000FFF0H(FP) (* j *) 
 A17DFFF8 000BC            LDL      R11,0000FFF8H(FP) (* i *) 
 4960572B 000C0            SLL      R11,#00000002H,R11
 22EE0038 000C4            LDA      R23,00000038H(RD)
 4177040B 000C8            ADDQ     R11,R23,R11
 A13DFFF8 000CC            LDL      R9,0000FFF8H(FP) (* i *) 
 4120300A 000D0            ADDL     R9,#00000001H,R10
 4940572A 000D4            SLL      R10,#00000002H,R10
 22CE0038 000D8            LDA      R22,00000038H(RD)
 4156040A 000DC            ADDQ     R10,R22,R10
 A38A0000 000E0            LDL      R28,00000000H(R10) (* sort *) 
 B38B0000 000E4            STL      R28,00000000H(R11) (* sort *) 
 A15DFFF8 000E8            LDL      R10,0000FFF8H(FP) (* i *) 
 4140300B 000EC            ADDL     R10,#00000001H,R11
 4960572B 000F0            SLL      R11,#00000002H,R11
 230E0038 000F4            LDA      R24,00000038H(RD)
 4178040B 000F8            ADDQ     R11,R24,R11
 A2FDFFF0 000FC            LDL      R23,0000FFF0H(FP) (* j *) 
 B2EB0000 00100            STL      R23,00000000H(R11) (* sort *) 
 47FF041F 00104            NOP
 A15DFFF8 00108    1$:     LDL      R10,0000FFF8H(FP) (* i *)      ;14
 4140300B 0010C            ADDL     R10,#00000001H,R11
 B57DFFF8 00110            STQ      R11,0000FFF8H(FP) (* i *) 
 C3FFFFD2 00114            BR       00000060H
 A14E0030 00118    3$:     LDL      R10,00000030H(RD) (* top *)    ;16
 4140312B 0011C            SUBL     R10,#00000001H,R11
 B56E0030 00120            STQ      R11,00000030H(RD) (* top *) 
 C3FFFFC8 00124            BR       00000048H
 47BD041E 00128    5$:     MOV      FP,SP

Code generated for the 680x0

        Old Compiler                             New Compiler
     
        MOVE.L  #N, (top)                        MOVE.L  #N, (top)
L0      CMPI.L  #1, (top)                        CMPI.L  #1, (top)
        BLE     L5                               BLE     L5
        MOVE.L  #1, (-4, A6)                     MOVE.L  #1, (-4, A6)
L1      MOVE.L  (-4, A6), D7                     MOVE.L  (-4, A6), D7
        CMP.L   (top), D7                        CMP.L   (top), D7
        BGE     L4                               BGE     L4
L2      MOVE.L  (-4, A6), D7
        LEA     (sort), A4                       LEA     (sort), A4
        MOVE.L  (-4, A6), D6                     MOVE.L  D7, D6
        ADDQ.L  #1, D6                           ADDQ.L  #1, D6
        LEA     (sort), A3
        MOVE.L  (0, A4, D7.L*4), D5              MOVE.L  (0, A4, D7.L*4), D5
        CMP.L   (0, A4, D6.L*4), D5              CMP.L   (0, A4, D6.L*4), D5
        BLE     L3                               BLE     L3
        MOVE.L  (-4, A6), D7
        LEA     (sort), A4
        MOVE.L  (0, A4, D7.L*4), (-8, A6)        MOVE.L  D5, (-8, A6)
        MOVE.L  (-4, A6), D7
        ADDQ.L  #1, D7                           ADDQ.L  #1, D7
        LEA     (sort), A4
        MOVE.L  (-4, A6), D6                     MOVE.L  (-4, A6), D4
        LEA     (sort), A3
        MOVE.L  (0, A4, D7.L*4), (0, A3, D6.L*4) MOVE.L  (0, A4, D7.L*4), D4.L*4)
        MOVE.L  (-4, A6), D7
        ADDQ.L  #1, D7                           ADDQ.L  #1, D4
        LEA     (sort), A4
        MOVE.L  (-8, A6), (0, A4, D7.L*4)        MOVE.L  D5, (0, A4, D4.L*4)
L3      ADDQ.L  #1, (-4, A6)                     ADDQ.L  #1, (-4, A6)
        BRA     L1                               BRA     L1
L4      SUBQ.L  #1, (top)                        SUBQ.L  #1, (top)
        BRA     L0                               BRA     L0
L5

List of Technical Reports and Dissertations

by Taylor Hutt, email: thutt@clark.net

The two directories of concern at ETH-Zuerich's neptune ftp-server ftp.inf.ethz.ch are:


/doc/tech-reports      # contains some of the Yellow Books
/doc/diss              # contains some dissertations
Another directory which is worth checking out is

/pub/Oberon/Newsletter # contains ETHZ Oberon Newsletters edited by
                         Johannes Marais
Here is the index of tech-reports (read at your own risk; some are quite boring)

Title        : A New Method to Approximate the Volume Rendering Equation
               using Wavelet Bases and Piecewise Polynomials.
Authors      : M. Gross, L. Lippert, A. Dreger, R. Koch.
Organisation : Department of Computer Science, ETH Zurich.
Date         : September 1994.
Document     : 220.

Title : Exploiting Multidatabase Technology for CIM. Authors : Norrie, M.C., Schaad, W., Schek, H.-J., Wunderli, M. Organisation : Department of Computer Science, ETH Zurich. Date : July 1994. Document : 219.
Title : Unified Transaction Model for Semantically Rich Operatio ns. Authors : Vingralek, R., Ye, H., Breitbart, Y., Schek, H.-J. Organisation : Department of Computer Science, ETH Zurich. Date : July 1994. Document : 218.
Title : Fitting of Circles and Ellipses. Least Squares Solution. Authors : Walter Gander, Gene H. Golub, Rolf Strebel. Organisation : Department of Computer Science, ETH Zurich. Date : 1994. Document : 217.
Title : Communication Latency Hiding --- Model and Implementation in High-Latency Computer Networks. Author : Volker Strumpen. Organisation : Department of Computer Science, ETH Zurich. Date : 1994. Document : 216.
Title : Tools for Digital Circuit Design using FPGAs. Authors : H. Eberle, S. Gehring, S. Ludwig, N. Wirth. Organisation : Department of Computer Science, ETH Zurich. Date : 1994. Document : 215.
Title : SCIDDLE: A Tool for Large Scale Distributed Computing. Authors : Peter Arbenz, Christoph Sprenger, Hans Peter Luethi, Stefan Vogel. Organisation : Department of Computer Science, ETH Zurich. Date : March 1994. Document : 213.
Title : HP-Oberon(TM) The Oberon Implementation for Hewlett-Packard Apollo 9000 Series 700. Author : J. Supcik. Organisation : Department of Computer Science, ETH Zurich. Date : 1994. Document : 212.
Title : User's Guide to SCIDDLE Version 3.0. Author : Christoph Sprenger. Organisation : Department of Computer Science, ETH Zurich. Date : December 1993. Document : 208.
Title : The Homotopy Method Applied to Eigenvalue Problems. Author : M. Oettli. Organisation : Department of Computer Science, ETH Zurich. Date : 1993. Dokument : 205.
Title : An Extension-Board with an FPGA for Experimental Circuit Design CL - An Editor for the CLi6000 Field Programmable Gate Array and its Implementation CL-Editor User Manual. Authors : N. Wirth, S. Ludwig. Organisation : Department of Computer Science, ETH Zurich. Date : 1993. Dokument : 198.
Title : On the Linearization of Graphs and Writing Symbol Files. Oberon Technical Notes. Authors : R. Griesemer, C. Pfister (ed.), B. Heeb, J. Templ. Organisation : Department of Computer Science, ETH Zurich. Date : 1991. Document : 156.
Here is the index from diss: Title : Separate Compilation and Module Extension. Authors : Regis Crelier. Organisation : Institute for Computer Systems, ETH Zurich. Language : English. Pages : 168. Date : 1994. Document : th10650.
Title : Code Generation On the Fly: A Key for Portable Software. Authors : Michael Franz. Organisation : Institute for Computer Systems, ETH Zurich. Language : English. Pages : 97. Date : 1994. Document : th10497.
Title : A Programming Language for Vector Computers. Authors : Robert Griesemer. Organisation : Institute for Computer Systems, ETH Zurich. Language : English. Pages : 193. Date : August 1993. Document : th10277.

Recommended Reading

by Günter Dotzel

I'd like to present two related books, the first one written by someone who blew it shortly after he wrote his book and the second one written by someone who wrote his book after he ruined his fifteen-year career and lost over a million dollars.

The Education of a Speculator, by Victor Niederhofer, John Wiley & Sons, 1997.
From the book's preface: Join me in seeing how humdrum everyday experiences, combined with the wisdom of the immortals, can help you appreciate and maybe even learn the nitty-gritty of buying low and selling high.

What I learned losing a million dollars, by Jim Paul and Brendan Moynihan, 1994.
From the book's preface: This book is a case study of the classic tale of countless entrepreneurs: the risk taker who sees an opportunity, the idea that clicks, the intoxicating growth, the errors and the collapse. Our case is that of a trader, but as with all case studies and parables the lessons can be applied to a great many other situations. These lessons will help you whether you are in the markets or in the business. The two areas have more in common than one might suppose.


IMPRESSUM: The ModulaTor is an unrefereed journal. Technical papers are to be taken as working papers and personal rather than organizational statements. Items are printed at the discretion of the Editor based upon his judgement on the interest and relevancy to the readership. Letters, announcements, and other items of professional interest are selected on the same basis. Office of publication: The Editor of The ModulaTor is Guenter Dotzel; he can be reached by tel/fax: [removed due to abuse] or by mailto:[email deleted due to spam]


Home | Site_index | Legal | OpenVMS_compiler | Alpha_Oberon_System | ModulaTor | Bibliography | Oberon[-2]_links | Modula-2_links |

Amazon.com [3KB] [Any browser]

Books Music Video Enter keywords...


Amazon.com logo

Webdesign by www.otolo.com/webworx, 07-Dec-1998