Сумма квадратов комплексных чисел в порядке убывания

ProgramBox

Сумма квадратов комплексных чисел в порядке убывания

Post author:admin
Запись опубликована:7 февраля, 2023
Post category:Вопросы по программированию

#c #sorting #merge

#c #сортировка #слияние

Вопрос:

Я хотел бы вычислить сумму квадратов комплексных чисел в порядке убывания, используя три исходных кода (Complex2.h, Complex2.cpp , Вектор3) например) (5 6i)^2 (3 4i)^2 (1 2i)^ 2….

Я пытаюсь добавить и изменить некоторые коды в Vector3, чтобы получить результат, но сейчас застрял посередине.. Кто-нибудь дает какие-нибудь советы?

 //Complex2.h
#ifndef  COMPLEX2_H_INCLUDED
#define  COMPLEX2_H_INCLUDED
#include    <ostream>
using namespace std;
class  Complex2 {
    double  rPart, iPart;           // real part and imaginary part
public:
    // operator
    Complex2(double r = 0, double i = 0) : rPart(r), iPart(i) {}
    Complex2  conj()  const {
        return Complex2(rPart, -iPart);
    }
    Complex2  operator (const Complex2 amp;c) const;
    Complex2  operator (double r) const;
    Complex2  operator-(const Complex2 amp;c) const;
    Complex2  operator-(double r) const;
    Complex2  operator*(const Complex2 amp;c) const;
    Complex2  operator*(double r) const;
    Complex2  operator/(const Complex2 amp;c) const;
    Complex2  operator/(double r) const;
    Complex2amp; operator =(const Complex2 amp;c);
    Complex2amp; operator-=(const Complex2 amp;c);
    Complex2amp; operator*=(const Complex2 amp;c);
    Complex2amp; operator/=(const Complex2 amp;c);
    bool      operator==(const Complex2 amp;c) const;
    bool      operator!=(const Complex2 amp;c) const;
    double    real() const { return rPart; }
    double    imag() const { return iPart; }
    void  display() const;      // print complex value
    friend  Complex2  operator (double r, const Complex2amp; c);
    friend  ostreamamp; operator<<(ostreamamp; os, const Complex2amp; c);
};
#endif

//Complex2.cpp
#include    <iostream>
#include    "Complex2.h"
using namespace std;

Complex2 Complex2::operator (const Complex2 amp;c) const
{
    return Complex2(rPart   c.rPart, iPart   c.iPart);
}    

Complex2 Complex2::operator (double r) const
{
    return Complex2(rPart   r, iPart);
}

Complex2 Complex2::operator-(const Complex2 amp;c) const
{
    return Complex2(rPart - c.rPart, iPart - c.iPart);
}

Complex2 Complex2::operator-(double r) const
{
    return Complex2(rPart - r, iPart);
}

Complex2 Complex2::operator*(const Complex2 amp;c) const
{
    return Complex2(rPart * c.rPart - iPart * c.iPart, rPart * c.iPart   iPart * c.rPart);
}

Complex2 Complex2::operator*(double r) const
{
    return Complex2(rPart * r, iPart * r);
}

Complex2 Complex2::operator/(const Complex2 amp;c) const
{
    double  d = c.rPart * c.rPart   c.iPart * c.iPart;
    return Complex2((rPart * c.rPart   iPart * c.iPart) / d, (iPart * c.rPart - rPart * c.iPart) /     d);
}

Complex2 Complex2::operator/(double r) const
{
    return Complex2(rPart / r, iPart / r);
}

Complex2amp; Complex2::operator =(const Complex2 amp;c)
{
    rPart  = c.rPart;    iPart  = c.iPart;
    return *this;
}

Complex2amp; Complex2::operator-=(const Complex2 amp;c)
{
    rPart -= c.rPart;    iPart -= c.iPart;
    return *this;
}

Complex2amp; Complex2::operator*=(const Complex2 amp;c)
{
    *this = *this * c;
    return *this;
}

Complex2amp; Complex2::operator/=(const Complex2 amp;c)
{
    *this = *this / c;
    return *this;
}

bool Complex2::operator==(const Complex2 amp;c) const
{
    return  rPart == c.rPart amp;amp; iPart == c.iPart;
}

bool Complex2::operator!=(const Complex2 amp;c) const
{
    return  rPart != c.rPart || iPart != c.iPart;
}

void  Complex2::display() const
{
    cout << "(" << rPart;
    if (iPart > 0)
        cout << " j" << iPart;
    else if (iPart < 0)
        cout << "-j" << -iPart;
    cout << ")";
}    

Complex2  operator (double r, const Complex2amp; c)
{
    return Complex2(r   c.rPart, c.iPart);
}

ostreamamp;  operator<<(ostreamamp; os, const Complex2amp; c)
{
    os << "(" << c.rPart;   // print real part
    if (c.iPart > 0)        // print imaginary part
        os << " j" << c.iPart;
    else if (c.iPart < 0)
        os << "-j" << -c.iPart;
    cout << ")";
    return os;
}    

//Vector3.cpp
#include  <iostream>
#include  <vector>
#include  <cstdlib>
#include  <ctime>
#include  <algorithm>
#include "Complex2.h";
using  namespace  std;

template<typename T> struct GREATER {
    bool operator()(const Tamp; a, const Tamp; b) const {
        return a > b;
    }
};

int  main()
{
    srand((unsigned)time(NULL));   // Initialize random number generation

    vector<Complex2> cv1(5);
    cout << "vector1 : ";
    for (auto amp;c : cv1) {
        c = rand() % 100;         // 0~99 random number generation
        cout << c << " ";
    }
    sort(cv1.begin(), cv1.end(), GREATER<int>());   // sort algorithm in descending
    cout << endl << "sorted vector1 : ";
    for (auto c : cv1)
        cout << c << " ";
    cout << endl << endl;

    vector<Complex2> cv2(5);
    cout << "vector2 : ";
    for (auto amp;c : cv2) {
        c = rand() % 100;         // 0~99 random number generation
        cout << c << " ";
    }
    sort(cv2.begin(), cv2.end(), GREATER<int>());   // sort algorithm in descending
    cout << endl << "sorted vector2 : ";
    for (auto c : cv2)
        cout << c << " ";
    cout << endl << endl;

    // vector for saving the merged result
    vector<Complex2> cv3(cv1.size()   cv2.size());
    // Save the result cv1 plus cv2 as cv3
    merge(cv1.begin(), cv1.end(),
        cv2.begin(), cv2.end(), cv3.begin(), GREATER<int>());
    cout << "the result of merged vector1 and vector2 : ";
    for (auto c : cv3)
        cout << c << " ";
    cout << endl << endl;

    return 0;
}

1. sort(cv1.begin(), cv1.end(), GREATER<int>()); Это не имеет смысла. Вы берете компаратор, который знает, как сравнивать int s, и пытаетесь использовать его для сравнения комплексных чисел. Математически комплексные числа не образуют единого общего порядка, поэтому неясно, что означает их сортировка.

2. В постановке задачи упоминается «сумма квадратов», но показанный код не суммирует и не возводит в квадрат какие-либо числа, комплексные или иные.

3. Вы можете заменить GREATER на std::greater

Ответ №1:

Для этого все, что вам действительно нужно, это определить operator> :

 bool Complex2::operator>(const Complex2 amp;c) const
{
    return rPart * rPart   iPart * iPart > c.rPart * c.rPart   c.iPart * c.iPart;
}

Затем вы можете вызвать std::sort и std::merge с:

 std::sort(cv1.begin(), cv1.end(), std::greater<Complex2>());

std::merge(cv1.begin(), cv1.end(), cv2.begin(), cv2.end(), 
           cv3.begin(), std::greater<Complex2>());

Примечание: почему бы не использовать std::complex ?

1. Это сработает, если предположить, что OP означал «величина», когда они писали «квадрат».

2. @dxiv На самом деле, если вы возведете в квадрат комплексное число, его величина также будет возведена в квадрат, если только я сегодня не уйду

3. Правильно, и из-за этого сравнение квадратов величин дает тот же порядок сортировки, что и сравнение самих величин. Но OP написал только «квадраты», и сравнить «квадраты» невозможно, потому что квадрат комплексного числа сам по себе является комплексным числом, и для комплексных чисел не существует общего порядка .

Ответ №2:

Здесь очень важна одна вещь:

Невозможно упорядочить комплексные числа!!!

Вы говорите о их упорядочении, и, похоже, вы ищете какую-то функцию упорядочения, но вам нужно знать, что, какими бы ни были способы упорядочения комплексных чисел, порядок должен удовлетворять следующему аргументу:

 Order(Number1, Number2) AND Order(Number2, Number3) => Order(Number1, Number3)

Это выражение не может быть истинным для любого порядка, который вы могли бы придумать (по крайней мере, для комплексных чисел, для упорядочения действительных чисел просто), поэтому ваш вопрос о «порядке убывания» комплексных чисел не может иметь смысла.

Все объяснение можно найти здесь .