# javascript实现复数

**Repository Path**: linwt0/complex

## Basic Information

- **Project Name**: javascript实现复数
- **Description**: 使用javascript实现复数运算，可以创建复数对象，以及进行复数的加、减、乘、除、取模、求共轭复数等基本运算。
- **Primary Language**: JavaScript
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2020-09-02
- **Last Updated**: 2020-12-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

 ### javascript实现复数

### Description
    创作背景：在设计音箱分频器，虽然在线可以输入参数生成电路图，然后在EDA进行电路仿真，但仿真没有覆盖20~20KHz扫描的频率特性图，
    为了能看到分频电路仿真的滤波图像，需要海量的计算，而电路中涉及到容抗和感抗引入复数的计算，非常复杂，而科学计算器不支持复数计算，
    原生javascript Math对象也没提复数运算的API，为了方便计算特意使用javasccript编写一个复数运算程序。

    使用javascript实现复数运算，可以创建复数对象，以及进行复数的加、减、乘、除、取模、求共轭复数等基本运算。
    
### 复数对象Complex
    Complex是一个复数对象，用来表示一个复数。复数对象Complex有三个基本属性，分别是r,i,s。比如1+2j，这样表示{ r: 1, i: 2, s: 'j' }

    r保存复数的实数部分，i保存复数的虚数部分，s保存复数的后缀。

    复数对象Complex有一个toString方法，toString方法能够将复数对象转化为字符串格式。

### 关于复数对象Complex的特殊定义
    1、复数对象后缀s的值是i或者j。通常数学上复数后缀是i,但在某领域中复数后缀是j，比如在电磁学上复数后缀为了与电流i区别开来选择j。
    
    2、不同后缀s的复数对象不能进行运算。
       demo：
        let a=ComplexType.set(1,1,'i')
        let b=ComplexType.set(1,1,'j')
        let result = ComplexType.sum(a,b)  // TypeError: suffix must be uniform, either i or j

    3、运算中如果全部参数是实数，则默认i作为复数后缀
        demo:
        let result = ComplexType.sum(10,5)
        console.log(result); // Complex { r: 15, i: 0, s: 'i' }
        console.log('10+5 toString:',result.toString(),'\n') //15
    

    3、处理复数虚部为0的情况。当复数虚部为0的时候，数学上复数变为实数，但满足程序的需要，在此数据类型仍然保留Complex对象类型，
       而非Number。比如1+0i，数学上直接是1了,但用复数对象Complex表示则是Complex { r: 1, i: 0, s: 'i' }

### 复数运算操作对象ComplexType提供的运算方法：
 
    * set:创建一个复数，返回值是一个Complex实例对象

        demo：创建z=1+1j

        const z = ComplexType.set(1,1,'j')
        console.log(z) // Complex { r: 1, i: 1, s: 'j' }
        console.log(z.toString()) // 1+j
        z.__proto__ === Complex.prototype  //true

     * sum:复数加法方法，返回参数中所有复数从左到右依次相加的值，返回值是一个Complex对象
    
        demo:(1+j)+(2+2j)

        let a =  ComplexType.set(1,1,'j')
        let b =  ComplexType.set(2,2,'j')

        result = ComplexType.sum(a,b)
        console.log(result); //Complex { r: 3, i: 3, s: 'j' }
        console.log(result.toString(),'\n') //3+3j

        console.log(result .__proto__ === Complex.prototype) // true

     * sub:复数减法方法，返回参数中所有复数从左到右依次相减的值，返回值是一个Complex对象
    
        demo1:(1+j)-(2+2j)

        let a =  ComplexType.set(1,1,'j')
        let b =  ComplexType.set(2,2,'j')

        let result = ComplexType.sub(a,b)
        console.log(result); //Complex { r: -1, i: -1, s: 'j' }
        console.log(result.toString(),'\n') //-1-j

        /******************************************************************/
        demo2:(1+j)-(2+2j)-(-2-2j)

        let a =  ComplexType.set(1,1,'j')
        let b =  ComplexType.set(2,2,'j')
        let c =  ComplexType.set(-2,-2,'j')

        let result = ComplexType.sub(a,b,c)
        console.log(result); //Complex { r: 1, i: 1, s: 'j' }
        console.log(result.toString(),'\n') //1+j

        console.log(result .__proto__ === Complex.prototype) // true

     * mul:复数乘法方法，返回参数中所有复数从左到右依次相乘的值，返回值是一个Complex对象
    
        demo:(1+j)*(2+2j)

        let a =  ComplexType.set(1,1,'j')
        let b =  ComplexType.set(2,2,'j')
   
        let result = ComplexType.mul(a,b)
        console.log(result); // Complex { r: 0, i: 4, s: 'j' }
        console.log(result.toString(),'\n') //4j

        console.log(result .__proto__ === Complex.prototype) // true


     * div:复数除法方法，返回参数中所有复数从左到右依次相除的值，返回值是一个Complex对象
    
        demo1: (8+8j)/4

        let a =  ComplexType.set(8,8,'j')

        let result = ComplexType.div(a,4)
        console.log(result); //Complex { r: 2, i: 2, s: 'j' }
        console.log(result.toString(),'\n') //2+2j

        console.log(result .__proto__ === Complex.prototype) // true

        /******************************************************************/
        demo2:[ (8+8j)/(2+2j) ] / 2j

        let a =  ComplexType.set(8,8,'j')
        let b =  ComplexType.set(2,2,'j')

        let result = ComplexType.div(a,b,2)
        console.log(result); //Complex { r: 2, i: 0, s: 'j' }
        console.log(result.toString(),'\n') //2


     * con:共轭复数方法，返回复数的共轭复数，返回值是一个Complex对象
   
        demo:(-3+4j)的共轭复数
    
        let result = ComplexType.con(b)
        console.log(b) // Complex { r: -3, i: 4, s: 'j' }
        console.log(result.toString(),'\n') //-3-4j

        console.log(result .__proto__ === Complex.prototype) // true

     * abs:复数模方法，返回复数的模，返回值是一个实数，Number类型。

        demo: |(-12+5j)|
    
        let result = ComplexType.abs(d)
        console.log(c) // Complex { r: -12, i: -5, s: 'j' }
        console.log(result.toString(),'\n') //  abs:  13

        console.log(Object.prototype.toString.call(result)) // [object Number]

        注：以上sum、sub、mul、div、con、abs方法的参数，既可以是复数，也可以是实数，如果输入的是实数，则会先把实数转化为复数对象
        才进行运算，这正是保留虚部为0的复数对象原因；既可以是两个，也可以是多个，但必须至少两个，不管参数有多少个一律从左往右依次运算。

### 如何使用complex
        引入complex.js文件即可使用