Como chegar Vector de números complexos a partir de dois vetores (real e imag)

Question

Eu tenho dois vetores de carros alegóricos e eu quero-los para se tornar um vetor de números complexos. Estou preso. Eu não me importo usando iteradores, mas tenho a certeza que estaria redescobrindo a roda eu não estou informado sobre. É meu código me levando na direção certa?

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

O código acima está a atravessar o compilador corretamente, mas quando eu quero começar números únicos de myComplexVector usando iterador eu recebo erro "símbolo indefinido 'const_iterator" (Borland C ++)

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

Answer 1

Aqui você está criando um objeto "complexo", cujas partes real e imaginária são vetores de carros alegóricos.
Talvez o que você realmente quer fazer é criar um vetor de objetos complexos cujas partes real e imaginária são flutua?

EDIT: myComplexVector é não um vetor, é um complexo. É por isso que um const_iterator por isso não está definido.

Answer 2

Você pode criar um general "zip" função tomando iterators a ambos os vetores e um functor conversor e um iterador de saída:

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 eu gostaria que houvesse tal função um na STL ...

Answer 3

Whay não fazê-lo muito mais fácil?

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

Answer 4

A maneira mais fácil é simplesmente escrever o loop

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:. ... e seguir o conselho de Neil declarar tipo myComplexVector corretamente

Answer 5

Isto não faz qualquer sentido:

typedef std::complex<CVFloat> myComplexVector;

certamente você quer dizer

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

ou algo semelhante?

Uma vez UO tem isso, você pode simplesmente iterar sobre os vetores flutuador (assumindo que eles contêm valores correspondentes) e adicionar ao seu vector complexa usando push_back ():

CFVector v;

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

Answer 6

Um número complexo é simplesmente um par de dois números reais a e b denotar que o complexo a+bi número. O que exatamente você está tentando fazer com os dois vetores?

Answer 7

Eu entendo sua pergunta que você quiser combinar um vetor de partes reais com um vetor de partes imaginárias em um vetor de números complexos.

std::complex tem um parâmetro de modelo que permite que você escolheu o represenation numérica das partes do complexo (ou seja, se você quiser valores complexas baseadas em double ou float ou mesmo algum costume tipo de número ...). O tipo complexo, em seguida, define a álgebra complexa básico em termos do tipo subjacente.

Em seu código você está tentando construir um tipo complexo baseado em um vetor de carros alegóricos (ou seja, um única valor complexo que tem uma parte real e imaginária ser um vector), que é obviamente errado. Em vez disso você quer um vector de números complexos do tipo float

Você teria que fazer algo como:

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

Observações:

• Na maioria dos casos, não é necessária a criação de recipientes, tais como vectores na pilha (isto é, utilizando new) Tentar evitar este.

• Infelizmente o doesnt biblioteca C ++ padrão contêm uma combinação de iterator (isto é, que "automaticamente" combina duas sequências) que permitiria uma solução mais elegante (ver Aumento Zip iterador para uma idéia geral).