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)
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
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 dissertationsAnother 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.
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 |
Contact |
Legal |
Buy_products |
OpenVMS_compiler |
Alpha_Oberon_System |
XDS_family |
DOS_compiler |
ModulaTor |
Bibliography |
Oberon[-2]_links |
Modula-2_links |
Onduleurs
![Amazon.com [3KB]](amzn/amazon3.gif)
![[Any browser]](starsbtn.gif){kind=small}