java复数四则运算
JAVA_实现两个复数的四则运算
JAVA_实现两个复数的四则运算1、⼀个复数类Complex由两部分组成：实部real和虚部imaginary，两个复数可以进⾏加减乘除四则运算。
试设计这个复数类，然后在另⼀个类的程序⼊⼝演⽰。
public class Test {public static void main(String[] args) {// 定义两个对象并赋值：c1(a+bi)=(2+4i),c2=(c+di)=(6+16i)Complex c1=new Complex();c1.real=2;c1.imaginary=4;Complex c2=new Complex();c2.real=6;c2.imaginary=16;// 以字符串的⽅式输出：采⽤标准格式输出，即a+biSystem.out.println("两个复数相加得："+c1.add(c2));// 在每次调⽤并运算（此时real值发⽣变化）之后，再重新赋值：c1.real=2;c1.imaginary=4;System.out.println("两个复数相减得："+c1.sub(c2));c1.real=2;c1.imaginary=4;System.out.println("两个复数相乘得："+c1.mul(c2));c1.real=2;c1.imaginary=4;System.out.println("两个复数相除得："+c1.div(c2));}}class Complex{double real;double imaginary;//最后以字符串输出的格式：//1.虚部为正值时，实部+"+"+虚部+"i" 2.虚部为0时，只有实部，即实部+"" 3.虚部为负值时，实部+""+虚部+"i" // 加法，减法：直接实部加减实部，虚部加减虚部String add(Complex c){if(imaginary+c.imaginary>0)return (real=real+c.real)+"+"+(imaginary=imaginary+c.imaginary)+"i";else if(imaginary+c.imaginary==0)return (real=real+c.real)+"";elsereturn (real=real+c.real)+""+(imaginary=imaginary+c.imaginary)+"i";}String sub(Complex c){if(imaginary-c.imaginary>0)return (real=real-c.real)+"+"+(imaginary=imaginary-c.imaginary)+"i";else if(imaginary-c.imaginary==0)return (real=real-c.real)+"";elsereturn (real=real-c.real)+""+(imaginary=imaginary-c.imaginary)+"i";}// 乘法的公式：(a+bi)*(c+di) = a*c + bi*c + a*di + bi*di = a*c + (b*d)(i^2) + (b*c+a*d)i// 注：此处的i^2直接赋值-1，即 return a*c-b*d+(b*c+a*d)iString mul(Complex c){if(imaginary*c.real+real*c.imaginary>0)return (real*c.real)-(imaginary*c.imaginary)+"+"+(imaginary*c.real+real*c.imaginary)+"i";else if(imaginary*c.real+real*c.imaginary==0)return (real*c.real)-(imaginary*c.imaginary)+"";elsereturn (real*c.real)-(imaginary*c.imaginary)+""+(imaginary*c.real+real*c.imaginary)+"i";}// 除法的公式：(a+bi)/(c+di) = (a+bi)*(c-di) / c^2+d^2// 注：在乘法的基础上得到格式A+Bdi，再进⾏A /c^2+d^2，B /c^2+d^2 + "i"String div(Complex c){if(imaginary*c.real-real*c.imaginary>0)return ((real*c.real)+(imaginary*c.imaginary))/(c.real*c.real+c.imaginary*c.imaginary)+"+"+(imaginary*c.real-real*c.imaginary)/(c.real*c.real+c.imaginary*c.imaginary)+"i";else if(imaginary*c.real-real*c.imaginary==0)return ((real*c.real)+(imaginary*c.imaginary))/(c.real*c.real+c.imaginary*c.imaginary)+"";elsereturn ((real*c.real)+(imaginary*c.imaginary))/(c.real*c.real+c.imaginary*c.imaginary)+""+(imaginary*c.real-real*c.imaginary)/(c.real*c.real+c.imaginary*c.imaginary)+"i";}}/*Complex c1=new Complex();c1.real=2;c1.imaginary=4;Complex c2=new Complex();c2.real=6;c2.imaginary=16;即：c1=2+4ic2=6+16i数学运算结果：两者相加：8+20i两者相减：-4-12i两者相乘：-52+56i(2+4i)*(6+16i)两者相除：0.2602739726027397-0.0273972602739726i(2+4i)/(6+16i)=(2+4i)*(6-16i)/(6*6+16*16)*/。
Java复数运算
Java复数运算描述创建⼀个复数类Complex,⽤来执⾏复数的算数运算，并编写⼀个程序来测试该类。
（1）该类有两个成员变量，即实部(realPart)和虚部(imaginaryPart)，均为实数类型（2）定义⼀个构造函数，⽤来对类的对象进⾏初始化，构造函数的函数原理为：Complex(double realPart,double imaginaryPart);（3）定义⼀个add成员函数，实现两个复数的加法Complex add(Complex);（4）定义⼀个sub成员函数，实现两个复数的减法Complex sub(Complex);（5）定义⼀个mul成员函数，实现两个复数的乘法Comple mul(Complex);（6）定义⼀个div成员函数，实现两个复数的除法Complex div(Complex);（7）定义⼀个print成员函数，打印当前复数运算结果，打印格式为：3.0+2.0i或-3.0-2.0i测试⽤的main函数如下：public static void main(String[] a) {Scanner input = new Scanner(System.in);int x1,y1,x2,y2;x1=input.nextInt();y1=input.nextInt();x2=input.nextInt();y2=input.nextInt();Complex c1 = new Complex(x1, y1);Complex c2 = new Complex(x2, y2);Complex c3=c1.add(c2);Complex c4=c1.sub(c2);Complex c5=c1.mul(c2);Complex c6=c1.div(c2);c3.print();c4.print();c5.print();c6.print();}输⼊输⼊占1⾏，分别是4个整数，⽤来构造两个复数输出输出占4⾏，分别为两个复数运算后的结果。
java解析四则运算为树形的方法_概述及解释说明
java解析四则运算为树形的方法概述及解释说明1. 引言1.1 概述：本文将讨论Java解析四则运算为树形结构的方法。
四则运算是数学中最基础的运算，包括加法、减法、乘法和除法。
通过对四则运算表达式进行解析，可以将其转化为树形结构，以提供更方便的处理和计算方式。
在本文中，我们将介绍四则运算及其解析方式的简介，并重点关注树形结构在这种解析中的应用。
1.2 文章结构：本文共分为5个部分：引言、正文、解释说明、结论和后记。
在引言部分，我们将给出文章的概述，简述整篇文章的内容与目标。
在正文部分，我们将详细介绍四则运算及其解析方式的简介，并探究树形结构在这种解析中的作用。
在解释说明部分，我们会阐述将四则运算表达式转化为树形结构的基本概念和原理，并讨论Java中实现这一过程的方法。
接着，我们还会探讨树形结构在四则运算解析中的优势和应用场景。
在结论部分，我们将总结文章要点和重点论述内容，并对Java解析四则运算为树形的方法进行评价并展望未来的发展方向。
最后，在后记部分，我们将留下一些附加信息和感想。
1.3 目的：本文的目的是提供一个全面且易懂的解析四则运算为树形结构的方法，并探讨这种方法在Java中的应用。
通过深入了解四则运算的解析和树形结构的应用，读者可以更好地理解并使用这些技术，进一步提高程序设计和算法实现能力。
本文还旨在为Java开发者提供一个可靠而有效的工具，以便于他们处理复杂的四则运算表达式。
跟随本文学习并实践这种方法可以增强编码技巧和培养抽象思维能力，在日常开发中收获不少益处。
2. 正文:2.1 四则运算及其解析方式简介:在数学中，四则运算指的是加法、减法、乘法和除法这四种基本运算。
它们是最常见和基础的数学运算，广泛应用于各个领域。
在计算机科学中，我们通常需要将四则运算表达式进行解析，以便计算机能够理解和执行。
2.2 树形结构在四则运算解析中的应用:树形结构是一种非常适合表示嵌套层次关系的数据结构。
四则运算代码（java版本）采用正则表达式
四则运算代码（java版本）采⽤正则表达式//加减乘除负数、括号这⼏种//具体看代码以及注释 (测试没发现bug，如发现有bug 请指正)package com.test;import java.util.ArrayList;import java.util.List;import java.util.regex.Matcher;import java.util.regex.Pattern;/*** 四则运算，可能不是最优的写法，⾃⼰测试没发现bug<br>* 前提：正确的算式,因为没做算式的验证<br>* 思路：<br>* 1、⽤正则拆分所有的元素例⼦：2-5+4*5/(2+2)-4<br>* 拆分为【2,-5,4,*,5,/,(,2,2,),-4】<br>* 2、先计算括号⾥，乘除，最后加减** 总结：总体花了17、8个⼩时，主要原因还是没有仔细总体分析流程导致。
<br>* 以⾄于想到点写点代码、修修改改，没有⼀个完整的把握的思路。
所以⼀个问题⼀定<br>* 先⾛通整个思路、流程其实编码是最容易的，重点是处理的过程思路** @author wangshiyan* @time 2014-12-4 下午12:50:01**/public class SizheTool {public static void main(String[] args) {try {System.out.println(jisuanStr("11.2+3.1*(423-(2+5.7*3.4)+5.6)-6.4/(15.5+24)"));} catch (Exception e) {System.out.println("请检查你的算式格式");e.printStackTrace();}}/*** 拆分算式⾥的各个元素并处理对应所在位置<br>** @param str* @return*/public static List<String> splitStr(String string) throws Exception {List<String> listSplit = new ArrayList<String>();Matcher matcher = pile("\\-?\\d+(\\.\\d+)?|[*/()]|\\-").matcher(string);// ⽤正则拆分成每个元素while (matcher.find()) {// System.out.println(matcher.group(0));listSplit.add(matcher.group(0));}return listSplit;}/*** 计算<br>* 步骤：1、如果有括号<br>* 然后取上⼀个最近的(坐标计算当前括号组合⾥的算式），在继续往下查找括号以此类推,直⾄循环使⽤到所有坐标元素* 计算完毕（运算顺序括号、乘除、加减）** @param str* @return*/public static double jisuanStr(String str) throws Exception {double returnDouble = 0;List<String> listSplit = splitStr(str); // 拆分好的元素List<Integer> zKuohaoIdxList = new ArrayList<Integer>();// 左括号,<所在坐标，>if (pile(".*\\(|\\).*").matcher(str).find()) {// 如果包含括号运算String value = "";// 单个字符值int zIdx = 0;// 上⼀个左括号在zKuoHaoIdxList的下标// 此层循环计算完所有括号⾥的算式List<String> tempList = new ArrayList<String>();// 前⾯没有计算的元素int removeL = 0;int tempListSize = 0;for (int i = 0; i < listSplit.size(); i++) {value = listSplit.get(i);tempList.add(value);tempListSize = tempList.size();if ("(".equals(value)) {// 左括号zKuohaoIdxList.add(tempListSize-1);} else if (")".equals(value)) {// 遇到右括号就计算与上⼀左括号间的算式zIdx = zKuohaoIdxList.size() - 1;// 离当前右括号最近的左括号配对int start = zKuohaoIdxList.get(zIdx);returnDouble = jisuan(tempList, start + 1, tempListSize-1); // 开始位置,就是上⼀个左括号 removeL = tempListSize - start;tempList = removeUseList(tempList, removeL);// 移除已使⽤的元素tempList.add(returnDouble + "");// 刚刚计算的值添加进来zKuohaoIdxList.remove(zIdx);// 计算完毕清除括号}}// 把所有计算完returnDouble = jisuan(tempList, 0, tempList.size());} else {// 没有括号运算returnDouble = jisuan(listSplit, 0, listSplit.size());}return returnDouble;}/*** 倒序删除已⽤过的元素** @param list* @param removeLength* 数量* @return*/public static List<String> removeUseList(List<String> list, int removeLength) {int le = list.size() - removeLength;for (int i = list.size() - 1; i >= le; i--) {list.remove(i);}return list;}/*** 计算算式** @param listSplit* @param start* 括号算式开始符位置* @param end* 括号结束符位置* @return*/public static double jisuan(List<String> listSplit, int start, int end)throws Exception {double returnValue = 0;String strValue = null;// 临时变量List<String> jjValueList = new ArrayList<String>();// 剩下的加减元素// 遍历计算乘除法for (int i = start; i < end; i++) {strValue = listSplit.get(i);if ("*".equals(strValue) || "/".equals(strValue)) {// 乘除strValue = jisuanValue("*".equals(strValue) ? "*" : "/", Double.parseDouble(jjValueList.get(jjValueList.size() - 1)),Double.parseDouble(listSplit.get(i + 1)))+ "";jjValueList.remove(jjValueList.size() - 1);i++;}jjValueList.add(strValue);}// 遍历计算加减for (int j = 0; j < jjValueList.size(); j++) {strValue = jjValueList.get(j);if ("-".equals(strValue) || "+".equals(strValue)) {returnValue = jisuanValue("-".equals(strValue) ? "-" : "+",returnValue, Double.parseDouble(jjValueList.get(j + 1)));j++;} else {returnValue += Double.parseDouble(jjValueList.get(j));}}return returnValue;}/*** 计算2个数间的加减乘除操作如：2*5 ，2/5** @param type* 运算符* @param start* 数相当于上⾯2* @param end* 被数相当于上⾯5* @return*/public static double jisuanValue(String type, double start, double end) throws Exception {double d = 0;if ("-".equals(type)) {d = start - end;} else if ("+".equals(type)) {d = start + end;} else if ("*".equals(type)) {d = start * end;} else if ("/".equals(type)) {if (0 == start || 0 == end)d = 0;elsed = start / end;}return d;}}。
复数的四则运算
(z1z2)n=z1nz2n.
【探究】 i 的指数变化规律
i i , i 1 , i i , i 1
1 2 3 4
i , i __ i __ __ __ i , i 1 , i 1
5 6 7 8
你能发现规律吗？有怎样的规律？ 4 n 1 4n i i , i 1,
例4、下列命题中的真命题 为： D ( A )若Z1 Z 2 0, 则Z1与Z 2互为共轭复数。 (B )若Z1 Z 2 0, 则Z1与Z 2互为共轭复数。 (C)若Z1 Z 2 0, 则Z1与Z 2互为共轭复数。 ( D)若Z1 Z 2 0, 则Z1与Z 2互为共轭复数。
四、例题应用：
例1.计算 (5 6i) (2 i) (3 4i)
解: (5 6 i ) ( 2 i ) (3 4 i )
(5 2 3) (6 1 4) i 11i
（ 1 ） (a bi)(a bi) 例2：计算
a abi abi b i
2
t 1， tan 1， 45 .
o
x1 1，x2 2 i.
五、课堂小结： 1、定义: 把满足(c+di)(x+yi) =a+bi (c+di≠0) 的 复 数 x+yi 叫做复数 a+bi 除以复数 c+di 的商, 其中a,b,c,d,x,y都是实数,
目标: 分母实数化;
手段:
z z R.
三、知识新授：
复数的除法应怎样进行呢? 注意到,实数的除法运算是乘法的逆运算,类 比思考,我们可定义复数的除法:
定义: 把满足(c+di)(x+yi) =a+bi (c+di≠0) 的 复 数 x+yi 叫做复数 a+bi 除以复数 c+di 的商, 其中a,b,c,d,x,y都是实数,
java复数类加减乘除运算
java复数类加减乘除运算以下是一个简单的Java类，表示复数并提供了基本的四则运算：```javapublic class ComplexNumber {private double real; //实部private double imaginary; //虚部// 构造函数public ComplexNumber(double real, double imaginary) { this.real = real;this.imaginary = imaginary;}// 获取实部public double getReal() {return real;}// 获取虚部public double getImaginary() {return imaginary;}// 添加两个复数public ComplexNumber add(ComplexNumber other) {double real = this.real + other.real;double imaginary = this.imaginary + other.imaginary; return new ComplexNumber(real, imaginary);}// 减去另一个复数public ComplexNumber subtract(ComplexNumber other) {double real = this.real - other.real;double imaginary = this.imaginary - other.imaginary; return new ComplexNumber(real, imaginary);}// 乘以另一个复数public ComplexNumber multiply(ComplexNumber other) {double real = this.real * other.real - this.imaginary * other.imaginary;double imaginary = this.real * other.imaginary + this.imaginary * other.real;return new ComplexNumber(real, imaginary);}// 除以另一个复数public ComplexNumber divide(ComplexNumber other) {double divisor = other.real * other.real + other.imaginary * other.imaginary;if (divisor == 0) {throw new IllegalArgumentException("Divisor cannot be zero.");}double real = (this.real * other.real +this.imaginary * other.imaginary) / divisor;double imaginary = (this.imaginary * other.real - this.real * other.imaginary) / divisor;return new ComplexNumber(real, imaginary);}}```你可以这样使用它：```javapublic class Main {public static void main(String[] args) {ComplexNumber a = new ComplexNumber(1, 2); // 1+2iComplexNumber b = new ComplexNumber(3, 4); // 3+4iComplexNumber sum = a.add(b); // (1+3)+(2+4)i = 4+6iComplexNumber difference = a.subtract(b); // (1-3)+(2-4)i = -2+2iComplexNumber product = a.multiply(b); //(1*3)+(2*4)i = 3+8iComplexNumber quotient = a.divide(b); //((1*3+2*4)/(3*3+4*4))+((2*3-1*4)/(3*3+4*4))i = 0.6+0.4iSystem.out.println("Sum: " + sum); // Sum: 4.0+6.0iSystem.out.println("Difference: " + difference); // Difference: -2.0+2.0iSystem.out.println("Product: " + product); // Product: 3.0+8.0iSystem.out.println("Quotient: " + quotient); // Quotient: 0.6+0.4i}}```。
Java实现四则运算
Java实现四则运算本次使⽤java语⾔，实现了四则运算习题的⽣成。
⼀、主要功能：（1）算式个数（2）是否有乘除法（3）结果集数值范围（4）加减法有⽆负数（5）除法有⽆余数（6）除法出现⼩数是否⽀持分数显⽰（7）选择⽣成算式导⼊的⽂件（8）输出打印每⾏个数⼆、代码实现：（1）IFormulaGenerationpackage cn.zhl.software;import java.util.Map;public interface IFormulaGeneration {//加法⽣成接⼝,结果范围，加法有⽆负数,⽣成个数public Map<String,Integer> Add(int resultRange,boolean is,int num);//减法⽣成接⼝，结果范围，减法有⽆负数，⽣成个数public Map<String,Integer> Sub(int resultRange,boolean is,int num);//乘法⽣成接⼝,⽣成个数public Map<String,Integer> Mul(int resultRange,int num);//除法⽣成接⼝，结果范围，除法有⽆余数，是否⽀持分数,⽣成个数public Map<String,String> Div(int resultRange,boolean is,boolean is2,int num);//检测算式是否存在重复,如果存在返回truepublic boolean Repeat(Map<?,?> map,String formula);//⽣成特定范围的数值public int nextInt(int min, int max);//算法⽣成器：算式个数，是否有乘除法，数值范围，加减法有⽆负数，除法⼜⽆余数，是否⽀持分数，打印每⾏个数 public Map<String,?> FormulaCustom(int formulaNum,boolean if_MulDiv,int range,boolean ifNeg_AddSub,boolean ifRem_Div,boolean ifRed_Div,int lineNum);}（2）FormulaRealizationpackage cn.zhl.software;import java.util.HashMap;import java.util.Map;import java.util.Random;import java.util.Set;public class FormulaRealization implements IFormulaGeneration {Random random = new Random();@Overridepublic Map<String, Integer> Add(int resultRange, boolean is, int num) {if (resultRange < 0) {resultRange = -resultRange;}Map<String, Integer> addMap = new HashMap<>();int r1 = 0, r2 = 0, n = 0;String formula = "";for (; n < num; ) {r1 = nextInt(-resultRange, resultRange);if (is) {//加法允许出现负数r2 = nextInt(-resultRange - r1, resultRange - r1);} else {r2 = nextInt(-r1, resultRange - r1);}formula = (r1 < 0 ? "(" + r1 + ")" : r1) + "+" + (r2 < 0 ? "(" + r2 + ")" : r2);if (Repeat(addMap, formula)) {}return addMap;}@Overridepublic Map<String, Integer> Sub(int resultRange, boolean is, int num) { if (resultRange < 0) {resultRange = -resultRange;}Map<String, Integer> subMap = new HashMap<>();int r1 = 0, r2 = 0, n = 0;String formula = "";for (; n < num; ) {r1 = nextInt(-resultRange, resultRange);if (is) {//加法允许出现负数r2 = nextInt(-resultRange + r1, resultRange + r1);} else {r2 = nextInt(r1, resultRange + r1);}formula = (r1 < 0 ? "(" + r1 + ")" : r1) + "-" + (r2 < 0 ? "(" + r2 + ")" : r2); if (Repeat(subMap, formula)) {subMap.put(formula, r1 - r2);n++;}}return subMap;}@Overridepublic Map<String, Integer> Mul(int resultRange, int num) {if (resultRange == 0) {resultRange = 1;}if (resultRange < 0) {resultRange = -resultRange;String formula = "";for (; n < num; ) {while (r1 == 0) {r1 = nextInt(-resultRange, resultRange);}r2 = nextInt(-(int) (resultRange / Math.abs(r1)), (int) (resultRange / Math.abs(r1))); formula = (r1 < 0 ? "(" + r1 + ")" : r1) + "*" + (r2 < 0 ? "(" + r2 + ")" : r2);if (Repeat(mulMap, formula)) {mulMap.put(formula, r1 * r2);n++;r1 = nextInt(-resultRange, resultRange);}}return mulMap;}@Overridepublic Map<String, String> Div(int resultRange, boolean is, boolean is2, int num) { if (resultRange == 0) {resultRange = 1;}if (resultRange < 0) {resultRange = -resultRange;}Map<String, String> divMap = new HashMap<>();int r1 = 0, r2 = 0, n = 0;String formula = "";for (; n < num; ) {//r1 = nextInt(-resultRange, resultRange);while (r2 == 0) {r2 = nextInt(-resultRange, resultRange);}if (!is) {//除法没有余数r1 = r2 * nextInt(-(resultRange), resultRange);} else {//有余数r1 = nextInt(-resultRange, resultRange);}formula = (r1 < 0 ? "(" + r1 + ")" : r1) + "/" + (r2 < 0 ? "(" + r2 + ")" : r2);if (Repeat(divMap, formula)) {String result = "";if (is && is2) {//有余数且化为分数if(r1*r2<0){result = "-"+fracReduction(Math.abs(r1), Math.abs(r2));}else {result = fracReduction(Math.abs(r1), Math.abs(r2));}if(r1%r2==0){result = ((double) r1 / r2) + "";}if (is) {result = ((double) r1 / r2) + "";}}if(r1==0){result=0.0+"";}if (r1==-r2){result="-1.0";}divMap.put(formula, result);n++;}}return divMap;}@Overridepublic boolean Repeat(Map<?, ?> map, String formula) { if (map.isEmpty()) {return true;} else {Set<String> strings = (Set<String>) map.keySet(); for (String string : strings) {//如果当前算式与前⾯算式重复返回falseif (string.equals(formula)) {return false;}}//如果当前算式与前⾯算式不存在重复返回truereturn true;}}@Overridepublic int nextInt(int min, int max) {if (min == max) {return max;}return random.nextInt(max - min + 1) + min;public String fracReduction(int numerator, int denominator) {//找到最⼤公约数，然后分别处以最⼤公约数int m = numerator;int n = denominator;int r;while (numerator > 0) {r = denominator % numerator;denominator = numerator;numerator = r;}// if ((m / denominator)==-(n / denominator)){// return "-1.0";// }return m / denominator + "/" + n / denominator;}@Override//算法⽣成器：算式个数，是否有乘除法，数值范围，加减法有⽆负数，除法⼜⽆余数，是否⽀持分数，打印每⾏个数public Map<String, ?> FormulaCustom(int formulaNum, boolean if_MulDiv, int range, boolean ifNeg_AddSub, boolean ifRem_Div, boolean ifRed_Div, int lineNum) {int add = 0, sub = 0, mul = 0, div = 0;add = nextInt(formulaNum/5,formulaNum/3);sub = nextInt((formulaNum - add)/4,(formulaNum - add)/2);mul = nextInt((formulaNum - add - sub)/3,(formulaNum - add - sub)/1);div = formulaNum - add - sub - mul;Map map = new HashMap();if (if_MulDiv) {//如果存在乘除法将算式总数分为四份Map<String, Integer> addMap = Add(range, ifNeg_AddSub, add);Map<String, Integer> subMap = Sub(range, ifNeg_AddSub, sub);Map<String, Integer> mulMap = Mul(range, mul);Map<String, String> divMap = Div(range, ifRem_Div, ifRed_Div, div);map.putAll(addMap);map.putAll(subMap);map.putAll(mulMap);map.putAll(divMap);} else {//不存在则分为两份map.putAll(addMap);map.putAll(subMap);}return map;}}（3）FormulaRealizationTestpackage cn.zhl.test;import cn.zhl.software.FormulaRealization;import org.junit.Test;import java.util.Map;import java.util.Set;public class FormulaRealizationTest {FormulaRealization formulaRealization = new FormulaRealization();@Testpublic void testAdd() {Map<String, Integer> add = formulaRealization.Add(100, false, 5); for (String s : add.keySet()) {System.out.print(s+"="+add.get(s)+" ");}}@Testpublic void testSub() {Map<String, Integer> sub = formulaRealization.Sub(100, true, 5); for (String s : sub.keySet()) {System.out.print(s+"="+sub.get(s)+" ");}}@TestSystem.out.print(s+"="+mul.get(s)+" ");}}@Testpublic void testDiv() {Map<String, String> div = formulaRealization.Div(100, true, true, 5);for (String s : div.keySet()) {System.out.print(s+"="+div.get(s)+" ");}}@Testpublic void test1() {String div = formulaRealization.fracReduction(25,5);System.out.print(div);}}（4）IFileGenerationpackage cn.zhl.fileCreate;import java.util.Map;public interface IFileGeneration {//⽤于将产⽣的算式写⼊到⽂件中public void fileShow(Map<String,?> stringMap,int lineNum,String fileName); }（5）FileRealizationpackage cn.zhl.fileCreate;import java.io.File;import java.io.FileWriter;import java.io.IOException;@Overridepublic void fileShow(Map<String,?> stringMap, int lineNum, String fileName) {int n=0;String answerName=fileName+"_Answer.txt";fileName=fileName+".txt";/*File file1 = new File("\\cn\\zhl\\formulaFile\\" + fileName);File file2 = new File("\\cn\\zhl\\formulaFile\\" + answerName);*/File file1 = new File("Arithmetic_question_generation_system\\src\\cn\\zhl\\formulaFile\\"+fileName);File file2 = new File("Arithmetic_question_generation_system\\src\\cn\\zhl\\formulaFile\\"+answerName);for (String s : stringMap.keySet()) {n++;try(FileWriter formulaWriter = new FileWriter(file1,true); FileWriter answerWriter = new FileWriter(file2,true)) { formulaWriter.write(s+"= ");answerWriter.write(s+"="+stringMap.get(s)+" ");if(n%lineNum==0){formulaWriter.write("\n");answerWriter.write("\n");}} catch (IOException e) {e.printStackTrace();System.out.println("未成功将算式保存到"+fileName+"中,答案保存到"+answerName+"中,请联系开发⼈员！"); }}System.out.println("已成功将算式保存到"+fileName+"中,答案保存到"+answerName+"中,欢迎您的下次使⽤！"); }}（6）FormulaCustomTestpackage cn.zhl.software;import cn.zhl.fileCreate.FileRealization;import java.io.File;import java.io.FileWriter;import java.io.IOException;public class FormulaCustomTest {public static void main(String[] args) {int formulaNum;boolean if_MulDiv;int range;boolean ifNeg_AddSub;boolean ifRem_Div;boolean ifRed_Div;int lineNum;Scanner scanner = new Scanner(System.in);System.out.println("请输⼊需要算式个数：");formulaNum=scanner.nextInt();System.out.println("请输⼊需要乘除法（Y/N）：");if(scanner.next().equals("y")||scanner.next().equals("Y")){if_MulDiv=true;}else {if_MulDiv=false;}System.out.println("请输⼊需要结果集范围（默认-n~n）：");range=scanner.nextInt();System.out.println("请输⼊允许加减法出现负数（Y/N）：");if(scanner.next().equals("y")||scanner.next().equals("Y")){ifNeg_AddSub=true;}else {ifNeg_AddSub=false;}System.out.println("请输⼊允许除法出现⼩数（Y/N）：");if(scanner.next().equals("y")||scanner.next().equals("Y")){ifRem_Div=true;}else {ifRem_Div=false;}System.out.println("请输⼊允许除法结果换算成分数（Y/N）："); if(scanner.next().equals("y")||scanner.next().equals("Y")){ifRed_Div=true;}else {lineNum=scanner.nextInt();//⽂件名String fileName="";System.out.println("请输⼊算式需要导⼊的⽂件名：");fileName=scanner.next();System.out.println("定制完成，正在随机⽣成算式。
复数的四则运算
共轭虚数：虚部不为0的共轭复数。
特别地，实数的共轭复数是实数本身。
-2i 2i (1-i)2= ___; 练习.计算: (1+i)2= ___;
1 i 1 i -i i ____; ____; 1 i 1 i 1 i 2000 1 ( ) ______ . 1 i
复数的加法满足交换律、结合律,即对任何 z1,z2,z3∈C,有 z1+z2=z2+z1,(z1+z2)+z3=z1+(z2+z3). 例.计算 解:
(5 6i) (2 i) (3 4i)
(5 6 i ) (2 i ) (3 4 i ) (5 2 3) (6 1 4) i 11i
例.计算 (1 2i)(3 4i)(2 i)
解:
(1 2i )(3 4i )( 2 i ) (11 2i )( 2 i ) 20 15i
例证明 . : (a bi)(a bi) a b (a, b R).
2 2
两个复数的和与积都是实数的充要条件是, 这两个复数互为共轭复数.
思考:对于任意的两个复数到底能否比较大小?
答案:当且仅当两个复数都是实数时,才能比较大小.
即:若z1>z2 z1,z2∈R且z1>z2.
复数的四则运算 ： 1 复数的加法与减法 （a +bi）± （c +di）=（a +c）±（b +d)i 即：两个复数相加（减）就是实数部与实数部， 虚数部与虚数部分别相加（减）
解:复数-3+2i ,2+i,0对应点A(-3,2),B(2,1),O(0,0),如图.
Java实现四则运算表达式
四则混合运算的算符优先算法Java实现它们都是对表达式的记法，因此也被称为前缀记法、中缀记法和后缀记法。
它们之间的区别在于运算符相对与操作数的位置不同：前缀表达式的运算符位于与其相关的操作数之前；中缀和后缀同理。
举例：(3 + 4) × 5 - 6 就是中缀表达式- × + 3 4 5 6 前缀表达式3 4 + 5 × 6 - 后缀表达式中缀表达式（中缀记法）中缀表达式是一种通用的算术或逻辑公式表示方法，操作符以中缀形式处于操作数的中间。
中缀表达式是人们常用的算术表示方法。
虽然人的大脑很容易理解与分析中缀表达式，但对计算机来说中缀表达式却是很复杂的，因此计算表达式的值时，通常需要先将中缀表达式转换为前缀或后缀表达式，然后再进行求值。
对计算机来说，计算前缀或后缀表达式的值非常简单。
前缀表达式（前缀记法、波兰式）前缀表达式的运算符位于操作数之前。
前缀表达式的计算机求值：从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素op 次顶元素），并将结果入栈；重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果。
例如前缀表达式“- × + 3 4 5 6”：(1) 从右至左扫描，将6、5、4、3压入堆栈；(2) 遇到+运算符，因此弹出3和4（3为栈顶元素，4为次顶元素，注意与后缀表达式做比较），计算出3+4的值，得7，再将7入栈；(3) 接下来是×运算符，因此弹出7和5，计算出7×5=35，将35入栈；(4) 最后是-运算符，计算出35-6的值，即29，由此得出最终结果。
可以看出，用计算机计算前缀表达式的值是很容易的。
将中缀表达式转换为前缀表达式：遵循以下步骤：(1) 初始化两个栈：运算符栈S1和储存中间结果的栈S2；(2) 从右至左扫描中缀表达式；(3) 遇到操作数时，将其压入S2；(4) 遇到运算符时，比较其与S1栈顶运算符的优先级：(4-1) 如果S1为空，或栈顶运算符为右括号“)”，则直接将此运算符入栈；(4-2) 否则，若优先级比栈顶运算符的较高或相等，也将运算符压入S1；(4-3) 否则，将S1栈顶的运算符弹出并压入到S2中，再次转到(4-1)与S1中新的栈顶运算符相比较；(5) 遇到括号时：(5-1) 如果是右括号“)”，则直接压入S1；(5-2) 如果是左括号“(”，则依次弹出S1栈顶的运算符，并压入S2，直到遇到右括号为止，此时将这一对括号丢弃；(6) 重复步骤(2)至(5)，直到表达式的最左边；(7) 将S1中剩余的运算符依次弹出并压入S2；(8) 依次弹出S2中的元素并输出，结果即为中缀表达式对应的前缀表达式。
java复数四则运算
java复数四则运算import java.util.Scanner;class Complex{Scanner sc=new Scanner(System.in); private float realpart,imagepart; Complex(){}Complex(float r, float i){realpart=r;imagepart=i;}public void setReal(float real){this.realpart=real;}public void setImage(float image) {this.imagepart=image;}public float getReal(){return realpart;}public float getImage(){return imagepart;}public String toString(){if(imagepart==0) return ""+realpart;if(imagepart<0&&realpart>0) return realpart+"+"+"("+imagepart+")"+"i";if(realpart<0&&imagepart>0) return "("+realpart+")"+"+"+imagepart+"i";if(imagepart<0&&realpart<0) return "("+realpart+")"+"+"+"("+imagepart+")"+"i";else return realpart+"+"+imagepart+"i";}public Complex add(Complex c){float realpart=this.getReal()+c.getReal();float imagepart=this.getImage()+c.getImage();return new Complex(realpart,imagepart);}public Complex sub(Complex c){float realpart=this.getReal()-c.getReal();float imagepart=this.getImage()-c.getImage();return new Complex(realpart,imagepart);}public Complex mul(Complex c){float realpart=this.getReal()*c.getReal()-this.getImage()*c.getImage();floatimagepart=this.getReal()*c.getImage()+this.getImage()*c.getRea l();return new Complex(realpart,imagepart);}public Complex div(Complex c){floatrealpart=(this.getReal()*c.getReal()+this.getImage()*c.getImage() )/(c.getReal()*c.getReal()+c.getImage()*c.getImage());float imagepart=-(this.getReal()*c.getImage()+this.getImage()*c.getReal())/(c.getR eal()*c.getReal()+c.getImage()*c.getImage());return new Complex(realpart,imagepart);}public void PressButton(int s,Complex c1,Complex c2){while(s!=0){switch(s){case1:System.out.println(c1.toString()+"+"+c2.toString()+"="+c1.ad d(c2));break;case 2:System.out.println(c1.toString()+"-"+"("+c2.toString()+")"+"="+c1.sub(c2));break;case3:System.out.println("("+c1.toString()+")"+"*"+"("+c2.toString() +")"+"="+c1.mul(c2));break;case4:System.out.println("("+c1.toString()+")"+"/"+"("+c2.toString() +")"+"="+c1.div(c2));break;}if(s<1||s>4){System.out.println("Input again:");}s=sc.nextInt();}System.out.println("Input error!");}}public class TestComplex{public static void main(String[] args){Scanner sc=new Scanner(System.in);System.out.println("Please input complex A:");float realpart1=sc.nextInt();float imagepart1=sc.nextInt(); System.out.println("Please input complex B:");float realpart2=sc.nextInt();float imagepart2=sc.nextInt(); Complex c1=new Complex(realpart1,imagepart1); Complex c2=new Complex(realpart2,imagepart2); System.out.println("Please choose the operate pattern:\n"+ "(choose 1 will run add operation)\n"+"(choose 2 will run sub operation)\n"+"(choose 3 will run mul operation)\n"+"(choose 4 will run div operation)");int s=sc.nextInt();Complex C=new Complex();for(;;){C.PressButton(s,c1,c2);System.out.println("Please input complex A again:"); realpart1=sc.nextInt();imagepart1=sc.nextInt(); System.out.println("Please input complex B again:"); realpart2=sc.nextInt();imagepart2=sc.nextInt(); System.out.println("Please choose the operate pattern:\n"+ "(choose 1 will run add operation)\n"+"(choose 2 will run sub operation)\n"+"(choose 3 will run mul operation)\n"+"(choose 4 will run div operation)");s=sc.nextInt();if(s==-1){System.out.println("Game over!");break;}}}}。
JAVA四则运算算法
JAVA四则运算算法⼀、程序要求解析⼀般数学算式，实现简单的带括号的加减乘除运算。
⼆、基本思路前⾯两篇介绍了直接解析字符串和⽤数组容器辅助解析的两种⽅式，这次再介绍最常⽤的解析算法——解析后缀表达式（逆波兰表达式）。
三、逆波兰表达式及其得到算法1、逆波兰表达式也即后缀表达式，指的是不包含括号，运算符放在两个运算对象的后⾯，所有的计算按运算符出现的顺序，严格从左向右进⾏（不再考虑运算符的优先规则）。
（摘⾃百度），既然没了运算符的优先规则，那么计算机解析起来⾃然容易的多。
对于我们常见的表达式，称为中缀表达式，每个中缀表达式都有对应的后缀表达式。
如：中缀表达式：-2*(1+6/3)+4后缀表达式：-2 1 6 3 / + * 4 +（这⾥为了区分负号和减号，我在数字与数字、数字与符号之间都加了空格，⾄于怎么从中缀表达式得到后缀表达式，后⾯有介绍及参考程序）⽽在解析后缀表达式时，只需要遵守以下原则即可：从左往右遍历遇到数字直接放⼊容器遇到运算符，将最后两个数字取出，进⾏该运算，将结果再放⼊容器遍历结束后，容器中的数字即为运算结果按这个过程⾛下来，⾃然⽽然的想到⽤栈是最合适的。
现只需想办法由输⼊的中缀表达式转为后缀表达式即可完成解析。
2、由中缀表达式得到后缀表达式的算法由中缀表达式得到后缀表达式，只要遵守以下步骤即可：⾸先设置运算符的优先级（这样设置也是为了简化程序）：”null” 栈顶若为空，假设优先级为0“(” 优先级设为1“+-” 优先级设为2“*/” 优先级设为3从左向右遍历中缀表达式遇到数字直接输出遇到符号遇到左括号，直接压栈遇到右括号，弹栈输出直到弹出左括号（左括号不输出）遇到运算符，⽐较栈顶符号，若该运算符优先级⼤于栈顶，直接压栈；若⼩于栈顶，弹栈输出直到⼤于栈顶，然后将改运算符压栈。
最后将符合栈弹栈并输出现根据这个原则，⼿动模拟⼀遍转换过程：还是以-2*(1+6/3)+4为例四、代码⼀环境：Eclipse Java EE IDE（Version: Oxygen.1a Release (4.7.1a)）jdk1.8.0_131先写⼀个最基本的两位数四则运算⽅法，⽐较简单，没有写注释：private static double doubleCal(double a1, double a2, char operator) throws Exception {switch (operator) {case '+':return a1 + a2;case '-':return a1 - a2;case '*':return a1 * a2;case '/':return a1 / a2;default:break;}throw new Exception("illegal operator!");} 写⼀个获得优先级的⽅法：private static int getPriority(String s) throws Exception {if(s==null) return 0;switch(s) {case "(":return 1;case "+":;case "-":return 2;case "*":;case "/":return 3;default:break;}throw new Exception("illegal operator!");}将中缀表达式转变为后缀表达式：private static String toSufExpr(String expr) throws Exception {System.out.println("将"+expr+"解析为后缀表达式...");/*返回结果字符串*/StringBuffer sufExpr = new StringBuffer();/*盛放运算符的栈*/Stack<String> operator = new Stack<String>();operator.push(null);//在栈顶压⼈⼀个null，配合它的优先级，⽬的是减少下⾯程序的判断/* 将expr打散分散成运算数和运算符 */Pattern p = pile("(?<!\\d)-?\\d+(\\.\\d+)?|[+\\-*/()]");//这个正则为匹配表达式中的数字或运算符Matcher m = p.matcher(expr);while (m.find()) {String temp = m.group();if (temp.matches("[+\\-*/()]")) { //是运算符if (temp.equals("(")) { //遇到左括号，直接压栈operator.push(temp);System.out.println("'('压栈");} else if (temp.equals(")")) { //遇到右括号，弹栈输出直到弹出左括号（左括号不输出）String topItem = null;while (!(topItem = operator.pop()).equals("(")) {System.out.println(topItem+"弹栈");sufExpr.append(topItem+" ");System.out.println("输出:"+sufExpr);}} else {//遇到运算符，⽐较栈顶符号，若该运算符优先级⼤于栈顶，直接压栈；若⼩于栈顶，弹栈输出直到⼤于栈顶，然后将改运算符压栈。
Java程序完成复数的加减乘模的运算
Java程序完成复数的加减乘模的运算实习目的：用java实现对复数的基本操作，加，减，乘，除，取模运算。
程序代码：代码一：import java.util.Scanner;public class fushu{public float a,b; //定义成员变量fushu() //构造函数1{}fushu(float x,float y) //构造函数2{a=x;b=y;}public static void main(String[] args) //主函数{System.out.println("选择你要进行操作的序号：1.两个复数加；2.减；3.乘；4.除；5.求模；\n输出你的选择，按回车。
");Scanner in=new Scanner(System.in); //从键盘获得选择int i=in.nextInt();System.out.println(i);switch(i){case 1: //加{System.out.println("第一个实部:")float a1=in.nextFloat();System.out.println("第一个虚部:"); float b1=in.nextFloat();fushu c1=new fushu(a1,b1); System.out.println("第2个实部:"); float a2=in.nextFloat(); System.out.println("第2个虚部:"); float b2=in.nextFloat();fushu c2=new fushu(a2,b2); fushu m=jia(c1,c2);System.out.println("结果为:"); print(m);break;}case 2: //减{System.out.println("第一个实部:"); float a1=in.nextFloat(); System.out.println("第一个虚部:"); float b1=in.nextFloat();fushu c1=new fushu(a1,b1); System.out.println("第2个实部:"); float a2=in.nextFloat(); System.out.println("第2个虚部:"); float b2=in.nextFloat();fushu c2=new fushu(a2,b2); fushu m=jian(c1,c2); System.out.println("结果为:"); print(m);}case 3: //乘{System.out.println("第一个实部:");float a1=in.nextFloat();System.out.println("第一个虚部:");float b1=in.nextFloat();fushu c1=new fushu(a1,b1);System.out.println("第2个实部:");float a2=in.nextFloat();System.out.println("第2个虚部:");float b2=in.nextFloat();fushu c2=new fushu(a2,b2);fushu m=cheng(c1,c2);System.out.println("结果为:");print(m);}case 4: //除{System.out.println("第一个实部:");float a1=in.nextFloat();System.out.println("第一个虚部:");float b1=in.nextFloat();fushu c1=new fushu(a1,b1);System.out.println("第2个实部:");float a2=in.nextFloat();System.out.println("第2个虚部:");float b2=in.nextFloat();fushu c2=new fushu(a2,b2);if(b2==0&&a2==0) //判断能否相除{System.out.println("第二个复数为零，无法计算。
Java实现四则运算的解析收藏
于是在网上搜索了一番，终于有所启发。但是也感慨网上很多的例子并不完整，让我冒着访问恶意网页的风险，四处浏览。遂将我自己的实现写在这里，供大家参考讨论。
此实现方法主要是参考了机械工业出版社出版的《数据结构、算法与应用——C++语言描述》（2000年1月出版）当中，第5章——堆栈，第169页，5.5应用——5.5.1括号匹配的例子，使用Java编写完成。
op = operators.get(curPos).charAt(0);
switch (op) {
case '+':
values.add(curPos, values.get(curPos) + values.get(curPos + 1));
values.remove(curPos + 1);
stack.clear();
break;
}else{
System.out.println("有未关闭的右括号！");
isRightFormat = false;
}
}
curPos++;
}
if(stack.size() > 0){
}
}
ArrayList<Double> values = new ArrayList<Double>();
ArrayList<String> operators = new ArrayList<String>();
JAVA四则运算(递归的思想)
int t = operate.caculate("(3+8*(10-2))"); System.out.println(t); }
}
if (priStack.empty()) { // 当为空时，显然 当前优先级最低，返回高 return true;
} char last = (char) stElement(); // 如果栈顶为'('显然，优先级最低，')'不可能为栈顶。 if (last == '(') {
package demo; import java.util.Stack;
/** * 利用栈，进行四则运算的类 * 用两个栈来实现算符优先，一个栈用来保存需要计算的数据 numStack,一个用来保存计
算优先符 priStack * * 基本算法实现思路为：用当前取得的运算符与 priStack 栈顶运算符比较优先级：若高于，
} // 判断当前运算符与栈顶元素优先级， 如果高，或者低于平，计算完后，将当前操作符号， 放入操作符栈
if (temp.charAt(0) != '#') {
priStack.push(new Character(temp.charAt(0))); if (temp.charAt(0) == ')') {// 当栈顶为'('，而当前元素为')'时，则是括号内以算完，去掉括 号
StringBuffer tempNum = new StringBuffer();// 用来临时存放数字字符串(当为多位数时) StringBuffer string = new StringBuffer().append(str);// 用来保存，提高效率 while (string.length() != 0) {
Java实现复数及其运算
Java实现复数及其运算//Main.java 为主类，其中Main为主函数，Calc为计算函数；publicclass Main{//str用于输出那个提示语句，x是第一参数，y是第二参数//使用Object类型是为了保证不管是Plural类型还是double类型都可以传参publicstaticvoid Calc(String str,Objectx,Object y) {System.out.println(str);Plural.Add(x,y).Out();Plural.Sub(x,y).Out();Plural.Mul(x,y).Out();Plural.Div(x,y).Out();System.out.println();}publicstaticvoid main(String[] args){Plural x=new Plural(1,2);Plural y=new Plural(2,3);Calc("验证两个复数的计算",x,y);Calc("验证一个复数一个实数的计算",x,3);Calc("验证一个实数一个复数的计算",1,y);Calc("验证两个实数的计算",1,3);}}//Plural.java 为复数类，其中Plural为多个构造函数，Out为输出函数；publicclass Plural{//数据段privatedouble real;//实部privatedouble imaginary;//虚部//构造方法//无参数的构造public Plural(){this.real=0.0;this.imaginary=0.0;}//一个double的构造public Plural(double x){this.real=x;this.imaginary=0.0;}//一个Plural的构造，实为复制xpublic Plural(Plural x){this.real=x.real;this.imaginary=x.imaginary;}//实部，虚部的构造public Plural(double real,double imaginary) {this.real=real;this.imaginary=imaginary;}//输出方法publicvoid Out(){//考虑实部虚部情况进行输出，避免出现+-，0+0等情况if(real!=0){if(imaginary<0)System.out.println(real+"-"+(-imaginary)+"i");elseif(imaginary>0)System.out.println(real+"+"+imaginary+"i");elseSystem.out.println(real);}else{if(imaginary!=0)System.out.println(imaginary+"i");elseSystem.out.println(0);}}//静态方法//为非static的Out的copy，只是为了方便publicstaticvoid Out(Plural x){x.Out();}//类似Object+Object的运算publicstatic Plural Add(Object x,Object y){//1.如果x输入Plural类型，则(x instanceof Plural)返回true，反之亦然// 用这样的判断得出如果传参为Object类型时如何计算//2.Double.parseDouble(x.toString())// 是先将Object类型的x转换为String类型然再转换为double，本情况不能直接转换//下列方法类同if((x instanceof Plural)&&(y instanceof Plural))return Add((Plural)x,(Plural)y);elseif((x instanceof Plural)&&!(y instanceof Plural))return Add((Plural)x,Double.parseDouble(y.toString()));elseif(!(x instanceof Plural)&&(y instanceof Plural))return Add((Double.parseDouble(x.toString())),(Plural)y);elsereturnAdd((Double.parseDouble(x.toString())),Double.parseDouble(y.t oString())); }publicstatic Plural Sub(Object x,Object y){if((x instanceof Plural)&&(y instanceof Plural))return Sub((Plural)x,(Plural)y);elseif((x instanceof Plural)&&!(y instanceof Plural))return Sub((Plural)x,Double.parseDouble(y.toString()));elseif(!(x instanceof Plural)&&(y instanceof Plural))return Sub((Double.parseDouble(x.toString())),(Plural)y);elsereturnSub((Double.parseDouble(x.toString())),Double.parseDouble(y.to String())); }publicstatic Plural Mul(Object x,Object y){if((x instanceof Plural)&&(y instanceof Plural))return Mul((Plural)x,(Plural)y);elseif((x instanceof Plural)&&!(y instanceof Plural))return Mul((Plural)x,Double.parseDouble(y.toString()));elseif(!(x instanceof Plural)&&(y instanceof Plural))return Mul((Double.parseDouble(x.toString())),(Plural)y);elsereturnMul((Double.parseDouble(x.toString())),Double.parseDouble(y.to String())); }publicstatic Plural Div(Object x,Object y){if((x instanceof Plural)&&(y instanceof Plural))return Div((Plural)x,(Plural)y);elseif((x instanceof Plural)&&!(y instanceof Plural))return Div((Plural)x,Double.parseDouble(y.toString()));elseif(!(x instanceof Plural)&&(y instanceof Plural))return Div((Double.parseDouble(x.toString())),(Plural)y);elsereturnDiv((Double.parseDouble(x.toString())),Double.parseDouble(y.to String()));}//类似Plural+Plural的运算publicstatic Plural Add(Plural x,Plural y){Plural result=new Plural(x.real+y.real,x.imaginary+y.imaginary);return result;}publicstatic Plural Sub(Plural x,Plural y){Plural result=new Plural(x.real-y.real,x.imaginary-y.imaginary);return result;}publicstatic Plural Mul(Plural x,Plural y){double real=x.real*y.real-x.imaginary*y.imaginary;double imaginary=x.real*y.imaginary+x.imaginary*y.real;Plural result=new Plural(real,imaginary);return result;}publicstatic Plural Div(Plural x,Plural y){double denominator=y.real*y.real+y.imaginary*y.imaginary;double molecular1=x.real*y.real+x.imaginary*y.imaginary;double molecular2=x.imaginary*y.real-x.real*y.imaginary;Plural result=new Plural(molecular1/denominator,molecular2/denominator);return result;}//类似Plural+double的运算publicstatic Plural Add(Plural x,double y){return Add(x,new Plural(y,0.0));}publicstatic Plural Sub(Plural x,double y){return Sub(x,new Plural(y,0.0));}publicstatic Plural Mul(Plural x,double y){Plural result=new Plural(x.real*y,x.imaginary*y);return result;}publicstatic Plural Div(Plural x,double y){Plural result=new Plural(x.real/(y*1.0),x.imaginary/(y*1.0)); return result;}//类似double+Plural的运算publicstatic Plural Add(double x,Plural y){return Add(y,x);}publicstatic Plural Sub(double x,Plural y){return Sub(y,x);}publicstatic Plural Mul(double x,Plural y){return Mul(y,x);}publicstatic Plural Div(double x,Plural y){Plural result=Div(new Plural(x,0.0),y);return result;}//类似double+double的运算publicstatic Plural Add(double x,double y){return (new Plural(x+y,0.0));}publicstatic Plural Sub(double x,double y){return (new Plural(x-y,0.0));}publicstatic Plural Mul(double x,double y){return (new Plural(x*y,0.0));}publicstatic Plural Div(double x,double y) {return (new Plural(x/y,0.0));}}//运行结果：验证两个复数的计算3.0+5.0i-1.0-1.0i-4.0+7.0i0.6153846153846154+0.07692307692307693i 验证一个复数一个实数的计算4.0+2.0i-2.0+2.0i3.0+6.0i0.3333333333333333+0.6666666666666666i验证一个实数一个复数的计算3.0+3.0i1.0+3.0i2.0+3.0i0.15384615384615385-0.23076923076923078i 验证两个实数的计算4.0-2.03.00.3333333333333333。
Java编写四则运算
Java编写四则运算⼀、需求分析程序可接收⼀个输⼊参数n，然后按要求产⽣n道加减乘除练习题，每个数字在 0 和 100 之间。
⼆、功能分析输⼊需要产⽣的题⽬个数。
屏幕依次显⽰产⽣的题⽬以及计算结果。
package arithmetic;import java.util.ArrayList;import java.util.List;import java.util.Random;import java.util.Scanner;import java.util.function.BiFunction;public class Exam {Scanner scan=new Scanner(System.in);private List<Subject> subjectList;public List<Subject> getSubjectList() {return subjectList;}public void setSubjectList(List<Subject> subjectList) {this.subjectList = subjectList;}public Exam() {System.out.print("请输⼊出题个数");int count = scan.nextInt();List<Subject> list = new ArrayList<Subject>();BiFunction<Integer, Integer, Integer> add = (x, y) -> x + y;BiFunction<Integer, Integer, Integer> minus = (x, y) -> x - y;BiFunction<Integer, Integer, Integer> multiple = (x, y) -> x * y;BiFunction<Integer, Integer, Integer> divide = (x, y) -> x / y;for (int i = 0; i < count; i++) {Subject subject = new Subject();Integer a = new Random().nextInt(99);Integer b = new Random().nextInt(99);subject.setA(a);subject.setB(b);subject.setIndex(i + 1);Integer symbol = new Random().nextInt(3);if (symbol == 0) {subject.setSymbol("+");subject.setAnswer(add.apply(a, b));} else if (symbol == 1) {subject.setSymbol("-");subject.setAnswer(minus.apply(a, b));} else if (symbol == 2) {subject.setSymbol("×");subject.setAnswer(multiple.apply(a, b));} else if (symbol == 3) {subject.setSymbol("÷");subject.setAnswer(divide.apply(a, b));}list.add(subject);}this.subjectList = list;}public static void main(String[] args) {Exam exam = new Exam();// 查看试卷exam.getSubjectList().forEach(subject -> {System.out.println(subject.getA() + " " + subject.getSymbol() + " "+ subject.getB() + " = " + subject.getAnswer());});}}/*** 定义题⽬的类**/class Subject {private Integer index;private Integer a;private Integer b;private String symbol;private Integer answer;public Integer getIndex() {return index;}public void setIndex(Integer index) {this.index = index;}public Integer getA() {return a;}public void setA(Integer a) {this.a = a;}public Integer getB() {return b;}public void setB(Integer b) {this.b = b;}public String getSymbol() {return symbol;}public void setSymbol(String symbol) {this.symbol = symbol;}public Integer getAnswer() {return answer;}public void setAnswer(Integer answer) {this.answer = answer;}}。
数学复数运算
数学复数运算复数是由实部和虚部组成的数，通常用 a+bi 的形式表示，其中 a 是实部，b 是虚部，且 i 是虚数单位。
在数学中，复数运算是对复数进行各种算术操作的过程。
本文将介绍复数的四则运算、复数的共轭、复数的模和幅角，以及复数的乘法和除法等内容。
一、复数的四则运算复数的四则运算包括加法、减法、乘法和除法。
对于两个复数 a+bi 和 c+di，这些运算的计算规则如下：1. 加法：(a+bi)+(c+di) = (a+c) + (b+d)i2. 减法：(a+bi)-(c+di) = (a-c) + (b-d)i3. 乘法：(a+bi)(c+di) = (ac-bd) + (ad+bc)i4. 除法：(a+bi)/(c+di) = [(ac+bd)/(c^2+d^2)] + [(bc-ad)/(c^2+d^2)]i需要注意的是，虚部 i 的平方等于 -1，因此在计算过程中可以利用这一性质简化运算。
二、复数的共轭复数的共轭是指实部不变，虚部取负的操作。
对于一个复数 a+bi，它的共轭为 a-bi。
共轭复数的性质如下：1. 一个复数与它的共轭的乘积为该复数的模的平方：(a+bi)(a-bi) = a^2 + b^22. 一个复数与它的共轭的和为实数：(a+bi) + (a-bi) = 2a三、复数的模和幅角复数的模是指复数到原点的距离，用 |a+bi| 表示，它的计算公式为sqrt(a^2 + b^2)。
而复数的幅角是指复数与正实轴的夹角，用 arg(a+bi) 表示，它的计算公式为 arctan(b/a)。
根据复数的模和幅角，我们可以利用极坐标表示复数。
对于一个复数 a+bi，它可以表示为 |a+bi| * (cos(arg(a+bi)) + i*sin(arg(a+bi)))。
四、复数的乘法和除法复数的乘法和除法可以利用复数的模和幅角进行计算。
两个复数的乘法可以通过将两个复数的模相乘，幅角相加得到新的复数的模和幅角。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
return new Complex(realpart,imagepart);
}
public Complex div(Complex c)
realpart1=sc.nextInt();imagepart1=sc.nextInt();
System.out.println("Please input complex B again:");
realpart2=sc.nextInt();imagepart2=sc.nextInt();
return new Complex(realpart,imagepart);
}
public Complex sub(Complex c)
{
float realpart=this.getReal()-c.getReal();
float imagepart=this.getImage()-c.getImage();
{
float realpart=(this.getReal()*c.getReal()+this.getImage()*c.getImage())/(c.getReal()*c.getReal()+c.getImage()*c.getImage());
float imagepart=-(this.getReal()*c.getImage()+this.getImage()*c.getReal())/(c.getReal()*c.getReal()+c.getImage()*c.getImage());
else return realpart+"+"+imagepart+"i";
}
public Complex add(Complex c)
{
float realpart=this.getReal()+c.getReal();
float imagepart=this.getImage()+c.getImage();
Scanner sc=new Scanner(System.in);
System.out.println("Please input complex A:");
float realpart1=sc.nextInt();float imagepart1=sc.nextInt();
System.out.println("Please input complex B:");
System.out.println("Please choose the operate pattern:\n"+
"(choose 1 will run add operation)\n"+
"(choose 2 will run sub operation)\n"+
"(choose 3 will run mul operation)\n"+
return new Complex(realpart,imagepart);
}
public void PressButton(int s,Complex c1,Complex c2)
{
while(s!=0)
{
switch(s)
{
case 1:System.out.println(c1.toString()+"+"+c2.toString()+"="+c1.add(c2));break;
case 2:System.out.println(c1.toString()+"-"+"("+c2.toString()+")"+"="+c1.sub(c2));break;
case 3:System.out.println("("+c1.toString()+")"+"*"+"("+c2.toString()+")"+"="+c1.mul(c2));break;
import java.util.Scanner;
class Complex
{
Scanner sc=new Scanner(System.in);
private float realpart,imagepart;
Complex(){}
Complex(float r, float i)
return new Complex(realpart,imagepart);
}
public Complex mul(Complex c)
{
float realpart=this.getReal()*c.getReal()-this.getImage()*c.getImage();
break;
}
}
}
}
"(choose 3 will run mul operation)\n"+
"(choose 4 will run div operation)");
s=sc.nextInt();
if(s==-1)
{
System.out.println("Game over!");
float realpart2=sc.nextInt();float imagepart2=sc.nextInt();
Complex c1=new Complex(realpart1,imagepart1);
Complex c2=new Complex(realpart2,imagepart2);
}
s=sc.nextInt();
}
System.out.println("Input error!");
}
}
public class TestComplex
{
public static void main(String[] args)
{
if(imagepart<0&&realpart>0) return realpart+"+"+"("+imagepart+")"+"i";
if(realpart<0&&imagepart>0) return "("+realpart+")"+"+"+imagepart+"i";
if(imagepart<0&&realpart<0) return "("+realpart+")"+"+"+"("+imagepart+")"+"i";
"(choose 4 will run div operation)");
int s=sc.nextInt();
Complex C=new Complex();
for(;;)
{
C.PressButton(s,c1,c2);
System.out.println("Please input complex A again:");
{
realpart=r;
imagepart=i;
}
public void setReal(float real)
{
this.realpart=real;
}
public void setImage(float image)
{
this.imagepart=image;
System.out.println("Please choose the operate pattern:\n"+
"(choose 1 will run add operation)\n"+
"(choose 2 will run sub operation)\n"+
case 4:System.out.println("("+c1.toString()+")"+"/"+"("+c2.toString()+")"+"="+c1.div(c2));break;
}
if(println("Input again:");
}
public float getReal()
{
return realpart;
}
public float getImage()