Was sind die n"achsten Schritte?

1) Vektoren und Matrizen

Wir haben im Augenblick die Klassen vector und matrix (von doubles) in LEDA. 
Ferner haben wir integer_vector und integer_matrix implementiert aber noch nicht integriert.

In Zukunft m"ochten wir vector<N> und matrix<N>, wobei N ein beliebiger Zahlentyp ist. Aus Gr"unden der Aufw"artskompatibilit"at bewegen wir das
augenblickliche vector.h und vector.c nach old_vector.h. und old_vector.c.
Analoges gilt f"ur matrix.h und matrix.c
Dann kann man diese weiterbenutzen und mu\3 nur das include "andern.

Implementierung von vector<N> und matrix<N>.

Die Implementierung ist analog zu array<E>, d.h. wir schaffen Klassen
gen_vector und gen_matrix. In diesen Klassen sind alle Funktionen, die 
auf Ns arbeiten virtuell, also +,-,* und so weiter. Die Implementierung
sollte man aus integer_vector und integer_matrix "ubernehmen k"onnen.

vector<N> und matrix<N> wird dann aus gen_vector und gen_array abgeleitet 
analog wie array<E> aus gen_array abgeleitet wird.

Damit h"atten wir dann vector<N> und matrix<N>. Diese Klassen arbeiten f"ur alle
Zahlentypen, haben aber zwei Nachteile.

Erstens bringen die virtuellen Funktionen einen betr"achtlichen Overhead, der hier viel gravierender zuschlagen sollte als bei den anderen LEDA-Typen. Beachte, da\3 wir etwa das + auf doubles "uber eine virtuelle Funktion aufrufen w"urden.

Daher schaffen wir auch noch die Klassen double_vector, int_vector und integer_vector. Die beiden letzten sind die jetzige Klasse integer_vector (allerdings einmal mit int statt integer), f"ur die erste kann man entweder die jetzige Klasse vector nehmen oder auch eine modifizierte integer_vector.

Dann ersten wir f"ur diese Spezialf"alle, die allgemeine Implementierung durch die spezielle, d.h. im h-file gibt es die Zeilen

class vector<double>: public double_vector { leerer Rumpf}
-----------------------------------------------------

hiezu zwei mails von Stefan




template spezialisierugnen funktionieren ganz einfach:


template <class T>  vector {

....

};


class vector<double> : public double_vector {};


Hier ein anderes Beispiel mit Listen, das ich ausprobiert habe.
Es verwendet eine Spezialisierung fuer den LEDA Listen Typ list<T>
wenn T = int ist.


#include <LEDA/list.h>
 
 
class int_list
{
  int_list(); 
 ~int_list(); 
 
  void append(int);
};
 
 
class list<int> : public int_list {};
 
 
main()
{
 
  list<double> dl;
 
  dl.append(1.7);
 
  list<int>    di;
  di.append(17);
 
}


ich bin damit einverstanden die Namen

vector<N>   und   matrix<N>

zu nehmen.

Also

template <class number>

class vector :   private gen_vector
{
   virtual GenPtr addition(GenPtr a, GenPtr b)
    { return   Copy(LEDA_ACCESS(number,a) + LEDA_ACCESS(number,b)); }

   ...
   (oder so aehnlich)

 };



und die Spezialisierungen


class vector<double> : public double_vector
{

    };






Stefan.


2) In matrix.h und integer_matrix.h sind die Philosophien bez"uglich Funktionen verschieden

matrix.h                      integer_matrix.h


M.det()                       determinant(M)                   

Wir nehmen die erste Version, d.h. die Funktionen sind nicht friends sondern members. Also M.det(), M.linear_solve(  ), M.homogeneous_linear_solve(  ) usw.


3) Wenn die Klassen vector<N> und matrix<N> stehen m"ussen wir wohl auch d_rat_point und hyperplane "uberarbeiten. Stefan schl"agt zwei "Anderungen vor.

In Dimension 2 sollten einige der Pr"adikate ausprogrammiert werden und nicht 
auf die Aufrufe von linear_solve usw. zur"uckgef"uhrt werden.

4) Wir m"ussen dann noch aufschreiben, welche Funktionen Zahlentypen unterst"utzen m"ussen. Im Kapitel Foundations gibt es schon eine Aufstellung.
Sie enth"alt +,-, ..., <, <=,     aber vergi\3t sign und so weiter.

Huch: Auch endliche K"orper sollten ein Zahlentyp sein. Da macht sign keinen Sinn. Brauchen vector und matrix denn wirklich sign und <. Ich glaube nicht. Das braucht man erst in hyperplane und d_rat_point. Also sollte man wohl zwei Arten von Zahlentypen unterscheiden. Ungeordnete und Geordnete. 
