Что на самом деле делает эта структура?

Question

Я нашел этот структурный код в примере Джулии Сет из книги по CUDA. Я начинающий программист C и не могу понять, что он делает, и я не нашел нужную информацию в Интернете, чтобы разобраться в этом. Вот структура:

struct cuComplex {
    float   r;
    float   i;
    cuComplex( float a, float b ) : r(a), i(b)  {}
    float magnitude2( void ) { return r * r + i * i; }
    cuComplex operator*(const cuComplex& a) {
        return cuComplex(r*a.r - i*a.i, i*a.r + r*a.i);
    }
    cuComplex operator+(const cuComplex& a) {
        return cuComplex(r+a.r, i+a.i);
    }
};

и это называется очень просто так:

cuComplex c(-0.8, 0.156);
cuComplex a(jx, jy);

int i = 0;
for (i=0; i<200; i++) {
    a = a * a + c;
    if (a.magnitude2() > 1000)
        return 0;
}

return 1;

Итак, код сделал что? Определено что-то типа структуры «cuComplex», дающее реальные и мнимые части числа. (-0,8 и 0,156) Что возвращается? (Или помещен в структуру?) Как мне работать с логикой оператора в структуре, чтобы понять, что на самом деле рассчитывается и хранится там?

Я думаю, что он, вероятно, выполняет рекурсивные вызовы обратно в структуру

float magnitude2 (void) { return return r * r + i * i; }

, вероятно, вызывает оператор '*' для r и снова для i, а затем результаты этих двух операций вызывают оператор '+'? Это правильно и что возвращается на каждом этапе?

Просто в замешательстве.

Спасибо!

Answer 1

Оператор умножения просто берет действительную и мнимую часть аргумента a и добавляет их к действительной и мнимой частям объекта, к которому вызывается оператор, и возвращает новый комплексный объект числа результата. Я добавил указатель this , чтобы уточнить:

cuComplex operator*(const cuComplex& a) {
    // first constructor argument is the real part, second is the imaginary part
    return cuComplex(this->r*a.r - this->i*a.i, this->i*a.r + this->r*a.i);
}

То же самое касается оператора сложения. Снова копия нового объекта типа cuComplex создается и возвращается. На этот раз действительной и мнимой его частью является сумма соответствующих полей этого объекта и аргумента.

оператор cuComplex + (const cuComplex & a) { return cuComplex (this-> r + a.r, this-> i + a.i); } * +1010 *

Для цикла кажется, что мнимое число a умножается на себя (что приводит к вращению в плоскости Re-Im и добавляется постоянное мнимое c в каждая итерация, пока величина (длина) результата не превысит определенный порог.

Обратите внимание, что и оператор *, и оператор +, а также функция magnitude2 () являются членами структуры cuComplex и, таким образом, доступен указатель this .

Надеюсь, это поможет.

Answer 2

Это не простая структура, а класс (который в основном представляет собой структуру с функциями) и представляет собой C ++.

cuComplex c(-0.8, 0.156);

Здесь он создает экземпляр этого класса и устанавливает 2 значения, вызывая конструктор (специальная функция, которая инициализирует поля экземпляра класса).

Это, вероятно, не будет иметь достаточного смысла, поэтому я предлагаю вам изучить книгу по C ++. Ускоренный C ++ - хороший выбор, если вы уже знакомы с программированием.

Answer 3

Это реализация C ++ сложного числа, предоставляющая метод для возврата величины и перегрузок операторов для сложения и умножения.Действительная (r) и мнимая (i) части хранятся отдельно.

a * a + c вызывает перегруженные методы: (a.operator*(a)).operator+(c)

Похоже, вы очень мало разбираетесь вчетный синтаксис C (return r * r + i * i; возвращает r раз r плюс i раз i), поэтому я предлагаю вам прочитать введение новичка в C / C ++, затем введение в комплексные числа, а затем прочитатьперегрузка операторов в C ++.

Answer 4

r и i являются членами структуры, объявленной как float.Выражение в функции magnitude2 просто выполняет стандартную арифметику с плавающей запятой со значениями, хранящимися в этих элементах.

Функции операторов, определенные в структуре, используются, когда операторы * и + применяются к переменнойтипа struct, например, в строке a = a * a + c.

Answer 5

Как вы и сказали, cuComplex содержит два значения для вещественной (r) и мнимой (i) части числа.Конструктор просто присваивает значение r и i.

Оператор * работает с номерами cuComplex.Операторы умножения и сложения будут вызываться только в том случае, если вы умножаете два объекта cuComplex вместе.

Они просто существуют для упрощения вашего кода.Без оператора вам пришлось бы выполнить операцию добавления самостоятельно:

cuComplex c(-0.8, 0.156);
cuComplex a(jx, jy);

// Add, both operations are equivalent.
cuComplex result1 = cuComplex(c.r + a.r, c.i + a.i);
cuComplex result2 = c + a;

Что касается кода

cuComplex c(-0.8, 0.156); // Create cuComplex instance called c
cuComplex a(jx, jy); // Create cuComplex instance called a

int i = 0;
for (i=0; i<200; i++) {
    a = a * a + c; // Use the * and + operator of cuComplex
    if (a.magnitude2() > 1000)
        return 0;
}

return 1;

Я думаю, что он, вероятно, выполняет рекурсивные вызовы обратно в структуру

float magnitude2 (void) { return return r * r + i * i; }

Это не так, поскольку r и i являются float.Операторы * и + перегружены для cuComplex, а не с плавающей точкой

Answer 6

В C ++ просто используйте std::complex<float>.

Answer 7

Если вы знакомы с понятием классов, замените слово «struct» на «class», это облегчит его понимание.

«Класс» содержит две переменные r и i, конструктор, который принимает два аргумента с плавающей запятой, оператор умножения, оператор сложения и функцию для вычисления величины.

Answer 8

Вы должны пометить этот вопрос как C++, а не C (даже если у вас есть struct, этот имеет конструктор и переопределяет операторы, которые являются типичными объектно-ориентированными понятиями).

Эта структура определяет комплексные числа, позволяет умножать (через operator*), добавлять их (через operator+) и получать их модуль (через magnitude2).

В начале;у вас есть одно постоянное комплексное число, c и a, другое комплексное число , которое не является постоянным , данное пользователем, вероятно, через координаты jx и jy.На каждой итерации цикла a умножается сам по себе, и к этому результату добавляется c.

Если в какой-то момент a имеет модуль больше 1000, цикл заканчивается,Я предполагаю, что это тестовая программа, чтобы увидеть, как модуль a растет в соответствии с начальными условиями, заданными пользователем.