精华内容
下载资源
问答
  • public class Fushu2 {double ...//实部虚部public Fushu2(){}public Fushu2(double r,double i){this.real=r;this.imag=i;}double getreal(){return this.real;}double getimag(){return this.imag;}public Fus...

    public class Fushu2 {

    double real,imag;//实部和虚部

    public Fushu2(){}

    public Fushu2(double r,double i)

    {

    this.real=r;

    this.imag=i;

    }

    double getreal()

    {

    return this.real;

    }

    double getimag()

    {

    return this.imag;

    }

    public Fushu2 plus(Fushu2 num)

    {

    Fushu2 result=new Fushu2();

    result.real=this.real+num.real;

    result.imag=this.imag+num.imag;

    return result;

    }

    public Fushu2 jianfa(Fushu2 num)

    {

    Fushu2 result=new Fushu2();

    result.real=this.real-num.real;

    result.imag=this.imag-num.imag;

    return result;

    }

    boolean isEqual(Fushu2 a)

    {

    return(this.real==a.real&&this.imag==a.imag);

    }

    String ToString()

    {

    return this.real+"i+"+this.imag+"j";

    }

    public static void main(String arg[])

    {

    Fushu2 a=new Fushu2();

    Fushu2 b=new Fushu2(4,3);

    Fushu2 c=new Fushu2(2,1);

    System.out.println("a的值为:"+a.ToString());

    System.out.println("b的值为:"+b.ToString());

    System.out.println("c的值为:"+c.ToString());

    System.out.println();

    Fushu2 d=b.plus(c);

    Fushu2 e=b.jianfa(c);

    System.out.println("d的值为:"+d.ToString());

    System.out.println("e的值为:"+e.ToString());

    System.out.println("a的值为:"+a.ToString());

    System.out.println();

    System.out.println("d和e的值相等吗?:"+d.isEqual(e));

    }

    }

    展开全文
  • System.out.print("请输入第一个复数:"); String input = in.nextLine(); matf.toComplex(input); System.out.print("请输入第二个复数:"); input = in.nextLine(); mats.toComplex(input); Complex temp = new ...

    package Myjava;

    //import java.lang.

    //修复一小点输入不当导致崩溃

    import java.util.Scanner;

    public class Complex {

    double real ,virt;

    public static void main(String[] args) {

    // TODO 自动生成的方法存根

    var in = new Scanner(System.in);

    Complex matf = new Complex();

    Complex mats = new Complex();

    System.out.print("请输入第一个复数:");

    String input = in.nextLine();

    matf.toComplex(input);

    System.out.print("请输入第二个复数:");

    input = in.nextLine();

    mats.toComplex(input);

    Complex temp = new Complex();

    temp.copy(matf);

    System.out.println("模分别为:" + matf.mod() + "  " + mats.mod());

    if(matf.compareMod(mats)) {

    System.out.println("两数模相等");

    }else {

    System.out.println("两式模不等");

    }

    if(matf.compareSame(mats)) {

    System.out.println("两数相等");

    }else {

    System.out.println("两式不等");

    }

    temp.copy(matf);

    temp.add(mats);

    System.out.println("两式之和:" + temp.toString());

    temp.copy(matf);

    temp.sub(mats);

    System.out.println("(1):" + matf.toString() + "减 (2):" + mats.toString() + "值为:" + temp.toString());

    temp.copy(mats);

    temp.sub(matf);

    System.out.println("(2):" + mats.toString() + "减 (1):" + matf.toString() + "值为:" + temp.toString());

    }

    public void copy(Complex value) {

    this.real = value.real;

    this.virt = value.virt;

    }

    public String toString() {

    String flag = "+";

    if (this.virt < 0) {

    flag = "";

    }

    return (this.real + flag + this.virt + "i");

    }

    public void print() {

    String flag = "+";

    if (this.virt < 0) {

    flag = "";

    }

    System.out.println(this.real + flag + this.virt + "i");

    }

    public void toComplex(String str) {

    this.real = 0;

    this.virt = 0;

    str = str.replaceAll(" ","");

    //System.out.println("old" + str);

    str = str.toLowerCase();

    //System.out.println("old" + str);

    String temp = str;

    int indexSub = temp.indexOf("-", 1);

    int indexAdd = temp.indexOf("+", 1);

    if(indexSub != -1 || indexAdd != -1) {

    //有两个部分

    if (indexSub > indexAdd) {

    indexAdd = indexSub;

    }

    //分离虚实两部分

    str = temp.substring(0,indexAdd);

    temp = temp.substring(indexAdd,temp.length());

    }else {

    //只有一个部分

    temp = "0";

    }

    String strs[] = {str,temp};

    //System.out.println("STRS:" + temp + str);

    for (String retval: strs) {

    if((retval.length() == 2 && retval.charAt(1) == 'i') ) {

    retval = retval.charAt(0) + "1i";

    }

    if ((retval.length() == 1 && retval.charAt(0) == 'i')) {

    retval =  "1i";

    }

    if (retval.charAt(retval.length() - 1) == 'i') {

    this.virt = virt + Double.valueOf(retval.substring(0,retval.length() - 1));

    }else {

    this.real = real + Double.valueOf(retval);

    }

    }

    //System.out.print("mat:" + real + "+" + virt + 'i');

    }

    public void add(Complex value) {

    this.real += value.real;

    this.virt += value.virt;

    }

    public void sub(Complex value) {

    this.real -= value.real;

    this.virt -= value.virt;

    }

    public boolean compareMod(Complex value) {

    if (this.mod() != value.mod()) {

    return false;

    }

    return true;

    }

    public boolean compareSame(Complex value) {

    if (this.mod() != value.mod()) {

    return false;

    }else if(this.real != value.real){

    return false;

    }

    return true;

    }

    public float mod() {

    return (float) Math.sqrt(this.real * real + virt * virt);

    }

    }

    展开全文
  • } public boolean equls(Complextest other) { System.out.print("是否相等:"); return this==other||Math.abs(this.real-other.real)(this.vir-other.vir); } public void diff(Complextest other)//减法 { float ...

    实名感谢尚梦川大佬教会我正则表达式!!!!!!!!!!!!!!!!!!!!!!!!!!

    输入的必须是正确答案,主要是尝试正则表达式。 看不懂的童邪慎用。优化也不是特别好,但是看懂了比较舒服。

    有错误欢迎指正

    import java.util.Scanner;

    import java.util.regex.Matcher;

    import java.util.regex.Pattern;

    public class Complextest {

    public float real,vir;

    public static int count=0;

    public static String Input()

    {

    Scanner in = new Scanner(System.in);

    count++;

    System.out.println("请输入第"+count+"个复数:");

    String res= in.next();

    return res;

    }

    public Complextest (String str)

    {

    if(str.equals("i")||str.equals("+i"))

    {

    this.real=0;

    this.vir =1;

    }

    else if(str.equals("-i"))

    {

    this.real=0;

    this.vir =-1;

    }

    else{

    String a = "^([-+]?)(\\d+|\\d+\\.\\d+)$";//只有实部的匹配

    String bi =   "^([-+]?)(\\d+|\\d+\\.\\d+)?(i+)$";//只虚部的匹配

    String a_bi = "^([-+]?)(\\d+|\\d+\\.\\d+)([-+]+)(\\d+|\\d+\\.\\d+)(i+)$";//都有

    String a_i =  "^([-+]?)(\\d+|\\d+\\.\\d+)([-+]+)(i+)$";

    Pattern fora = Pattern.compile(a);

    Pattern forbi = Pattern.compile(bi);

    Pattern fora_bi = Pattern.compile(a_bi);

    Pattern fora_i = Pattern.compile(a_i);

    Matcher toa= fora.matcher(str);

    Matcher tobi= forbi.matcher(str);

    Matcher toa_bi= fora_bi.matcher(str);

    Matcher toa_i= fora_i.matcher(str);

    if(toa_i.find())//([-+]?)(\\\\d+|\\\\d+\\\\.\\\\d+)([-+]+)(i+)

    {

    this.real = Float.parseFloat(toa_i.group(1)+toa_i.group(2));

    this.vir = 1;

    if(toa_i.group(3).equals("-"))

    {

    this.vir*=-1;

    }

    }

    if(toa.find())//只匹配实部

    {

    this.real = Float.parseFloat(toa.group(0));

    this.vir = 0;

    }else if(tobi.find())//只匹配虚部"([-+]?)(\\d+|\\d+\\.\\d+)(i+)";

    {

    this.real=0;

    this.vir=Float.parseFloat(tobi.group(1)+tobi.group(2));

    }

    if(toa_bi.find())//([-+]?)(\\d+|\\d+\\.\\d+)([-+]+)(\\d+|\\d+\\.\\d+)(i+)

    {

    this.real = Float.parseFloat(toa_bi.group(1)+toa_bi.group(2));

    if(toa_bi.group(4).length()==0)

    {

    this.vir=1;

    if(toa_bi.group(3)=="+")

    {

    this.vir*=-1;

    }

    }else {

    this.vir=Float.parseFloat(toa_bi.group(3)+toa_bi.group(4));

    }

    }

    }

    System.out.print("你输入的复数:");

    sayResult(this.real,this.vir);

    }

    public void add(Complextest other)//加法

    {

    float sum_Real,sum_Vir;

    sum_Real=this.real+other.real;

    sum_Vir=this.vir+other.vir;

    System.out.print("和:");

    sayResult(sum_Real,sum_Vir);

    }

    public void lenth(Complextest other)//长度

    {

    float x_len,y_len;

    x_len=this.real-other.real;

    y_len=this.vir-other.vir;

    System.out.println("长度是"+String.format("%.2f", Math.sqrt(x_len*x_len+y_len*y_len)));

    }

    public boolean equls(Complextest other)

    {

    System.out.print("是否相等:");

    return this==other||Math.abs(this.real-other.real)<0.001&&Math.abs(this.vir-other.vir)<0.001;

    }

    public void diff(Complextest other)//减法

    {

    float diff_Real,diff_Vir;

    diff_Real=this.real-other.real;

    diff_Vir=this.vir-other.vir;

    System.out.print("差:");

    sayResult(diff_Real,diff_Vir);

    }

    public void sayResult(float Real_,float Vir_)

    {

    StringBuffer put = new StringBuffer();

    String str=String.valueOf(Real_);

    if(Real_!=0)//实部存在

    {

    put.append(str);

    if(Vir_!=0)//等于0就不管

    {

    if(Vir_>0)

    {

    if(Vir_==1)//虚部为1

    {

    put.append("+i");

    }else {

    put.append("+"+Vir_+"i");

    }

    } else if(Vir_<0)

    {

    if(Vir_==-1)//虚部为-1

    {

    put.append("-i");

    }else {

    put.append(Vir_+"i");

    }

    }

    }

    }else//不存在实部

    {

    if(Vir_!=0)//只有虚部

    {

    if(Vir_==-1)

    {

    put.append("-i");

    }else if(Vir_==1)

    {

    put.append("i");

    }else

    {

    put.append(Vir_+"i");

    }

    }else//虚部都没有

    {

    put.append("0");

    }

    }

    System.out.println(put);

    }

    public static void main(String[] args) {

    String str;

    str = Input();

    Complextest first = new Complextest(str);

    str = Input();

    Complextest second = new Complextest(str);

    first.add(second);

    first.diff(second);

    first.lenth(second);

    System.out.println(first.equls(second));

    }

    }

    展开全文
  • 我们把形如z=a+bi(a,b均为实数)的数称为复数,其中a称为实部,b称为虚部,i称为虚数单位。当z的虚部等于零时,常称z为实数;...即两个实部相等虚部互为相反数的复数互为共轭复数(conjugate complex number)。 p...

    我们把形如z=a+bi(a,b均为实数)的数称为复数,其中a称为实部,b称为虚部,i称为虚数单位。当z的虚部等于零时,常称z为实数;当z的虚部不等于零时,实部等于零时,常称z为纯虚数。复数域是实数域的代数闭包,即任何复系数多项式在复数域中总有根。
    对于复数 ,称复数 =a-bi为z的共轭复数。即两个实部相等,虚部互为相反数的复数互为共轭复数(conjugate complex number)。

    print("实部:%s"%(x.real))
    print("虚部:%s"%(x.imag))
    print("模:%s"%(abs(x)))
    print("共轭复数:%s"%(x.conjugate()))
    
    
    展开全文
  • 复数是 a+bi 形式的数,其中 a 和 b 是真数,在 C++ 代码中是浮点值,i 是根号 -1。a 被称作复数的实数部分,b 乘以 i 被称作虚数部分。使用复数的程序一般都很专业,例如,复数可以用于电气和电磁理论、数字信号...
  • 数字类型

    2020-12-04 22:05:06
    Python支持复数复数由实数部分和虚数部分构成,可以用a + bj,或者complex(a,b)表示, 复数实部a和虚部b都是浮点型。 数字类型转换 int(x) 将x转换为一个整数。 float(x) 将x转换为一个浮点数。 complex(x)将x...
  • 一个定义了复数运算以及运算符重载的工程,相比课本上的要更加高效和简洁
  • 【其它】复数类的定义 声明复数类Complex,成员变量包括double类型的实部real和double类型的虚部im,请定义如下成员方法: 1、两个构造方法: Complex(double real, double im); Complex(),该无参构造方法内部用 this(0,...
  • 振动冲击

    千次阅读 2018-12-08 00:20:19
    频率响应分析主要用于计算结构在周期振荡载荷作用下对每一个计算频率的动...就这涉及到一个问题:我们什么时候用实部虚部,什么时候用幅值和相位。 通常,振动噪声信号是由一个或多个正弦信号叠加而成,因而,这些...
  • 用java语言编写一个复数类,要求有实部虚部,实现复数加法减法和比较运算
  • 复数

    千次阅读 2019-04-30 14:14:44
    我们把形如z=a+bi(a,b均为实数)的数称为复数,其中a称为实部,b称为虚部,i称为虚数单位。当虚部等于零时,这个复数可以视为实数;当z的虚部不等于零时,实部等于零时,常称z为纯虚数。复数域是实数域的代数闭包...
  • 信号复数及希尔伯特变换的理解

    千次阅读 2021-03-17 11:31:02
    一般的硬件电路都不支持复数运算,一般的方法是把实部虚部分别方在不同的存储区域,运算的时候分别按照实虚部运算!对此,复数只是再学习过程中的一个概念,我们可以在做理论(比如在纸上推导公式)的时候使用,到...
  • c++复数类Complex的编写

    千次阅读 2017-07-17 22:35:36
    复数:由实部虚部组成。主要实现几个运算符的重载:=/==/+/-/+=/-+/前置++/前置–/后置++/后置–主要实现代码如下:头文件Complex.h 函数声明和类定义#include #pragma onceclass Complex { public: Complex...
  • java怎么定义复数

    2021-02-12 10:02:32
    java创建一个复数类complex,对复数进行数学运算,复数具有如下格式:RealPart+ImaginaryPart*i,其中,i为-1的平方根,具体要求如下:(1)...(3)按格式(a,b)打印复数,其中a为实部,b为虚部。Java代码如下:pub...
  • Java实现的复数

    2019-02-20 14:20:30
    Java实现的复数
  • 两个属性:实部x和虚部y 默认构造函数 Complex(),设置x=0,y=0 构造函数:Complex(int i,int j) 显示复数的方法:showComp()将其显示为如: 5+8i或5-8i 的形式。 求两个复数的和的方法:(参数是两个复数类对象...
  • Java声明复数类Complex

    千次阅读 2020-03-24 07:34:42
    声明复数类Complex,成员变量包括实部虚部,成员方法包括实现由字符串构造复数复数加法、减法,字符串描述、比较相等、计算复数的模等操作。 百度百科—对复数的介绍 import java.util.Scanner; public class ...
  • 一个复数类的C++代码 包含运算符重载 加减乘除 注释详细 适合刚开始学类的C++学生
  • 本文实例讲述了Python复数属性和方法运算操作。分享给大家供大家参考,具体如下:#coding=utf8'''''复数是由一个实数和一个虚数组合构成,表示为:x+yj一个负数时一对有序浮点数(x,y),其中x是实数部分,y是虚数部分...
  • get_real() 返回复数实部 get_imag() 返回复数虚部 show() 用于输出复数。要求以 3 + 4i , 3 - 4i 这样的形式输出 add() 用于把一个复数加到自身,比如 c1.add(c2) ,相当于 c1 += c2 友
  • 【单选题】该零件视图中,基本视图的个数为【单选题】急性肾衰竭少尿或无尿期,需紧急处理的为:【判断题】图中尺寸Φ 的基本偏差是上极限偏差。【多选题】下列物质是极性化合物...【判断题】在柱塞泵装配图中,序号1...
  • 5.1.1整数 - 数学中整数概念一致,没有取值范围限制,可正可负 -pow(x,y)函数:计算 xy,想算多大算多大 -四种进制表示形式: 十进制:1010, 99, -217 二进制,以0b或0B开头:0b010, -0B101 八进制,以0o或0O...
  • 模拟复数及其运算

    2015-01-10 13:58:00
    复数实部与虚部的 平方 和的正的 平方根 的值称为该复数的模,记作 ∣ z ∣ .  即对于复数 z=a+bi ,它的模  ∣ z ∣ = √ ( a^2+b^2) 棣莫佛定理 对于复数 z=r(cos θ +isin θ ),有 z 的 n 次幂...
  • Opencv数据类型(四):复数Complex类

    千次阅读 2019-12-24 20:28:18
    文章目录1、共轭复数介绍2、Opencv复数类介绍3、举例 1、共轭复数介绍 摘自 百度百科 复数介绍...当虚部不为零时,共轭复数就是实部相等虚部相反,如果虚部为零...
  • python里的复数complex

    2020-12-04 22:06:49
    复数是一个数学概念,包含了实部虚部。在python设计语言中,可以直接定义以j为单位...↓ 获取复数x的实部,使用x.real,获取复数x的虚部,使用x.imag 共轭复数: 两个实部相等虚部互为相反数的复数互为共轭复数...
  • 详细展示了如何定义类的成员及友元函数,以及各运算符重载的方法
  • //9、定义一个复数类,并通过定义运算符重载实现两个复数可以判别是否相等(==),并给出主函数应用该类。 #include"iostream" #include"iomanip" using namespace std; class Complex { private: int real,iamg; ...
  • 复数

    2017-05-09 01:55:32
    复数类:(1)由于默认的拷贝构造函数以值拷贝的方式一个一个拷贝的,此处的复数类,用值拷贝不会出错,所以不写,直接用默认的成员函数; (2)赋值运算符重载也是用默认的成员函数; (3)注意使用传引用能使...
  • 复数的基本概念

    千次阅读 2016-06-02 09:59:22
    概念 虚数单位:i2=−1i^2 = -1 复数的代数形式:z=a+biz = a + bi 复数的模:|z|=|a+bi|=a2+b2−...复数不能比较大小复数的运算 加减:(a+bi)±(c+di)=(a±c)+(b±d)i(a + bi) \pm (c + di) = (a \pm c) + (b \pm
  • 目录 一、复数类的生成 1、初始化复数 2、生成以及提取复数的相关方法 3、复数的显示 ...二、复数的相关运算 ...所以我们定义复数实部虚部为double 类型的real和vir,且由于我们作为一个复数类工具,我...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,501
精华内容 1,400
关键字:

复数实部与虚部相等