Come ottenere vettore di numeri complessi da due vettori (reale e imag)

Question

Ho due vettori di carri e voglio loro di diventare un vettore di numeri complessi. Sono bloccato. Non mi dispiace utilizzando iteratori, ma sono sicuro che sarebbe riscoprendo la ruota non sto informato circa. È il mio codice mi portando nella giusta direzione?

typedef std::vector<float> CVFloat;
CVFloat vA, vB;
//fil vectors
typedef std::complex<CVFloat> myComplexVector;
myComplexVector* vA_Complex = new myComplexVector(vA, vB);

Il codice di cui sopra sta attraversando il compilatore in modo corretto, ma quando voglio ottenere numeri singoli da myComplexVector utilizzando iteratore ottengo l'errore "simbolo indefinito 'const_iterator'" (Borland C ++)

myComplexVector::const_iterator it = vA_Complex->begin();

Answer 1

Qui si sta creando un oggetto "complesso", la cui reale e immaginario parti sono vettori di carri allegorici.
Forse quello che realmente vuole fare è la creazione di un vettore di oggetti complessi le cui parti reale e immaginaria sono carri?

EDIT: myComplexVector è non un vettore, è un complesso. Ecco perché un const_iterator per esso non è definito.

Answer 2

È possibile creare una funzione generale "zip" prendere iteratori ad entrambi i vettori, e un funtore convertitore ed un iteratore di uscita:

template< typename at_It1, typename at_It2, typename at_Transform, typename at_Out >
void zip( at_It1 from1, const at_It1 to1, 
          at_It2 from2, const at_It2 to2,
          at_Transform  tranformer,
          at_Out& av_Out ) {
    while( from1 != to1 ) {
        av_Out = transformer( *from1, *from2 );
        ++av_Out; ++from1; ++from2;
    }
}

struct DoubleToComplex {
     complex<double> operator()( const double d1, const double d2 ) const {
         return complex<double>( d1, d2 );
     }
};



zip( vA.begin(), vA.end(),
     vB.begin(), vB.end(),
     DoubleToComplex(),
     std::back_inserter( vTarget ) );

E mi piacerebbe che ci fosse una tale funzione nel STL ...

Answer 3

Whay non farlo molto molto più facile?

vector< complex<float> > result;
for( int i = 0; i < vA.size(); i++ ) {
    result.push_back( complex<float>( vA[i], vB[i] ) );
}

Answer 4

Il modo più semplice è solo scrivere il ciclo

myComplexVector cv;
for(CVFloat::iterator it1=vA.begin(), end1=vA.end(), 
      it2=vB.begin(), end2=vB.end();
    it1!=end1 && it2 != end2; ++it1, ++it2)
  cv.push_back(std::complex(*it1, *it2));

Modifica: ... e seguire il consiglio di Neil di dichiarare myComplexVector digitare correttamente

.

Answer 5

Questo non ha alcun senso:

typedef std::complex<CVFloat> myComplexVector;

sicuramente dire

typedef std::complex <float> ComplexFloat;
typedef std::vector <ComplexFloat> CFVector;

o qualcosa di simile?

Una volta ou l'hanno si può semplicemente scorrere i vettori galleggiante (ammesso che contengono valori corrispondenti) e aggiungere al vostro vettore complesso utilizzando push_back ():

CFVector v;

for ( int i = 0; i < vA.size(); i++ ) {
  v.push_back( ComplexFloat( vA[i], vB[i] ) );
}

Answer 6

Un numero complesso è semplicemente una coppia di due numeri reali a e b che denotano il numero complesso a+bi. Che cosa esattamente stai cercando di fare con i due vettori?

Answer 7

Capisco la tua domanda che si desidera combinare un vettore di parti reali, con un vettore di parti immaginarie in un vettore di numeri complessi.

std::complex ha un parametro di modello che consente si è scelto il represenation numerica delle parti del complesso (cioè se si desidera che i valori complessi basati su double o float o anche qualche misura Tipo numero ...). Il tipo complesso definisce quindi algebra complesso base in termini di tipo sottostante.

Nel codice che si sta tentando di costruire un tipo complesso basato su un vettore di carri allegorici (vale a dire un solo valore complesso avere una parte reale e immaginaria di essere un vettore), che è ovviamente sbagliato. Invece si vuole un vettore di numeri complessi di tipo float

Dovresti fare qualcosa di simile:

// ...
typedef std::vector<std::complex<float> > floatComplexVector;
floatComplexVector vA_Complex; // No need to 'new' !?

for (CVFLoat::const_iterator itA = vA.begin(), itB = vB.begin(); 
     itA != vA.end() && itB != vB.end(); 
     ++itA,++itB)
  vA_Complex.push_back(std::complex<float>(*itA, *itB));

Nota:

• Nella maggior parte dei casi non è necessario creare contenitori quali vettori sul mucchio (cioè usando new) Per evitare questo.

• Purtroppo la libreria standard non contiene gli un iteratore combinando (cioè una che "automaticamente" unisce due sequenze) che consentirebbe una soluzione più elegante C ++ (vedi Boost Zip iteratore per un'idea generale).