Java实现复数(二十一)

程序员文章站 2024-03-22 13:39:22

...

勿以恶小而为之，勿以善小而不为--------------------------刘备

劝诸君，多行善事积福报，莫作恶

上一章简单介绍了矩阵的加法，减法，乘法和转置(二十),如果没有看过,请观看上一章

一. 复数

关于数学中复数的概念和作用，可以百度搜索相关的内容。

把运算法则复制一下:

Java实现复数(二十一)

复数有两个属性，实部 real 和虚部 imag.

一.一复数模的大小 magnitude()

 /**
     *
     * @return 返回复数的大小
     */
    public double magnitude(){

        double d= Math.sqrt(this.real*this.real+this.imag*this.imag);
        //四位小数，并且去0
        return Double.valueOf(new BigDecimal(d).
                setScale(4, BigDecimal.ROUND_HALF_UP).stripTrailingZeros()
                .toString());
    }

一.二是否为纯虚数 pure()

/**
     *
     * @return 是否是纯虚数。 实部为0,虚部不为0,才是纯虚数
     */
    public boolean pure(){
        return pure(this);

    }

    /**
     *
     * @param other
     * @return 是否是纯虚数。 实部为0,虚部不为0,才是纯虚数
     */
    public static boolean pure(Complex other){
        if(other.getReal()==0&&other.getImag()!=0){
            return true;
        }
        return false;
    }

一.三是否为共轭复数 conjugate()

/**
     *
     * @return 是否是共轭复数。 实部相同，虚部互为相反数
     */
    public boolean conjugate(Complex other){

        return conjugate(this,other);
    }

    /**
     *
     * @param c1
     * @param c2
     * @return 是否是共轭复数。 实部相同，虚部互为相反数
     */
    public static boolean conjugate(Complex c1,Complex c2){
        if(c1.getReal()==c2.getReal()&&(c1.getImag()+c2.getImag())==0){
            return true;
        }
        return false;
    }

一.四复数加法 add()

/**
     *
     * @param other
     * @return 复数相加
     */
    public Complex add(Complex other){

        return add(this,other);
    }

    /**
     *
     * @param c1
     * @param c2
     * @return 静态方法，实现两个复数相加
     */
    public static Complex add(Complex c1,Complex c2){
        //新的实部
        double r=c1.getReal()+c2.getReal();
        //新的虚部
        double i=c1.getImag()+c2.getImag();
        //相加后的复数
        return new Complex(r,i);
    }

一.五复数的减法 substract()

/**
     *
     * @param other
     * @return 复数相减
     */
    public Complex substract(Complex other){

        return substract(this,other);
    }

    /**
     *
     * @param c1
     * @param c2
     * @return 静态方法，实现两个复数相减
     */
    public static Complex substract(Complex c1,Complex c2){
        //新的实部
        double r=c1.getReal()-c2.getReal();
        //新的虚部
        double i=c1.getImag()-c2.getImag();
        //相减后的复数
        return new Complex(r,i);
    }

一.六复数乘法 multiply ()

 /**
     *
     * @param other
     * @return 复数相乘
     */
    public Complex multiply(Complex other){

        return multiply(this,other);
    }

    /**
     *
     * @param c1
     * @param c2
     * @return 静态方法，实现两个复数相乘
     */
    public static Complex multiply(Complex c1,Complex c2){
        //新的实部
        double r=c1.getReal()*c2.getReal()-c1.getImag()*c2.getImag();
        //新的虚部
        double i=c1.getReal()*c2.getImag()+c1.getImag()*c2.getReal();
        //相乘后的复数
        return new Complex(r,i);
    }

一.七复数除法 divide()

/**
     *
     * @param other
     * @return 复数相除
     */
    public Complex divide(Complex other){

        return divide(this,other);
    }

    /**
     *
     * @param c1
     * @param c2
     * @return 静态方法，实现两个复数相除
     */
    public static Complex divide(Complex c1,Complex c2){

        //如果为0,表示除以0, 产生除0异常。
        if(c2.getReal()==0&&c2.getImag()==0){
            throw new ArithmeticException("除 0 异常");
        }

        //新的实部
        double r=(c1.getReal()*c2.getReal()+c1.getImag()*c2.getImag())/(c2.getReal()*c2.getReal()+c2.getImag()*c2.getImag());
        //新的虚部
        double i=(c1.getImag()*c2.getReal()-c1.getReal()*c2.getImag())/(c2.getReal()*c2.getReal()+c2.getImag()*c2.getImag());
        //相乘后的复数
        return new Complex(r,i);
    }

一.八复数比较是否相同 equals() 和hashcode()

/**
     *
     * @param o
     * @return  比较两个复数是否相同
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Complex complex = (Complex) o;
        return Double.compare(complex.real, real) == 0 &&
                Double.compare(complex.imag, imag) == 0;
    }

    @Override
    public int hashCode() {
        return Objects.hash(real, imag);
    }

一.九打印复数 toString()

 /**
     *
     * @return 打印展示复数
     */
    @Override
    public String toString() {
       StringBuilder sb=new StringBuilder();

       //保留四位小数，并且去0.
       String tempR=new BigDecimal(this.real).
               setScale(4, BigDecimal.ROUND_HALF_UP).stripTrailingZeros().toString();
       sb.append(tempR);


        //如果虚部为正，需要添加一个+号。 为-时，不需要添加

        if(this.imag>0){
            sb.append("+");
        }
        //如果为0,返回实部
        if(this.imag==0){

            return sb.toString();
        }
       //添加虚部， 复数后面的 i是固定的
        String tempI=new BigDecimal(this.imag).
                setScale(4, BigDecimal.ROUND_HALF_UP).stripTrailingZeros().toString();
        sb.append(tempI);
        sb.append("i");
       return sb.toString();
    }

二. 复数的汇总和测试

二.一复数类 Complex

package com.yjl.collection;

import java.math.BigDecimal;
import java.util.Objects;

/**
 * package: com.yjl.collection
 * className: Complex
 * Description: 数学中复数类
 *
 * @author : yuezl
 * @Date :2020/6/11 7:54
 */
public class Complex {

    /**
     * @param real 实部
     * @param imag 虚部
     */
    private double real;

    private double imag;

    public Complex() {

    }

    public Complex(double real, double imag) {
        this.real = real;
        this.imag = imag;
    }


    /**
     *
     * @return 返回复数的大小
     */
    public double magnitude(){

        double d= Math.sqrt(this.real*this.real+this.imag*this.imag);
        //四位小数，并且去0
        return Double.valueOf(new BigDecimal(d).
                setScale(4, BigDecimal.ROUND_HALF_UP).stripTrailingZeros()
                .toString());
    }

    /**
     *
     * @return 是否是纯虚数。 实部为0,虚部不为0,才是纯虚数
     */
    public boolean pure(){
        return pure(this);

    }

    /**
     *
     * @param other
     * @return 是否是纯虚数。 实部为0,虚部不为0,才是纯虚数
     */
    public static boolean pure(Complex other){
        if(other.getReal()==0&&other.getImag()!=0){
            return true;
        }
        return false;
    }

    /**
     *
     * @return 是否是共轭复数。 实部相同，虚部互为相反数
     */
    public boolean conjugate(Complex other){

        return conjugate(this,other);
    }

    /**
     *
     * @param c1
     * @param c2
     * @return 是否是共轭复数。 实部相同，虚部互为相反数
     */
    public static boolean conjugate(Complex c1,Complex c2){
        if(c1.getReal()==c2.getReal()&&(c1.getImag()+c2.getImag())==0){
            return true;
        }
        return false;
    }
    /**
     *
     * @param other
     * @return 复数相加
     */
    public Complex add(Complex other){

        return add(this,other);
    }

    /**
     *
     * @param c1
     * @param c2
     * @return 静态方法，实现两个复数相加
     */
    public static Complex add(Complex c1,Complex c2){
        //新的实部
        double r=c1.getReal()+c2.getReal();
        //新的虚部
        double i=c1.getImag()+c2.getImag();
        //相加后的复数
        return new Complex(r,i);
    }

    /**
     *
     * @param other
     * @return 复数相减
     */
    public Complex substract(Complex other){

        return substract(this,other);
    }

    /**
     *
     * @param c1
     * @param c2
     * @return 静态方法，实现两个复数相减
     */
    public static Complex substract(Complex c1,Complex c2){
        //新的实部
        double r=c1.getReal()-c2.getReal();
        //新的虚部
        double i=c1.getImag()-c2.getImag();
        //相减后的复数
        return new Complex(r,i);
    }

    /**
     *
     * @param other
     * @return 复数相乘
     */
    public Complex multiply(Complex other){

        return multiply(this,other);
    }

    /**
     *
     * @param c1
     * @param c2
     * @return 静态方法，实现两个复数相乘
     */
    public static Complex multiply(Complex c1,Complex c2){
        //新的实部
        double r=c1.getReal()*c2.getReal()-c1.getImag()*c2.getImag();
        //新的虚部
        double i=c1.getReal()*c2.getImag()+c1.getImag()*c2.getReal();
        //相乘后的复数
        return new Complex(r,i);
    }

    /**
     *
     * @param other
     * @return 复数相除
     */
    public Complex divide(Complex other){

        return divide(this,other);
    }

    /**
     *
     * @param c1
     * @param c2
     * @return 静态方法，实现两个复数相除
     */
    public static Complex divide(Complex c1,Complex c2){

        //如果为0,表示除以0, 产生除0异常。
        if(c2.getReal()==0&&c2.getImag()==0){
            throw new ArithmeticException("除 0 异常");
        }

        //新的实部
        double r=(c1.getReal()*c2.getReal()+c1.getImag()*c2.getImag())/(c2.getReal()*c2.getReal()+c2.getImag()*c2.getImag());
        //新的虚部
        double i=(c1.getImag()*c2.getReal()-c1.getReal()*c2.getImag())/(c2.getReal()*c2.getReal()+c2.getImag()*c2.getImag());
        //相乘后的复数
        return new Complex(r,i);
    }

    /**
     *
     * @param o
     * @return  比较两个复数是否相同
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Complex complex = (Complex) o;
        return Double.compare(complex.real, real) == 0 &&
                Double.compare(complex.imag, imag) == 0;
    }

    @Override
    public int hashCode() {
        return Objects.hash(real, imag);
    }

    /**
     *
     * @return 打印展示复数
     */
    @Override
    public String toString() {
       StringBuilder sb=new StringBuilder();

       //保留四位小数，并且去0.
       String tempR=new BigDecimal(this.real).
               setScale(4, BigDecimal.ROUND_HALF_UP).stripTrailingZeros().toString();
       sb.append(tempR);


        //如果虚部为正，需要添加一个+号。 为-时，不需要添加

        if(this.imag>0){
            sb.append("+");
        }
        //如果为0,返回实部
        if(this.imag==0){

            return sb.toString();
        }
       //添加虚部， 复数后面的 i是固定的
        String tempI=new BigDecimal(this.imag).
                setScale(4, BigDecimal.ROUND_HALF_UP).stripTrailingZeros().toString();
        sb.append(tempI);
        sb.append("i");
       return sb.toString();
    }

    /**
     *
     * @return 返回实部
     */
    public double getReal() {
        return real;
    }

    /**
     * 设置实部
     * @param real
     */
    public void setReal(double real) {
        this.real = real;
    }

    /**
     *
     * @return 返回虚部
     */
    public double getImag() {
        return imag;
    }

    /**
     *
     * @param imag 设置虚部
     */
    public void setImag(double imag) {
        this.imag = imag;
    }
}

二.二测试

package com.yjl.collection;

/**
 * package: com.yjl.collection
 * className: ComplexTest
 * Description: 请输入相应的描述
 *
 * @author : yuezl
 * @Date :2020/6/11 8:12
 */
public class ComplexTest {
    public static void main(String[] args) {

        //1. 第一个复数, 实部为2,虚部为7
        Complex c1=new Complex(2,7);
        //2. 第二个复数， 实部为3,虚部为-6
        Complex c2=new Complex(3,-6);
        //3. 第三个复数，实部为2，虚部为-7.
        Complex c3=new Complex(2,-7);

        //4. 第四个复数，看是否相同
        Complex c4=new Complex(2,7);
        System.out.println("c1打印输出:"+c1.toString());

        System.out.println(c1.toString()+"+"+c2.toString()+"="+Complex.add(c1,c2));
        System.out.println(c1.toString()+"-"+c2.toString()+"="+Complex.substract(c1,c2));
        System.out.println(c1.toString()+"*"+c2.toString()+"="+Complex.multiply(c1,c2));
        System.out.println(c1.toString()+"/"+c2.toString()+"="+Complex.divide(c1,c2));

        System.out.println(c3.toString()+"的大小模为:"+c1.magnitude());
        System.out.println(c3.toString()+"是否为纯虚函数:"+c1.pure());
        System.out.println(c1.toString()+"与"+c3.toString()+"是否为共轭复数:"+c1.conjugate(c3));
        System.out.println(c1.toString()+"与"+c4.toString()+"是否相同:"+c1.equals(c4));

    }
}

运行程序，控制台打印输出:

Java实现复数(二十一)

谢谢您的观看，如果喜欢，请关注我，再次感谢 !!!

相关标签： Java小知识点复数加法复数减法复数乘法复数除法实现复数

上一篇： strstr()函数实现

下一篇： HDFS 之 DataNode 核心知识点

Java实现复数(二十一)

一. 复数

一.一复数模的大小 magnitude()

一.二是否为纯虚数 pure()

一.三是否为共轭复数 conjugate()

一.四复数加法 add()

一.五复数的减法 substract()

一.六复数乘法 multiply ()

一.七复数除法 divide()

一.八复数比较是否相同 equals() 和hashcode()

一.九打印复数 toString()

二. 复数的汇总和测试

二.一复数类 Complex

二.二测试

Java实现复数(二十一)

自己实现“加减乘除”(java版本)

聚类算法之MST算法 java实现版本博客分类： java综合web算法算法averagelinkmst最短距离

java实现带头结点(head)的单向链表

循环双链表-JAVA语言实现

java实现循环双链表

Java数组实现双向链表

动手开发自己的mvc (系列) 博客分类： java综合实现自己的MVC

无头双向链表的相关操作（Java实现）

动手开发自己的mvc-1----实现初步的控制层，实现各种配置和资源获取博客分类：实现自己的MVCjava综合多线程java框架mvc

Java实现复数(二十一)

一. 复数

一.一 复数 模的大小 magnitude()

一.二 是否为纯虚数 pure()

一.三 是否为共轭复数 conjugate()

一.四 复数加法 add()

一.五 复数的减法 substract()

一.六 复数乘法 multiply ()

一.七 复数除法 divide()

一.八 复数比较是否相同 equals() 和hashcode()

一.九 打印复数 toString()

二. 复数的汇总和测试

二.一 复数类 Complex

二.二 测试

Java实现复数(二十一)

自己实现“加减乘除”(java版本)

聚类算法之MST算法 java实现版本 博客分类： java综合web算法 算法averagelinkmst最短距离

java实现带头结点(head)的单向链表

循环双链表-JAVA语言实现

java实现循环双链表

Java数组实现双向链表

动手开发自己的mvc (系列) 博客分类： java综合实现自己的MVC

无头双向链表的相关操作（Java实现）

动手开发自己的mvc-1----实现初步的控制层，实现各种配置和资源获取 博客分类： 实现自己的MVCjava综合 多线程java框架mvc

一.一复数模的大小 magnitude()

一.二是否为纯虚数 pure()

一.三是否为共轭复数 conjugate()

一.四复数加法 add()

一.五复数的减法 substract()

一.六复数乘法 multiply ()

一.七复数除法 divide()

一.八复数比较是否相同 equals() 和hashcode()

一.九打印复数 toString()

二.一复数类 Complex

二.二测试

聚类算法之MST算法 java实现版本博客分类： java综合web算法算法averagelinkmst最短距离

动手开发自己的mvc-1----实现初步的控制层，实现各种配置和资源获取博客分类：实现自己的MVCjava综合多线程java框架mvc