Wie Vektor der komplexen Zahlen von zwei Vektoren (real und imag) erhalten

Question

Ich habe zwei Vektoren von Schwimmern und ich möchte, dass sie einen Vektor von komplexen Zahlen werden. Ich stecke fest. Ich kümmere mich nicht Iteratoren verwenden, aber ich bin sicher, es wäre das Rad neu zu entdecken sein, ich bin nicht informiert. Ist mein Code mich in die richtige Richtung führen?

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

Der obige Code durch den Compiler wird richtig, aber wenn ich will Iterator einzelne Zahlen von myComplexVector bekommen mit i bekommen Fehler "nicht definiert Symbol 'const_iterator'" (Borland C ++)

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

Answer 1

Hier erstellen Sie ein „komplexes“ Objekt, deren realen und imaginären Teile sind Vektoren von Schwimmern.
Vielleicht, was wollen Sie eigentlich zu tun ist, um einen Vektor von komplexen Objekten, deren Real- und Imaginärteil schaffen Schwimmer?

EDIT: myComplexVector ist nicht ein Vektor, ist ein komplexer. Deshalb ist ein const_iterator für es nicht definiert ist.

Answer 2

Sie können einen allgemeinen „zip“ -Funktion erstellen Iteratoren zu beiden Vektoren und einen Wandler Funktors und einen Ausgang Iterator unter:

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 ) );

Und ich wünsche es eine solche Funktion in der STL waren ...

Answer 3

Whay es nicht viel einfacher?

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

Answer 4

Der einfachste Weg ist nur die Schleife schreiben

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));

Edit: ... und Neil Rat folgt richtig zu erklären myComplexVector Typ

.

Answer 5

Das macht keinen Sinn machen:

typedef std::complex<CVFloat> myComplexVector;

Sie sicherlich bedeuten

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

oder etwas ähnliches?

Sobald ou es haben Sie können einfach über die Schwimmervektoren laufen (vorausgesetzt, sie passende Werte enthalten) und fügen Sie Ihre komplexen Vektor mit push_back ():

CFVector v;

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

Answer 6

Eine komplexe Zahl ist einfach ein Paar von zwei reellen Zahlen a und b, die die komplexe Zahl a+bi bezeichnen. Was genau sind Sie mit den beiden Vektoren zu tun versuchen?

Answer 7

Ich verstehe Ihre Frage, die Sie einen Vektor von Realteilen mit einem Vektor der imaginären Teile in einen Vektor von komplexen Zahlen kombinieren mögen.

std::complex hat einen Template-Parameter, die können Sie die numerische represenation der Teile des Komplexes gewählt (das heißt, wenn Sie auf double oder float oder sogar einigen benutzerdefinierten Zahlentyp basierten komplexe Werte wollen ...). Der Komplex Typ definiert dann grundlegenden komplexen Algebra in Bezug auf den zugrunde liegenden Typ.

In Ihrem Code Sie versuchen, einen komplexen Typen auf einem Vektor von Schwimmern (das heißt ein Single komplexer Wert mit einem realen und imaginären Teil ist ein Vektor) auf der Grundlage zu konstruieren, was offensichtlich falsch ist. Stattdessen wollen Sie ein Vektor von komplexen Zahlen vom Typ float

Sie würden so etwas wie zu tun:

// ...
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));

Bemerkungen:

• In den meisten Fällen ist es nicht notwendig ist, Behälter zu schaffen, wie Vektoren auf dem Heap (das heißt mit new) Versuchen Sie, dies zu vermeiden.

• Leider ist die C ++ Standard-Bibliothek muß nicht eine Kombination Iterator (dh eine, die „automatisch“ zwei Sequenzen kombiniert) enthalten, die eine elegantere Lösung erlauben würde (siehe Boost-Zip Iterator für eine allgemeine Idee).