mspass::algorithms::deconvolution::ComplexArray Class Reference

Public Member Functions
	ComplexArray ()
	ComplexArray (std::vector< Complex64 > &d)
	ComplexArray (std::vector< Complex32 > &d)
	ComplexArray (int nsamp, FortranComplex32 *d)
	ComplexArray (int nsamp, FortranComplex64 *d)
	ComplexArray (int nsamp, float *d)
	ComplexArray (int nsamp, double *d)
	ComplexArray (int nsamp)
template<class T >
	ComplexArray (int nsamp, std::vector< T > d)
template<class T >
	ComplexArray (int nsamp, T d)
	ComplexArray (std::vector< double > mag, std::vector< double > phase)
	ComplexArray (const ComplexArray &parent)
ComplexArray &	operator= (const ComplexArray &parent)
Complex64	operator[] (int sample)
double *	ptr ()
double *	ptr (int sample)
ComplexArray &	operator+= (const ComplexArray &other) noexcept(false)
ComplexArray &	operator-= (const ComplexArray &other) noexcept(false)
ComplexArray &	operator*= (const ComplexArray &other) noexcept(false)
ComplexArray &	operator/= (const ComplexArray &other) noexcept(false)
const ComplexArray	operator+ (const ComplexArray &other) const noexcept(false)
const ComplexArray	operator- (const ComplexArray &other) const noexcept(false)
const ComplexArray	operator* (const ComplexArray &other) const noexcept(false)
const ComplexArray	operator/ (const ComplexArray &other) const noexcept(false)
void	conj ()
std::vector< double >	abs () const
double	rms () const
double	norm2 () const
std::vector< double >	phase () const
int	size () const

Constructor & Destructor Documentation

ComplexArray() [1/12]

mspass::algorithms::deconvolution::ComplexArray::ComplexArray

(

)

Empty constructor.

                           {
  nsamp = 0;
  /* Note declaration of shared_ptr initializes it with a NULL
     pointer equivalent - no initialization is needed */
}

ComplexArray() [2/12]

mspass::algorithms::deconvolution::ComplexArray::ComplexArray

(

std::vector< Complex64 > &

d

)

Construct from stl vector container of complex.

ComplexArray() [3/12]

mspass::algorithms::deconvolution::ComplexArray::ComplexArray

(

std::vector< Complex32 > &

d

)

Similar for 32 bit version

ComplexArray() [4/12]

mspass::algorithms::deconvolution::ComplexArray::ComplexArray	(	int	nsamp,
		FortranComplex32 *	d
	)

Construct from a FORTRAN data array.

Fortran stores complex numbers in a mulitplexed array structure (real(1), imag(1), real(2), imag(2), etc.). The constructors below provide a mechanism for building this object from various permutations of this.

Parameters

nsamp	is the number of elements in the C vector
d	is the pointer to the first compoment of the fortran vector.

                                                     {
  nsamp = n;
  data = std::shared_ptr<FortranComplex64[]>(new FortranComplex64[nsamp]);
  for (std::size_t i = 0; i < nsamp; i++) {
    data[i].real = d[i].real;
    data[i].imag = d[i].imag;
  }
}

ComplexArray() [5/12]

mspass::algorithms::deconvolution::ComplexArray::ComplexArray	(	int	nsamp,
		FortranComplex64 *	d
	)

                                                     {
  nsamp = n;
  data = std::shared_ptr<FortranComplex64[]>(new FortranComplex64[nsamp]);
  for (std::size_t i = 0; i < nsamp; i++) {
    data[i].real = d[i].real;
    data[i].imag = d[i].imag;
  }
}

ComplexArray() [6/12]

mspass::algorithms::deconvolution::ComplexArray::ComplexArray	(	int	nsamp,
		float *	d
	)

                                          {
  nsamp = n;
  data = std::shared_ptr<FortranComplex64[]>(new FortranComplex64[nsamp]);
  for (std::size_t i = 0; i < nsamp; i++) {
    data[i].real = d[i];
    data[i].imag = 0.0;
  }
}

ComplexArray() [7/12]

mspass::algorithms::deconvolution::ComplexArray::ComplexArray	(	int	nsamp,
		double *	d
	)

                                           {
  nsamp = n;
  data = std::shared_ptr<FortranComplex64[]>(new FortranComplex64[nsamp]);
  for (std::size_t i = 0; i < nsamp; i++) {
    data[i].real = d[i];
    data[i].imag = 0.0;
  }
}

ComplexArray() [8/12]

mspass::algorithms::deconvolution::ComplexArray::ComplexArray

(

int

nsamp

)

                                {
  nsamp = n;
  data = std::shared_ptr<FortranComplex64[]>(new FortranComplex64[nsamp]);
  for (std::size_t i = 0; i < nsamp; i++) {
    data[i].real = 0.0;
    data[i].imag = 0.0;
  }
}

ComplexArray() [9/12]

template<class T >

mspass::algorithms::deconvolution::ComplexArray::ComplexArray	(	int	nsamp,
		std::vector< T >	d
	)

Construct from different length of vector, adds zoeros to it And construct a constant arrays

                                                                   {
  nsamp = n;
  if (nsamp > d.size()) {
    data = std::shared_ptr<FortranComplex64[]>(new FortranComplex64[nsamp]);
    for (std::size_t i = 0; i < d.size(); i++) {
      this->data[i].real = d[i];
      this->data[i].imag = 0.0;
    }
    for (std::size_t i = d.size(); i < nsamp; i++) {
      this->data[i].real = 0.0;
      this->data[i].imag = 0.0;
    }
  } else {
    data = std::shared_ptr<FortranComplex64[]>(new FortranComplex64[nsamp]);
    for (std::size_t i = 0; i < nsamp; i++) {
      this->data[i].real = d[i];
      this->data[i].imag = 0.0;
    }
  }
}

ComplexArray() [10/12]

template<class T >

mspass::algorithms::deconvolution::ComplexArray::ComplexArray	(	int	nsamp,
		T	d
	)

                                                        {
  nsamp = n;
  data = std::shared_ptr<FortranComplex64[]>(new FortranComplex64[nsamp]);
  for (std::size_t i = 0; i < nsamp; i++) {
    this->data[i].real = d;
    this->data[i].imag = 0.0;
  }
}

ComplexArray() [11/12]

mspass::algorithms::deconvolution::ComplexArray::ComplexArray	(	std::vector< double >	mag,
		std::vector< double >	phase
	)

Construct from magnitude and phase arrays.

ComplexArray() [12/12]

mspass::algorithms::deconvolution::ComplexArray::ComplexArray

(

const ComplexArray &

parent

)

                                                     {
  nsamp = parent.nsamp;
  data = std::shared_ptr<FortranComplex64[]>(new FortranComplex64[nsamp]);
  for (std::size_t i = 0; i < nsamp; i++) {
    data[i].real = parent.data[i].real;
    data[i].imag = parent.data[i].imag;
  }
}

~ComplexArray()

mspass::algorithms::deconvolution::ComplexArray::~ComplexArray

(

)

                            {
  /*Original implementation used a raw pointer for data array.   Changed
    Dec. 2024 to shared_ptr so this destructor now does nothing.*/
  // delete[] data;
}

Member Function Documentation

abs()

vector< double > mspass::algorithms::deconvolution::ComplexArray::abs

(

)

const

                                       {
  vector<double> result;
  result.reserve(nsamp);
  for (std::size_t i = 0; i < nsamp; i++)
    result.push_back(sqrt((double)data[i].real * data[i].real +
                          data[i].imag * data[i].imag));
  return result;
}

conj()

void mspass::algorithms::deconvolution::ComplexArray::conj

(

)

product of complex and real vectors

product of complex and a number

Change vector to complex conjugates.

                        {
  for (std::size_t i = 0; i < nsamp; i++)
    data[i].imag = -data[i].imag;
}

norm2()

double mspass::algorithms::deconvolution::ComplexArray::norm2

(

)

const

                                 {
  double result = 0;
  for (std::size_t i = 0; i < nsamp; i++)
    result +=
        ((double)data[i].real * data[i].real + data[i].imag * data[i].imag);
  return sqrt(result);
}

operator*()

const ComplexArray mspass::algorithms::deconvolution::ComplexArray::operator*

(

const ComplexArray &

other

)

const

                    {
  try {
    ComplexArray result(*this);
    result *= other;
    return result;
  } catch (...) {
    throw;
  };
}

operator*=()

ComplexArray & mspass::algorithms::deconvolution::ComplexArray::operator*=

(

const ComplexArray &

other

)

                                                                {
  if (nsamp != other.nsamp) {
    stringstream sserr;
    sserr << "ComplexArray::operator*=:  Inconsistent array sizes" << endl
          << "left hand side array size=" << this->nsamp << endl
          << "right hand side array size=" << other.nsamp << endl
          << "Sizes must match to use this operator" << endl;
    throw MsPASSError(sserr.str(), ErrorSeverity::Invalid);
  }
  for (std::size_t i = 0; i < nsamp; i++) {
    Complex64 z1(data[i].real, data[i].imag);
    Complex64 z2(other.data[i].real, other.data[i].imag);
    Complex64 z3(z1 * z2);
    data[i].real = z3.real();
    data[i].imag = z3.imag();
  }
  return (*this);
}

operator+()

const ComplexArray mspass::algorithms::deconvolution::ComplexArray::operator+

(

const ComplexArray &

other

)

const

                    {
  try {
    ComplexArray result(*this);
    result += other;
    return result;
  } catch (...) {
    throw;
  };
}

operator+=()

ComplexArray & mspass::algorithms::deconvolution::ComplexArray::operator+=

(

const ComplexArray &

other

)

                                                                {
  if (nsamp != other.nsamp) {
    stringstream sserr;
    sserr << "ComplexArray::operator+=:  Inconsistent array sizes" << endl
          << "left hand side array size=" << this->nsamp << endl
          << "right hand side array size=" << other.nsamp << endl
          << "Sizes must match to use this operator" << endl;
    throw MsPASSError(sserr.str(), ErrorSeverity::Invalid);
  }
  for (std::size_t i = 0; i < nsamp; i++) {
    data[i].real += other.data[i].real;
    data[i].imag += other.data[i].imag;
  }
  return *this;
}

operator-()

const ComplexArray mspass::algorithms::deconvolution::ComplexArray::operator-

(

const ComplexArray &

other

)

const

                    {
  try {
    ComplexArray result(*this);
    result -= other;
    return result;
  } catch (...) {
    throw;
  };
}

operator-=()

ComplexArray & mspass::algorithms::deconvolution::ComplexArray::operator-=

(

const ComplexArray &

other

)

                                                                {
  if (nsamp != other.nsamp) {
    stringstream sserr;
    sserr << "ComplexArray::operator-=:  Inconsistent array sizes" << endl
          << "left hand side array size=" << this->nsamp << endl
          << "right hand side array size=" << other.nsamp << endl
          << "Sizes must match to use this operator" << endl;
    throw MsPASSError(sserr.str(), ErrorSeverity::Invalid);
  }
  for (std::size_t i = 0; i < nsamp; i++) {
    data[i].real -= other.data[i].real;
    data[i].imag -= other.data[i].imag;
  }
  return *this;
}

operator/()

const ComplexArray mspass::algorithms::deconvolution::ComplexArray::operator/

(

const ComplexArray &

other

)

const

                    {
  try {
    ComplexArray result(*this);
    result /= other;
    return result;
  } catch (...) {
    throw;
  };
}

operator/=()

ComplexArray & mspass::algorithms::deconvolution::ComplexArray::operator/=

(

const ComplexArray &

other

)

                                                                {
  if (nsamp != other.nsamp) {
    stringstream sserr;
    sserr << "ComplexArray::operator/=:  Inconsistent array sizes" << endl
          << "left hand side array size=" << this->nsamp << endl
          << "right hand side array size=" << other.nsamp << endl
          << "Sizes must match to use this operator" << endl;
    throw MsPASSError(sserr.str(), ErrorSeverity::Invalid);
  }
  for (std::size_t i = 0; i < nsamp; i++) {
    Complex64 z1(data[i].real, data[i].imag);
    Complex64 z2(other.data[i].real, other.data[i].imag);
    Complex64 z3(z1 / z2);
    data[i].real = z3.real();
    data[i].imag = z3.imag();
  }
  /* For efficiency we scan this array for nans rather than
  put that in the loop above - standard advice for efficiency in
  vector operators on modern computers */
  for (std::size_t i = 0; i < nsamp; ++i) {
    if (gsl_isnan(data[i].real) || gsl_isnan(data[i].imag)) {
      stringstream ss;
      ss << "ComplexArray::operator /=:  Division yielded a NaN "
         << "at sample number " << i << endl
         << "Denominator used for right hand side=" << other.data[i].real
         << " + " << other.data[i].imag << " i " << endl;
      throw MsPASSError(ss.str(), ErrorSeverity::Suspect);
    }
  }
  return (*this);
}

operator=()

ComplexArray & mspass::algorithms::deconvolution::ComplexArray::operator=

(

const ComplexArray &

parent

)

                                                                {
  if (&parent != this) {
    this->nsamp = parent.nsamp;
    this->data =
        std::shared_ptr<FortranComplex64[]>(new FortranComplex64[nsamp]);
    for (std::size_t i = 0; i < nsamp; i++) {
      this->data[i].real = parent.data[i].real;
      this->data[i].imag = parent.data[i].imag;
    }
  }
  return *this;
}

operator[]()

Complex64 mspass::algorithms::deconvolution::ComplexArray::operator[]

(

int

sample

)

Return a pointer to a fortran array containing the data vector.

The array linked to the returned pointer should be created with the new operator and the caller should be sure to use delete [] to free this memory when finished.

Index operator. Cannot make it work by getting the address from reference. Have to call the ptr() function to get the address.

Parameters

sample

is the sample number to return.

Returns

contents of vector at position sample.

                                             {
  return *reinterpret_cast<Complex64 *>(&data[sample].real);
}

phase()

vector< double > mspass::algorithms::deconvolution::ComplexArray::phase

(

)

const

                                         {
  vector<double> result;
  result.reserve(nsamp);
  for (std::size_t i = 0; i < nsamp; i++)
    result.push_back(atan2((double)data[i].imag, (double)data[i].real));
  return result;
}

ptr() [1/2]

double * mspass::algorithms::deconvolution::ComplexArray::ptr

(

)

                          {
  return reinterpret_cast<double *>(&data[0].real);
}

ptr() [2/2]

double * mspass::algorithms::deconvolution::ComplexArray::ptr

(

int

sample

)

                                    {
  return reinterpret_cast<double *>(&data[sample].real);
}

rms()

double mspass::algorithms::deconvolution::ComplexArray::rms

(

)

const

                               {
  double result = 0;
  for (std::size_t i = 0; i < nsamp; i++)
    result +=
        ((double)data[i].real * data[i].real + data[i].imag * data[i].imag) /
        nsamp / nsamp;
  return sqrt(result);
}

size()

int mspass::algorithms::deconvolution::ComplexArray::size

(

)

const

{ return nsamp; }

---

The documentation for this class was generated from the following files:

• /home/runner/work/mspass/mspass/cxx/include/mspass/algorithms/deconvolution/ComplexArray.h
• /home/runner/work/mspass/mspass/cxx/src/lib/algorithms/deconvolution/ComplexArray.cc