[c/c++]complex类的标准库实现

最新推荐文章于 2024-06-05 16:22:50 发布
最新推荐文章于 2024-06-05 16:22:50 发布
阅读量1.2w 收藏 19
点赞数 1
分类专栏： c++ complex 文章标签： VS2013

简介：

复数运算在数学领域非常重要，而且C++标准库也完备的实现了关于复数的几乎所有运算。要使用compelx类需要包含文件<complex>，并在std命名空间内引用。complex类包含了四则运算（+、-、*、/）、符号运算（+、-）、逻辑运算（==、!=）、三角运算（sin、cos、tan）、双曲运算（sinh、cosh、tanh）、指数运算（exp、pow）、幂运算（log、log10）等。通过对这些基本数据类型都有的操作定义，可以complex类当做基本的数据类型来使用。对于复数运算来说还有一类很重要的反三角函数、反双曲函数，C++标准库并未实现，在boost库的boost\math\complex目录下可以找到实现。

实现：

complex类被定义和实现在<complex>文件内。

文件首先定义了三种数据结构: _C_double_complex（_Dcomplex_value）、_C_float_complex（_Fcomplex_value）、_C_ldouble_complex（_Lcomplex_value）。这些数据结构的意义在于定义了不同类型的complex的内存存储结构。如下：

typedef struct _C_double_complex

    {   /* double complex */

    double _Val[2];

    } _C_double_complex;

typedef struct _C_float_complex

    {   /* float complex */

    float _Val[2];

    } _C_float_complex;

typedef struct _C_ldouble_complex

    {   /* long double complex */

    long double _Val[2];

    } _C_ldouble_complex;

typedef _CSTD _C_double_complex _Dcomplex_value;

typedef _CSTD _C_float_complex _Fcomplex_value;

typedef _CSTD _C_ldouble_complex _Lcomplex_value;

可以看到它的内部使用空间为2的数组来实现。然后文件前置声明了complex类的原型和三种特化版本：complex<float>、complex<double>、complex<long double>。

template<class _Ty> class complex;

template<> class complex<float>;

template<> class complex<double>;

template<> class complex<long double>;

所以我们在使用complex类的时候就可以定义成：

complex<float> fcomplex;

complex<double> dcomplex;

complex<long double> lcomplex;

接下来定义了一个_Ctraits类，该类的作用是定义了一些基本数据类型（如double、float、long double等）拥有的特性（如_Isinf（是否为无穷小）、_Isnan（是否为无穷大）等）以及可实现的函数运算集合（如cos（余弦函数）、tan（正切函数）等）：

        // TEMPLATE CLASS _Ctraits

template<class _Ty> class _Ctraits

    {   // complex traits for _Ty

public:

    static _Ty _Cosh(_Ty _Left, _Ty _Right);

    static short _Exp(_Ty *_Pleft, _Ty _Right, short _Exponent);

    static _Ty _Infv(_Ty);

    static bool _Isinf(_Ty _Left);

    static bool _Isnan(_Ty _Left);

    static _Ty _Nanv(_Ty);

    static _Ty _Sinh(_Ty _Left, _Ty _Right);

    static _Ty atan2(_Ty _Yval, _Ty _Xval);

    static _Ty cos(_Ty _Left);

    static _Ty exp(_Ty _Left);

    static _Ty ldexp(_Ty _Left, int _Exponent);

    static _Ty log(_Ty _Left);

    static _Ty pow(_Ty _Left, _Ty _Right);

    static _Ty sin(_Ty _Left);

    static _Ty sqrt(_Ty _Left);

    static _Ty tan(_Ty _Left);

    };

针对_Ctraits类的特化版本有三个:

        // CLASS _Ctraits<long double>

template<> class _Ctraits<long double>;

        // CLASS _Ctraits<double>

template<> class _Ctraits<double>;

        // CLASS _Ctraits<float>

template<> class _Ctraits<float>;

然后定义了一个存储模板_Complex_value，用来为complex类提供存储结构：

        // TEMPLATE CLASS _Complex_value

template<class _Ty> struct _Complex_value

    {   /* templatized complex value */

    enum {_Re = 0, _Im = 1};

    _Ty _Val[2];

    };

实际上文件已开始提到的那三个结构体（_Dcomplex_value、_Fcomplex_value、_Lcomplex_value）可以看做是_Complex_value的三个特化版本。

再接下来是从_Complex_value结构派生出_Complex_base类，主要提供取实部和虚部以及加减乘除的基本运算的函数。_Complex_base有两个模板参数，其中_Ty是基本数据类型，如double、float，_Valbase是存储结构，如_Dcomplex_value、_Fcomplex_value。而且请注意这里有很重要的一点：_Complex_base继承自模板参数_Valbase。

        // TEMPLATE CLASS _Complex_base

template<class _Ty, class _Valbase> class _Complex_base : public _Valbase

    {   // base for all complex types

public:

    typedef _Ctraits<_Ty> _Myctraits;

    typedef _Complex_base<_Ty, _Valbase> _Myt;

    typedef _Ty value_type;

 

    _Complex_base(const _Ty& _Realval, const _Ty& _Imagval);

    _Ty real(const _Ty& _Right);

    _Ty imag(const _Ty& _Right);

    _Ty real() ;

    _Ty imag() const;

protected:

    template<class _Other> inline   void _Add(const complex<_Other>& _Right);

    template<class _Other> inline   void _Sub(const complex<_Other>& _Right);

    template<class _Other> inline   void _Mul(const complex<_Other>& _Right);

    template<class _Other> inline   void _Div(const complex<_Other>& _Right);

    };

接下来有点怪异，因为complex的定义被放在了complex的特化版本之后。这里就先讲complex模板的实现。complex类继承自_Complex_base类，并且已经实现成了只有一个模板参数_Ty，但是我们知道_Complex_base类有两个模板参数，此时先前定义的那个_Complex_value模板就有作用了。然后结合后面的complex特化版本定义，就验证了我之前说过的“文件已开始提到的那三个结构体（_Dcomplex_value、_Fcomplex_value、_Lcomplex_value）可以看做是_Complex_value的三个特化版本”是正确的，知识没有采用明显的模板定义。至于为什么，我还没有想明白。如果读者知道为什么请告诉我一声。

// TEMPLATE CLASS complex

template<class _Ty> class complex  : public _Complex_base<_Ty, _Complex_value<_Ty> >

    {   // complex with _Ty components

public:

    typedef complex<_Ty> _Myt;

    typedef _Complex_base<_Ty, _Complex_value<_Ty> > _Mybase;

 

    complex(const _Ty& _Realval = _Ty(), const _Ty& _Imagval = _Ty());

    _Myt& operator=(const _Ty& _Right);

    template<class _Other>  complex(const complex<_Other>& _Right);

    template<class _Other>  _Myt& operator=(const complex<_Other>& _Right);

    _Myt& operator+=(const _Ty& _Right);

    _Myt& operator-=(const _Ty& _Right);

    _Myt& operator*=(const _Ty& _Right);

    _Myt& operator/=(const _Ty& _Right);

    _Myt& operator+=(const _Myt& _Right);

    _Myt& operator-=(const _Myt& _Right);

    _Myt& operator*=(const _Myt& _Right);

    _Myt& operator/=(const _Myt& _Right);

    template<class _Other> inline _Myt& operator+=(const complex<_Other>& _Right);

    template<class _Other> inline _Myt& operator-=(const complex<_Other>& _Right);

    template<class _Other> inline _Myt& operator*=(const complex<_Other>& _Right);

    template<class _Other> inline _Myt& operator/=(const complex<_Other>& _Right);

    };

接下来是complex类的三个特化版本：

complex<float>、complex<double>、complex<long double>。

        // CLASS complex<float>

template<> class complex<float> : public _Complex_base<float, _Fcomplex_value>

    {   // complex with float components

public:

    typedef float _Ty;

    typedef complex<_Ty> _Myt;

    explicit complex(   const complex<double>&);    // defined below

    explicit complex(   const complex<long double>&);   // defined below

    complex(const _Ty& _Realval = 0, const _Ty& _Imagval = 0);

    complex(const _Fcomplex_value& _Right);

    complex(const _Dcomplex_value& _Right);

    complex(const _Lcomplex_value& _Right);

    complex<_Ty>& operator=(const _Ty& _Right);

    _Myt& operator+=(const _Ty& _Right);

    _Myt& operator-=(const _Ty& _Right);

    _Myt& operator*=(const _Ty& _Right);

    _Myt& operator/=(const _Ty& _Right);

    _Myt& operator+=(const _Myt& _Right);

    _Myt& operator-=(const _Myt& _Right);

    _Myt& operator*=(const _Myt& _Right);

    _Myt& operator/=(const _Myt& _Right);

    template<class _Other> inline   _Myt& operator=(const complex<_Other>& _Right);

    template<class _Other> inline   _Myt& operator+=(const complex<_Other>& _Right);

    template<class _Other> inline   _Myt& operator-=(const complex<_Other>& _Right);

    template<class _Other> inline   _Myt& operator*=(const complex<_Other>& _Right);

    template<class _Other> inline   _Myt& operator/=(const complex<_Other>& _Right);

    };

        // CLASS complex<double>

template<> class complex<double> : public _Complex_base<double, _Dcomplex_value>

    {   // complex with double components

public:

    typedef double _Ty;

    typedef complex<_Ty> _Myt;

    complex(    const complex<float>&); // defined below

    explicit complex(   const complex<long double>&);   // defined below

    complex(const _Ty& _Realval = 0,const _Ty& _Imagval = 0);

    complex(const _Dcomplex_value& _Right);

    complex(const _Lcomplex_value& _Right);

    complex<_Ty>& operator=(const _Ty& _Right);

    _Myt& operator+=(const _Ty& _Right);

    _Myt& operator-=(const _Ty& _Right);

    _Myt& operator*=(const _Ty& _Right);

    _Myt& operator/=(const _Ty& _Right);

    _Myt& operator+=(const _Myt& _Right);

    _Myt& operator-=(const _Myt& _Right);

    _Myt& operator*=(const _Myt& _Right);

    _Myt& operator/=(const _Myt& _Right);

    template<class _Other> inline   _Myt& operator=(const complex<_Other>& _Right);

    template<class _Other> inline   _Myt& operator+=(const complex<_Other>& _Right);

    template<class _Other> inline   _Myt& operator-=(const complex<_Other>& _Right);

    template<class _Other> inline   _Myt& operator*=(const complex<_Other>& _Right);

    template<class _Other> inline   _Myt& operator/=(const complex<_Other>& _Right);

    };

        // CLASS complex<long double>

template<> class complex<long double> : public _Complex_base<long double, _Lcomplex_value>

    {   // complex with long double components

public:

    typedef long double _Ty;

    typedef complex<_Ty> _Myt;

    complex(    const complex<float>&); // defined below

    complex(    const complex<double>&);    // defined below

    complex(const _Ty& _Realval = 0,const _Ty& _Imagval = 0);

    complex(const _Lcomplex_value& _Right);

    complex<_Ty>& operator=(const _Ty& _Right);

    _Myt& operator+=(const _Ty& _Right);

    _Myt& operator-=(const _Ty& _Right);

    _Myt& operator*=(const _Ty& _Right);

    _Myt& operator/=(const _Ty& _Right);

    _Myt& operator+=(const _Myt& _Right);

    _Myt& operator-=(const _Myt& _Right);

    _Myt& operator*=(const _Myt& _Right);

    _Myt& operator/=(const _Myt& _Right);

    template<class _Other> inline   _Myt& operator=(const complex<_Other>& _Right);

    template<class _Other> inline   _Myt& operator+=(const complex<_Other>& _Right);

    template<class _Other> inline   _Myt& operator-=(const complex<_Other>& _Right);

    template<class _Other> inline   _Myt& operator*=(const complex<_Other>& _Right);

    template<class _Other> inline   _Myt& operator/=(const complex<_Other>& _Right);

    };

    在<complex>文件的最后还针对输入输出流定义了complex类的<<和>>运算符。

        // TEMPLATE FUNCTION operator>>

template<class _Ty, class _Elem, class _Tr>

inline basic_istream<_Elem, _Tr>& operator>>

(basic_istream<_Elem, _Tr>& _Istr, complex<_Ty>& _Right);

        // TEMPLATE FUNCTION operator<<

template<class _Ty, class _Elem, class _Tr>

inline basic_ostream<_Elem, _Tr>& operator<<

(basic_ostream<_Elem, _Tr>& _Ostr, const complex<_Ty>& _Right);

有心的读者读到这里可能会发觉，我们找不到关于complex类的三角函数之类的运算。原来这些运算被定义在了<xcomplex>文件里。

#define _CMPLX(T)   complex<T >

#define _CTR(T) _Ctraits<T >

#define _TMPLT(T)   template<class T >

// TEMPLATE FUNCTION operator+

_TMPLT(_Ty) inline

_CMPLX(_Ty) operator+(const _CMPLX(_Ty)& _Left,  const _CMPLX(_Ty)& _Right);

_TMPLT(_Ty) inline

    _CMPLX(_Ty) operator+(const _CMPLX(_Ty)& _Left, const _Ty& _Right);

_TMPLT(_Ty) inline

    _CMPLX(_Ty) operator+(const _Ty& _Left, const _CMPLX(_Ty)& _Right);

        // TEMPLATE FUNCTION operator-

_TMPLT(_Ty) inline

    _CMPLX(_Ty) operator-(const _CMPLX(_Ty)& _Left, const _CMPLX(_Ty)& _Right);

_TMPLT(_Ty) inline

    _CMPLX(_Ty) operator-(const _CMPLX(_Ty)& _Left, const _Ty& _Right);

_TMPLT(_Ty) inline

    _CMPLX(_Ty) operator-(const _Ty& _Left, const _CMPLX(_Ty)& _Right);

        // TEMPLATE FUNCTION operator*

_TMPLT(_Ty) inline

    _CMPLX(_Ty) operator*(const _CMPLX(_Ty)& _Left, const _CMPLX(_Ty)& _Right);

_TMPLT(_Ty) inline

    _CMPLX(_Ty) operator*(const _CMPLX(_Ty)& _Left, const _Ty& _Right);

_TMPLT(_Ty) inline

    _CMPLX(_Ty) operator*(const _Ty& _Left, const _CMPLX(_Ty)& _Right);

        // TEMPLATE FUNCTION operator/

_TMPLT(_Ty) inline

    _CMPLX(_Ty) operator/(const _CMPLX(_Ty)& _Left, const _CMPLX(_Ty)& _Right);

_TMPLT(_Ty) inline

    _CMPLX(_Ty) operator/(const _CMPLX(_Ty)& _Left, const _Ty& _Right);

_TMPLT(_Ty) inline

    _CMPLX(_Ty) operator/(const _Ty& _Left, const _CMPLX(_Ty)& _Right);

        // TEMPLATE FUNCTION UNARY operator+

_TMPLT(_Ty) inline

    _CMPLX(_Ty) operator+(const _CMPLX(_Ty)& _Left);

        // TEMPLATE FUNCTION UNARY operator-

_TMPLT(_Ty) inline

    _CMPLX(_Ty) operator-(const _CMPLX(_Ty)& _Left);

        // TEMPLATE FUNCTION operator==

_TMPLT(_Ty) inline

    bool operator==(const _CMPLX(_Ty)& _Left, const _CMPLX(_Ty)& _Right);

_TMPLT(_Ty) inline

    bool operator==(const _CMPLX(_Ty)& _Left, const _Ty& _Right);

_TMPLT(_Ty) inline

    bool operator==(const _Ty& _Left, const _CMPLX(_Ty)& _Right);

        // TEMPLATE FUNCTION operator!=

_TMPLT(_Ty) inline

    bool operator!=(const _CMPLX(_Ty)& _Left, const _CMPLX(_Ty)& _Right);

_TMPLT(_Ty) inline

    bool operator!=(const _CMPLX(_Ty)& _Left, const _Ty& _Right);

_TMPLT(_Ty) inline

    bool operator!=(const _Ty& _Left, const _CMPLX(_Ty)& _Right);

        // TEMPLATE FUNCTION imag

_TMPLT(_Ty) inline

    _Ty imag(const _CMPLX(_Ty)& _Left);

        // TEMPLATE FUNCTION real

_TMPLT(_Ty) inline

    _Ty real(const _CMPLX(_Ty)& _Left);

        // TEMPLATE FUNCTION _Fabs

_TMPLT(_Ty) inline

    _Ty _Fabs(const _CMPLX(_Ty)& _Left, int *_Pexp);

        // TEMPLATE FUNCTION abs

_TMPLT(_Ty) inline

    _Ty abs(const _CMPLX(_Ty)& _Left);

        // TEMPLATE FUNCTION cosh

_TMPLT(_Ty) inline

    _CMPLX(_Ty) cosh(const _CMPLX(_Ty)& _Left);

        // TEMPLATE FUNCTION exp

_TMPLT(_Ty) inline

    _CMPLX(_Ty) exp(const _CMPLX(_Ty)& _Left);

        // TEMPLATE FUNCTION log

_TMPLT(_Ty) inline

    _CMPLX(_Ty) log(const _CMPLX(_Ty)& _Left);

        // TEMPLATE FUNCTION pow

_TMPLT(_Ty) inline

    _CMPLX(_Ty) pow(const _CMPLX(_Ty)& _Left, const _Ty& _Right);

_TMPLT(_Ty) inline

    _CMPLX(_Ty) pow(const _CMPLX(_Ty)& _Left, int _Right);

_TMPLT(_Ty) inline

    _CMPLX(_Ty) pow(const _Ty& _Left, const _CMPLX(_Ty)& _Right);

_TMPLT(_Ty) inline

    _CMPLX(_Ty) pow(const _CMPLX(_Ty)& _Left, const _CMPLX(_Ty)& _Right);

        // TEMPLATE FUNCTION sinh

_TMPLT(_Ty) inline

    _CMPLX(_Ty) sinh(const _CMPLX(_Ty)& _Left);

        // TEMPLATE FUNCTION sqrt

_TMPLT(_Ty) inline

    _CMPLX(_Ty) sqrt(const _CMPLX(_Ty)& _Left);

        // TEMPLATE FUNCTION tanh

_TMPLT(_Ty) inline

    _CMPLX(_Ty) tanh(const _CMPLX(_Ty)& _Left);

        // TEMPLATE FUNCTION arg

_TMPLT(_Ty) inline

    _Ty arg(const _CMPLX(_Ty)& _Left);

        // TEMPLATE FUNCTION conj

_TMPLT(_Ty) inline

    _CMPLX(_Ty) conj(const _CMPLX(_Ty)& _Left);

        // TEMPLATE FUNCTION cos

_TMPLT(_Ty) inline

    _CMPLX(_Ty) cos(const _CMPLX(_Ty)& _Left);

        // TEMPLATE FUNCTION log10

_TMPLT(_Ty) inline

    _CMPLX(_Ty) log10(const _CMPLX(_Ty)& _Left);

        // TEMPLATE FUNCTION norm

_TMPLT(_Ty) inline

    _Ty norm(const _CMPLX(_Ty)& _Left);

        // TEMPLATE FUNCTION polar

_TMPLT(_Ty) inline

    _CMPLX(_Ty) polar(const _Ty& _Rho, const _Ty& _Theta);

_TMPLT(_Ty) inline

    _CMPLX(_Ty) polar(const _Ty& _Rho);

        // TEMPLATE FUNCTION sin

_TMPLT(_Ty) inline

    _CMPLX(_Ty) sin(const _CMPLX(_Ty)& _Left);

        // TEMPLATE FUNCTION tan

_TMPLT(_Ty) inline

    _CMPLX(_Ty) tan(const _CMPLX(_Ty)& _Left);

转自网易博客  架构师之路

http://blog.163.com/lvan100@yeah/blog/static/68117214201251753754185/

http://blog.163.com/lvan100@yeah/blog/static/6811721420125175391253/


liuzhongsky
关注
  • 1
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
boost::multiprecision模块complex128相关的测试程序
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-19 307
boost::multiprecision模块complex128相关的测试程序实现功能C++实现代码 实现功能 boost::multiprecision模块complex128相关的测试程序 C++实现代码 #include <iostream> #include <complex> #include <boost/multiprecision/complex128.hpp> template<class Complex> void complex_num
C++实现复数Complex
everthing willl be ok
09-23 1113
用C++实现一个简单的复数类，主要涉及四个默认成员函数：（1）构造函数：在定义对象时初始化成员变量，函数名与类名相同，无返回值（void也不能有），对象实例化时系统自动调用（2）拷贝构造函数：是一种特殊的构造函数，它由编译器调用来完成一些基于同一类的其他对象的构建及初始化。（3）析构函数：析构函数并不是删除对象，而是在撤销对象的占用内存之前进行一些清理工作，函数运行结束时自动调用（4）运算符重载：...
C语言中complex.h的踩坑记录
CLARKYY的博客
03-29 3261
一段C语言,在matlab用MEX编译时出错， 报错：C2143: 语法错误: 缺 少“;”(在“*”的前面) C2059: 语法错误 typedef struct { size_t sz; size_t nele; float complex *arr; } VarCFloatComplexArray; 解决：提问后https://ask.csdn.net/questions/7410767，根据提示，看complex.h文件把问题中的float complex改为_C_float_comp
【C到C++】关于 Complex (复数类）
bandaoyu的note
08-15 1170
2012.8.15   complex库中的模板complex&lt;&gt;提供了一个复数（y=real+imagei）类型，它与其他数值类型兼容。     template &lt;class SCALAR&gt; class complex{    // ……methods private:    SCALAR x, y; }; 这使用户能够根据需要决定...
C/C++ 引用和指针的区别及使用场景
最新发布
Layman的博客
06-05 1004
引用是只有在C++中才存在的概念，C语言是没有引用的。定义：引用是变量的别名，换句话说，就是为其起一个外号。一旦引用被初始化为一个变量，就不能再被改变为另一个变量的引用。初始化：引用必须在定义时初始化，并且一旦初始化后，其值（即它所引用的变量）就不能再改变。解引用：引用不需要解引用操作符（如*），它直接表示它所引用的变量的值。赋值：通过引用可以修改它所引用的变量的值。内存：引用不占用额外的内存空间（除了它引用的变量本身的内存）。定义：指针是一个变量，其值为另一个变量的地址；初始化。
C++complex复数类
August的博客
03-31 9292
  复数是形如a+bi的数，复数由实部和虚部构成，在C++的模板库中由complex类，可以直接调用，包含在complex头文件中。
complex库 和 limits库 的简单使用
whyorwhnt的专栏
09-16 1073
complex库为STL中定义的复数库：http://zh.wikipedia.org/zh/Complex.h 以下代码截取改编自：http://www.cppblog.com/cuckoo03/articles/79699.html #include #include #include #include using namespace std; const double PI
C标准库源代码(学习C/C++必备)
04-09
C标准库源代码\COMPLEX C标准库源代码\CONIO.H C标准库源代码\CPRINTF.C C标准库源代码\CPUTS.C C标准库源代码\CREAT.C C 标准库源代码\CRT0.C C标准库源代码\CRT0DAT.C C标准库源代码\CRT0FP.C C标准库源代码\CRT0...
mhpfrvv.rar_数学计算_C/C++_
08-09
1. **基础数学运算**：C/C++提供了标准库`<math.h>`，包含各种基本数学函数，如平方根、指数、对数、三角函数等。例如，`sqrt()`用于求平方根，`pow()`用于计算幂次，`sin()`、`cos()`和`tan()`分别对应正弦、余弦和...
CTutorialOxford.rar_数学计算_C/C++_
08-11
5. **数学库函数**：C标准库中的`<math.h>`提供了大量数学函数，如平方根（sqrt）、指数（exp）、对数（log）、三角函数（sin、cos、tan）等。在C++中，`<cmath>`提供相同功能但符合C++命名规则。 6. **复数运算**...
Sound_localization.rar_C/C++_
08-12
6. **编程实践**：使用C/C++进行声源定位开发，需要熟悉标准库如`<math.h>`和`<complex>`，以及可能用到的开源库，如FFmpeg或SOX用于音频处理，OpenCV或PCL用于三维空间计算。 7. **实时性与效率**：考虑到声源定位...
145026.rar_界面编程_C/C++_
08-10
标题中的“145026.rar_界面编程_C/C++_"表明这是一个关于C或C++编程的项目，特别强调了界面编程。这通常意味着它可能是一个使用MFC（Microsoft Foundation Classes）或者Windows API来创建图形用户界面的应用程序。...
C++中的complex
xiaofeixia002X的博客
05-13 800
在 C++ 中，std::complex 是一个模板类，用于表示和操作复数。这个类是标准模板库（STL）的一部分，包含在 头文件中。std::complex 提供了一套丰富的功能，包括基本的算术运算、比较运算、数学函数等，使得处理复数成为一件简单而直接的事情。
c语言虚数变量,关于C语言中的Complex（复数类型）和imaginary（虚数类型）
weixin_34417272的博客
05-18 2310
关于C语言中的Complex(复数类型)和imaginary(虚数类型)其实这里的复数complex就是数学里的复数，包含实部和虚部两个部分，比如：x=2.1+6i，下面进行详细介绍。C99 新增了复数类型(_Complex)和虚数类型(_Imaginary)。简单来说，C99 提供了三种复数类型：float _Complex，double _Complex，和 long double _Comp...
C语言的complex.h库复数运算
热门推荐
du98看灯夜的博客
08-31 1万+
C支持复数的数学计算，复数Z可以在笛卡尔坐标表示为：Z=x+y*I；其中x和y是实数，I是虚数单位。数x被称为实部，数y为虚部。在c语言中，一个复数是有浮点类型表示的实部和虚部。两部分都具有相同的类型，无论是float，double或者long double。 float _complex：实虚都为float double _complex：实虚都为double long double _c...
C++面向对象之类complex详解
qq_40319799的博客
02-25 7671
类complex可作为入门C++面向对象的经典类。complex的原型是数学上的复数。我们都知道复数有实部和虚部。所以类complex有两个数据成员re, im。复数有加，减，乘，除，取反，求共轭等操作，类complex也有相对应的成员函数来实现这些操作。下面是类complex的定义和测试代码，已在vs测试过。 类complex的定义 //complex.h #ifndef _MYCOMP...
C++学习 Complex类
qq_47530834的博客
01-16 1122
C++面向对象高级编程
c++ 学习笔记（0) boost 环境搭建
jeason的博客
12-08 921
0 .获得boost 源码 并且编译 安装 [jeason@centos7 ~]$ git clone https://gitee.com/add358/boost.git Cloning into 'boost'... remote: Enumerating objects: 97421, done. remote: Total 97421 (delta 0), reused 0 (delta 0), pack-reused 97421 Receiving objects: 100% (97421/974
C++侯捷笔记-complex类
m0_64133049的博客
01-28 1448
c++侯捷面向对象高级程序笔记——complex类
c 虚数 运算 矩阵 库
05-14
C语言中的虚数运算可以通过使用复数类型以及相关的库函数来进行。在C标准库中，不含直接支持复数类型以及相关运算的函数，但常用的数学库如math.h和complex.h库中均提供了复数类型及相关的运算函数。 而在C语言中，我们同样可以使用矩阵库来进行矩阵相关的计算操作，如矩阵加减、矩阵乘法、矩阵求逆等。常用的矩阵库如Intel MKL库、BLAS库、LAPACK库等，它们均提供了高效的矩阵计算函数以及可移植的接口。 同时，我们也可以使用C语言中的结构体来表示矩阵，这样可以方便地进行矩阵的构建、访问以及运算操作。值得一提的是，在C++中还有Eigen库，它提供了高效的矩阵、向量运算及线性代数操作。 综上所述，C语言可以通过使用复数类型及相关的库函数来进行虚数运算，同时也可以使用矩阵库和结构体来实现矩阵计算。这些都为C语言中数学计算提供了丰富的支持，方便了我们进行数学计算相关的编程工作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值