shz::complex Struct Reference

#include <shz_complex.hpp>

Inheritance diagram for shz::complex:

Collaboration diagram for shz::complex:

Public Member Functions
Constructors
Members for initializing and constructing.
	complex () noexcept=default
	complex (const complex &rhs) noexcept=default
	complex (float re, float im=0.0f) noexcept
	complex (const shz_complex_t &cplx) noexcept
	complex (const volatile shz_complex_t &cplx) noexcept
Member Operators
Overloaded operators defined as member functions.
complex &	operator= (const complex &rhs) noexcept=default
complex &	operator= (const shz_complex_t &rhs) noexcept
volatile complex &	operator= (volatile shz_complex_t rhs) volatile noexcept
complex &	operator+= (shz_complex_t rhs) noexcept
complex &	operator-= (shz_complex_t rhs) noexcept
complex &	operator*= (shz_complex_t rhs) noexcept
complex &	operator*= (float scale) noexcept
complex &	operator/= (shz_complex_t rhs) noexcept

Additional Inherited Members
Data Fields inherited from shz_complex_t
float	real
float	imag

Detailed Description

C++ wrapper around a floating-point complex number, real/imaginary pair.

Definition at line 28 of file shz_complex.hpp.

Constructor & Destructor Documentation

complex() [1/5]

shz::complex::complex ( )

defaultnoexcept

Default constructor.

complex() [2/5]

shz::complex::complex ( const complex & rhs )

defaultnoexcept

Default copy constructor.

complex() [3/5]

shz::complex::complex ( float re, float im = 0.0f )

inlinenoexcept

Value constructor, sets the imaginary component to 0 if none is supplied.

Definition at line 42 of file shz_complex.hpp.

                                                                    :
            shz_complex_t({ re, im }) {}

complex() [4/5]

shz::complex::complex ( const shz_complex_t & cplx )

inlinenoexcept

Converting constructor for initializing from the C base type.

Definition at line 46 of file shz_complex.hpp.

                                                                    :
            complex(cplx.real, cplx.imag) {}

complex() [5/5]

shz::complex::complex ( const volatile shz_complex_t & cplx )

inlinenoexcept

Converting constructor for initialization from a volatile value type.

Definition at line 50 of file shz_complex.hpp.

                                                                             :
            complex(cplx.real, cplx.imag) {}

Member Function Documentation

operator=() [1/3]

complex & shz::complex::operator= ( const complex & rhs )

defaultnoexcept

Defaulted assignment operator.

operator=() [2/3]

complex & shz::complex::operator= ( const shz_complex_t & rhs )

inlinenoexcept

Overloaded assignment operator for assigning to the C base type.

Definition at line 64 of file shz_complex.hpp.

                                                                               {
            real = rhs.real;
            imag = rhs.imag;
 
            return *this;
        }

operator=() [3/3]

volatile complex & shz::complex::operator= ( volatile shz_complex_t rhs ) volatile

inlinenoexcept

Overloaded assignment operator for assigning from a volatile C base type.

Definition at line 72 of file shz_complex.hpp.

                                                                                                   {
            real = rhs.real;
            imag = rhs.imag;
 
            return *this;
        }

operator+=()

complex & shz::complex::operator+= ( shz_complex_t rhs )

inlinenoexcept

Adds and accumulates rhs onto the given complex number.

Definition at line 80 of file shz_complex.hpp.

                                                                         {
            return (*this = shz_caddf(*this, rhs));
        }

operator-=()

complex & shz::complex::operator-= ( shz_complex_t rhs )

inlinenoexcept

Subtracts rhs from the given complex number, assigning it to the result.

Definition at line 85 of file shz_complex.hpp.

                                                                         {
            return (*this = shz_csubf(*this, rhs));
        }

operator*=() [1/2]

complex & shz::complex::operator*= ( shz_complex_t rhs )

inlinenoexcept

Multiplies and accumulates rhs by the given complex number.

Definition at line 90 of file shz_complex.hpp.

                                                                         {
            return (*this = shz_cmulf(*this, rhs));
        }

operator*=() [2/2]

complex & shz::complex::operator*= ( float scale )

inlinenoexcept

Multiplies and accumulates the given complex number by scalar.

Definition at line 95 of file shz_complex.hpp.

                                                                   {
            return (*this = shz_cscalef(*this, scale));
        }

operator/=()

complex & shz::complex::operator/= ( shz_complex_t rhs )

inlinenoexcept

Divides the given complex number by rhs, assigning it to the result.

Definition at line 100 of file shz_complex.hpp.

                                                                         {
            return (*this = shz_cdivf(*this, rhs));
        }

---

The documentation for this struct was generated from the following file:

• shz_complex.hpp