当前位置:首页 > 课后答案 > 数学课后习题答案
《初等数论》电子书封面

初等数论

  • 发布时间:2021年04月08日 09:13:07
  • 作者:王进明
  • 出版:人民教育出版社
  • 大小:6.68 MB
  • 类别:数学资料
  • 格式:PDF
  • 评分:7.7

    初等数论 课后答案

      给大家带来的是关于数学相关的课后习题答案,介绍了关于初等数学、数学方面的内容,本书是由人民教育出版社出版,资源格式为PDF,大小6.68 MB,王进明编写,目前高等院校数学类教材综合评分为:7.1分

      Tags:数学 初等数学 

      《初等数论》内容介绍

      初等数论共分五章,主要研究整数最基本的性质。章讨论整除理论;第二章与第三章较全面地介绍了同余理论的基本知识;第四章用整除理论和同余理论介绍了几类最基本部定方程的解法;第五章简要介绍了连分数。

      目录

      • 第一章:整数的整除性
      • 第二章:同余
      • 第三章:同余方程
      • 第四章:不定方程
      • 第五章:简单连分数

      笔记精选

      实例详解Java计算数学表达式

      Java字符串转换成算术表达式计算并输出结果,通过这个工具可以直接对字符串形式的算术表达式进行运算,并且使用非常简单。

      这个工具中包含两个类 Calculator 和 ArithHelper

      Calculator 代码如下:

      import java.util.Collections;
      import java.util.Stack;
      /**
       * 算数表达式求值 
       * 直接调用Calculator的类方法conversion() 
       * 传入算数表达式,将返回一个浮点值结果
       * 如果计算过程错误,将返回一个NaN
       */
      public class Calculator {
      	private Stack<String> postfixStack = new Stack<String>();
      	// 后缀式栈
      	private Stack<Character> opStack = new Stack<Character>();
      	// 运算符栈
      	private int[] operatPriority = new int[] { 0, 3, 2, 1, -1, 1, 0, 2 };
      	// 运用运算符ASCII码-40做索引的运算符优先级
      	public static double conversion(String expression) {
      		double result = 0;
      		Calculator cal = new Calculator();
      		try {
      			expression = transform(expression);
      			result = cal.calculate(expression);
      		}
      		catch (Exception e) {
      			// e.printStackTrace();
      			// 运算错误返回NaN
      			return 0.0 / 0.0;
      		}
      		// return new String().valueOf(result);
      		return result;
      	}
      	/**
         * 将表达式中负数的符号更改
         *
         * @param expression
         *      例如-2+-1*(-3E-2)-(-1) 被转为 ~2+~1*(~3E~2)-(~1)
         * @return
         */
      	private static String transform(String expression) {
      		char[] arr = expression.toCharArray();
      		for (int i = 0; i < arr.length; i++) {
      			if (arr[i] == '-') {
      				if (i == 0) {
      					arr[i] = '~';
      				} else {
      					char c = arr[i - 1];
      					if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == 'E' || c == 'e') {
      						arr[i] = '~';
      					}
      				}
      			}
      		}
      		if(arr[0]=='~'||arr[1]=='('){
      			arr[0]='-';
      			return "0"+new String(arr);
      		} else{
      			return new String(arr);
      		}
      	}
      	/**
         * 按照给定的表达式计算
         *
         * @param expression
         *      要计算的表达式例如:5+12*(3+5)/7
         * @return
         */
      	public double calculate(String expression) {
      		Stack<String> resultStack = new Stack<String>();
      		prepare(expression);
      		Collections.reverse(postfixStack);
      		// 将后缀式栈反转
      		String firstValue, secondValue, currentValue;
      		// 参与计算的第一个值,第二个值和算术运算符
      		while (!postfixStack.isEmpty()) {
      			currentValue = postfixStack.pop();
      			if (!isOperator(currentValue.charAt(0))) {
      				// 如果不是运算符则存入操作数栈中
      				currentValue = currentValue.replace("~", "-");
      				resultStack.push(currentValue);
      			} else {
      				// 如果是运算符则从操作数栈中取两个值和该数值一起参与运算
      				secondValue = resultStack.pop();
      				firstValue = resultStack.pop();
      				// 将负数标记符改为负号
      				firstValue = firstValue.replace("~", "-");
      				secondValue = secondValue.replace("~", "-");
      				String tempResult = calculate(firstValue, secondValue, currentValue.charAt(0));
      				resultStack.push(tempResult);
      			}
      		}
      		return double.valueOf(resultStack.pop());
      	}
      	/**
         * 数据准备阶段将表达式转换成为后缀式栈
         * 
         * @param expression
         */
      	private void prepare(String expression) {
      		opStack.push(',');
      		// 运算符放入栈底元素逗号,此符号优先级最低
      		char[] arr = expression.toCharArray();
      		int currentIndex = 0;
      		// 当前字符的位置
      		int count = 0;
      		// 上次算术运算符到本次算术运算符的字符的长度便于或者之间的数值
      		char currentOp, peekOp;
      		// 当前操作符和栈顶操作符
      		for (int i = 0; i < arr.length; i++) {
      			currentOp = arr[i];
      			if (isOperator(currentOp)) {
      				// 如果当前字符是运算符
      				if (count > 0) {
      					postfixStack.push(new String(arr, currentIndex, count));
      					// 取两个运算符之间的数字
      				}
      				peekOp = opStack.peek();
      				if (currentOp == ')') {
      					// 遇到反括号则将运算符栈中的元素移除到后缀式栈中直到遇到左括号
      					while (opStack.peek() != '(') {
      						postfixStack.push(String.valueOf(opStack.pop()));
      					}
      					opStack.pop();
      				} else {
      					while (currentOp != '(' && peekOp != ',' && compare(currentOp, peekOp)) {
      						postfixStack.push(String.valueOf(opStack.pop()));
      						peekOp = opStack.peek();
      					}
      					opStack.push(currentOp);
      				}
      				count = 0;
      				currentIndex = i + 1;
      			} else {
      				count++;
      			}
      		}
      		if (count > 1 || (count == 1 && !isOperator(arr[currentIndex]))) {
      			// 最后一个字符不是括号或者其他运算符的则加入后缀式栈中
      			postfixStack.push(new String(arr, currentIndex, count));
      		}
      		while (opStack.peek() != ',') {
      			postfixStack.push(String.valueOf(opStack.pop()));
      			// 将操作符栈中的剩余的元素添加到后缀式栈中
      		}
      	}
      	/**
         * 判断是否为算术符号
         *
         * @param c
         * @return
         */
      	private Boolean isOperator(char c) {
      		return c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')';
      	}
      	/**
         * 利用ASCII码-40做下标去算术符号优先级
         *
         * @param cur
         * @param peek
         * @return
         */
      	public Boolean compare(char cur, char peek) {
      		// 如果是peek优先级高于cur,返回true,默认都是peek优先级要低
      		Boolean result = false;
      		if (operatPriority[(peek) - 40] >= operatPriority[(cur) - 40]) {
      			result = true;
      		}
      		return result;
      	}
      	/**
         * 按照给定的算术运算符做计算
         *
         * @param firstValue
         * @param secondValue
         * @param currentOp
         * @return
         */
      	private String calculate(String firstValue, String secondValue, char currentOp) {
      		String result = "";
      		switch (currentOp) {
      			case '+':
      			      result = String.valueOf(ArithHelper.add(firstValue, secondValue));
      			break;
      			case '-':
      			      result = String.valueOf(ArithHelper.sub(firstValue, secondValue));
      			break;
      			case '*':
      			      result = String.valueOf(ArithHelper.mul(firstValue, secondValue));
      			break;
      			case '/':
      			      result = String.valueOf(ArithHelper.div(firstValue, secondValue));
      			break;
      		}
      		return result;
      	}
      }

      ArithHelper 代码如下:

      public class ArithHelper {
      	// 默认除法运算精度
      	private static final int DEF_DIV_SCALE = 16;
      	// 这个类不能实例化
      	private ArithHelper() {
      	}
      	/**
         * 提供精确的加法运算。
         *
         * @param v1 被加数
         * @param v2 加数
         * @return 两个参数的和
         */
      	public static double add(double v1, double v2) {
      		java.math.BigDecimal b1 = new java.math.BigDecimal(double.toString(v1));
      		java.math.BigDecimal b2 = new java.math.BigDecimal(double.toString(v2));
      		return b1.add(b2).doubleValue();
      	}
      	public static double add(String v1, String v2) {
      		java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
      		java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
      		return b1.add(b2).doubleValue();
      	}
      	/**
         * 提供精确的减法运算。
         *
         * @param v1 被减数
         * @param v2 减数
         * @return 两个参数的差
         */
      	public static double sub(double v1, double v2) {
      		java.math.BigDecimal b1 = new java.math.BigDecimal(double.toString(v1));
      		java.math.BigDecimal b2 = new java.math.BigDecimal(double.toString(v2));
      		return b1.subtract(b2).doubleValue();
      	}
      	public static double sub(String v1, String v2) {
      		java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
      		java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
      		return b1.subtract(b2).doubleValue();
      	}
      	/**
         * 提供精确的乘法运算。
         *
         * @param v1
         *      被乘数
         * @param v2
         *      乘数
         * @return 两个参数的积
         */
      	public static double mul(double v1, double v2) {
      		java.math.BigDecimal b1 = new java.math.BigDecimal(double.toString(v1));
      		java.math.BigDecimal b2 = new java.math.BigDecimal(double.toString(v2));
      		return b1.multiply(b2).doubleValue();
      	}
      	public static double mul(String v1, String v2) {
      		java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
      		java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
      		return b1.multiply(b2).doubleValue();
      	}
      	/**
         * 提供(相对)精确的除法运算,当发生除不尽的情况时,精确到 小数点以后10位,以后的数字四舍五入。
         *
         * @param v1
         *      被除数
         * @param v2
         *      除数
         * @return 两个参数的商
         */
      	public static double div(double v1, double v2) {
      		return div(v1, v2, DEF_DIV_SCALE);
      	}
      	public static double div(String v1, String v2) {
      		java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
      		java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
      		return b1.divide(b2, DEF_DIV_SCALE, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
      	}
      	/**
         * 提供(相对)精确的除法运算。当发生除不尽的情况时,由scale参数指 定精度,以后的数字四舍五入。
         *
         * @param v1 被除数
         * @param v2 除数
         * @param scale 表示表示需要精确到小数点以后几位。
         * @return 两个参数的商
         */
      	public static double div(double v1, double v2, int scale) {
      		if (scale < 0) {
      			throw new IllegalArgumentException("The  scale  must  be  a  positive  integer  or  zero");
      		}
      		java.math.BigDecimal b1 = new java.math.BigDecimal(double.toString(v1));
      		java.math.BigDecimal b2 = new java.math.BigDecimal(double.toString(v2));
      		return b1.divide(b2, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
      	}
      	/**
         * 提供精确的小数位四舍五入处理。
         *
         * @param v 需要四舍五入的数字
         * @param scale 小数点后保留几位
         * @return 四舍五入后的结果
         */
      	public static double round(double v, int scale) {
      		if (scale < 0) {
      			throw new IllegalArgumentException("The  scale  must  be  a  positive  integer  or  zero");
      		}
      		java.math.BigDecimal b = new java.math.BigDecimal(double.toString(v));
      		java.math.BigDecimal one = new java.math.BigDecimal("1");
      		return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
      	}
      	public static double round(String v, int scale) {
      		if (scale < 0) {
      			throw new IllegalArgumentException("The  scale  must  be  a  positive  integer  or  zero");
      		}
      		java.math.BigDecimal b = new java.math.BigDecimal(v);
      		java.math.BigDecimal one = new java.math.BigDecimal("1");
      		return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
      	}
      }

      使用时调用 Calculator 类的 conversion()方法,并传入算术表达式参数,即可返回一个 Double 类型的值。

      使用示例:

      public class MathTest {
      	public static void main(String[] args) {
      		String expression = "(0*1--3)-5/-4-(3*(-2.13))";
      		double result = Calculator.conversion(expression);
      		System.out.println(expression + " = " + result);
      		System.out.println();
      	}
      }

      控制台输出:

      (0*1--3)-5/-4-(3*(-2.13)) = 10.64

      测试截图:

      Java计算数学表达式代码详解

      总结

      以上就是本文关于Java计算数学表达式代码详解的全部内容,希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题,如有不足之处,欢迎留言指出。感谢朋友们对本站的支持!

      以上就是本次介绍的初等数论书的全部相关内容,课后答案及相关习题附件可以在下方下载,希望我们整理的资源能够帮助到大家,感谢大家对码农之家的支持。

      上一篇:软件工程

      下一篇:没有了

      查看更多
      数学 相关资源
      同济高等数学第七版(上、下册)
      同济高等数学第七版(上、下册) PDF 高清版

      《 高等数学 》第7版是普通高等教育十二五规划教材,在第6版的基础上作了进一步的修订。新版教材在保留原教材结构严谨,逻辑清晰、叙述详细、通俗易懂、例题较多、便于自学等优点的基础上,对教材深广度进行了适度的调整,使其更适合当前教学的需要;同时吸收了国外优秀教材的优点,对习题作了较多调整和充实;对全书内容作了进一步的锤炼和适当的调整,使其能更好满足高等教育进入大众化的新要求。 本书是同济大学数学系编《高等数学

      立即下载
      加密与认证技术的数学基础
      加密与认证技术的数学基础 PDF 高清版

      《加密与认证技术的数学基础》 系统地介绍了加密算法与认证技术所需要的数学基础知识,它们涉及到布尔代数、线性代数、数论、抽象代数和椭圆曲线等内容,并就这些数学知识在加密与认

      立即下载
      3D游戏与计算机图形学中的数学方法
      3D游戏与计算机图形学中的数学方法 PDF 扫描第3版 立即下载
      程序员的数学思维修炼
      程序员的数学思维修炼 PDF 解读扫描版

      本书是一本专门为程序员而写的数学书,介绍了程序设计中常用的数学知识。适合广大程序设计人员及数学爱好者阅读,尤其适合有一定程序设计经验,但还需要进一步加深对程序设计理解的人

      立即下载
      工程数学线性代数(同济大学)
      工程数学线性代数(同济大学) PDF 超清第六版 立即下载
      程序员的数学
      程序员的数学 PDF 超清版 立即下载
      读者心得
      43小时13分钟前回答

      使用Python快乐学数学Github万星神器Manim简介

      高考在即,笔者想为孩子以后能够快乐学习数学、学习编程找到一个比较合适的项目,经过一番比较发现github上的万星项目manim(https://github.com/3b1b/manim)就非常好。它能够快速构建有关数学的动画,而且非常精确形象。 安装Manim 虽然manim已经支持Python3.7的,不过安装起来还是比较麻烦,我在ubantu18.04上直接使用安装的过程如下: 1.首先尝试直接使用 pip install manimlib 命令安装,但是会有以下报错 Cannot uninstall 'pycairo'. It is a distutils installed project and thus we cannot accurately determine which files belong to it which would lead to only a partial uninstall. 2.pip安装失败后使用git命令安装 sudo apt install sox ffmpeg libcairo2 libcairo2-devsudo apt ins……

      18小时17分钟前回答

      Python数据分析要学什么数学

      因为不知道所学的数学知识到底有什么用。对于IT公司的研发人员来说,他们在进入大数据相关岗位前,总是觉得要先学点数学,但是茫茫的数学世界,哪里才是数据技术的尽头? 一谈到数据技术,很多人首先想到的是数学,大概是因为数字在数学体系中稳固的位置吧,这也是理所当然的。本文对数据技术的数学基础这个问题进行一些探讨。(推荐学习:Python视频教程) 我们知道数学的三大分支,即代数、几何与分析,每个分支随着研究的发展延伸出来很多小分支。在这个数学体系中,与大数据技术有密切关系的数学基础主要有以下几类。(关于这些数学方法在大数据技术中的应用参见《互联网大数据……

      20小时13分钟前回答

      Python函数学习的注意要点

      函数式编程 1.简化代码, 2,调用方便,修改方便 3.调用参数,形参数,与位置参数。关键参数,位置参数只能发在关键参数之后 4.默认参数 5.参数组(*args) 元组参数 6 接受字典 ( **kwargs) 当同时使用时必须放到参数的最后 程序运行的从文件的上边到下边的运行 局部变量 一个变量只在函数中生效。外部访问不到 全局变量 在文件顶层声明的变量 ,局部变量可以修改全局变量 需要使用关键字global name 在使用时不建议使用global 不能在函数中修改全局变量,不然不好调试 递归函数 1.必须有一个明确的结束条件 2.每次进入更深一层递归时,问题规模相比上次递归都应有所减少 3.递归效率不高,递归层次过多……

      码农之家

      袁诗文 提供上传

      资源
      38
      粉丝
      45
      喜欢
      71
      评论
      6

      Copyright 2018-2021 www.xz577.com 码农之家

      版权投诉 / 书籍推广:520161757@qq.com