Newsgroup: it.comp.lang.c++
Titolo: complex & c

Per una serie di operazioni matematiche, ho la necessità di utilizzare delle
matrici di complex ed ho pertanto realizzato una classe apposita.
Ho a disposizione un certo numero di funzioni in C, che non ho nessuna
intenzione di riscrivere perchè sono molto complesse (e già fatte piuttosto
bene).
Il problema sorge perchè molte di queste funzioni richiedono normalmente un
double *imag e un double *real (o addirittura porcherie tipo doppi puntatori
con dimensioni inserite in #define...).
Ovviamente generare due double[], copiare il contenuto della parte reale e
di quella immaginaria del mio vettore (per semplicità), eseguire la funzione
e ricopiare i risultati è assolutamente folle, ma non so cos'altro potrei
fare.
Avete dei suggerimenti ?
--
*** SPARTACO ***
-> 
amu...@tin.it
 <-
http://www.pegacity.it/informatica/case/473/index.htm

Avete dei suggerimenti ?
Se vuoi fare delle modifiche alle routine gia` scritte in C, non dovrebbe
essere troppo difficile fargli accettare dei vettori di stride due (come mi
pare di capire sono i vettori delle parti reali e immaginarie che tu hai a
disposizione).  Se usano indici nei vettori bastera` avere come parametro,
invece di un bieco array low-level, una furbetta classe che implementa
opportunamente l'operator[]; se usano puntatori, si trattera` di passargli
"puntatori" opportunamente furbetti e maliziosi.  Probabilmente basterebbe
cambiare opportunamente gli header e le dichiarazioni iniziali delle varie
definizioni, e il corpo delle funzioni potrebbe restare intonso.
Ma non si puo` fare senza modificarle.
Alex

(posted)
Funziona, ma che fatica questi const !!!
class Vecchia
{
  Matrice *M;
  const Matrice *MC;
  double &(complex::*funz)(void);
  double &(Vecchia::*nc)(unsigned);
  double &NC1(unsigned i) {return ((*M)(i).*funz)();}
  double &NC2(unsigned i) {throw ExpErr();}
public :
  Vecchia (Matrice &MM, double &(complex::*f)())
   : M(&MM), MC(&MM), funz(f), nc(&Vecchia::NC1) {}
  Vecchia (const Matrice &MM, double &(complex::*f)())
   : MC(&MM), M(NULL), funz(NULL), nc(&Vecchia::NC2) {}
  double &operator[](unsigned i) {return (this->*nc)(i);}
  double operator[](unsigned i) const
  {
   return ((complex)((*MC)(i)).*funz)();
    // se tolgo il cast mi dice che non è possibile convertire un const
complex* a complex*
  }
  bool operator==(unsigned dim) const {return MC->Righe()==dim ||
MC->Colonne()==dim;} // Bruttino, ma necessario perchè sia possibile v==NULL
};
class Immaginaria : public Vecchia
{
public :
  Immaginaria(Matrice &MM) : Vecchia(MM,&complex::imag) {}
  Immaginaria(const Matrice &MM) : Vecchia(MM,&complex::imag) {}
};
class Reale : public Vecchia
{
public :
  Reale(Matrice &MM) : Vecchia(MM,&complex::real) {}
  Reale(const Matrice &MM) : Vecchia(MM,&complex::real) {}
};
Ho dovuto modificare la classe complex per aggiungervi :
double &imag() {return im;}
double &real() {return re;}
La mia Matrice ha due operator()(unsigned) :
complex &operator()(unsigned)
complex operator()(unsigned) const
Una dannatissima cosa che non sono riuscito proprio a fare è la seguente :
Vecchia(const Matrice &MM, double (complex::* const f)())
(ovviamente bisognerebbe a questo punto avere anche una double (complex::*
const f)())
visto che complex ha anche
double imag() const
double real() const
non dovrebbe esserci problema : e invece, un bel cavolo !
--> impossibile trovare un match per Vecchia(const Matrice,
double(complex::*)()) <--
Ma siamo pazzi !?
Comunque, se hai qualche suggerimento, sono qui ad ascoltarti !
Dopo pasquetta provo anche con i puntatori.
Grazie per l'aiuto fino ad ora e buana Pasqua.
P.S. C'è qualcuno oltre ad Alex che ha dei suggerimenti ?
