算法 第四版 习题 答案1.2
算法第四版习题答案1.2
/*
* 1.2.1 编写一个Point2D的用例，从命令行接受一个整数N。在单位正方形内生成N个随机点，然后计算两点之间的最近距离
*/
public class testPoint2D {
public testPoint2D() {
// TODO Auto-generated constructor stub
}
public static void drawbox(double bw, double bh)
{
StdDraw.setPenRadius(0.005);
StdDraw.setPenColor(StdDraw.RED);
Interval1D xinterval = new Interval1D(0, bw);
Interval1D yinterval = new Interval1D(0, bh);
Interval2D box = new Interval2D(xinterval, yinterval);
box.draw();
}
public static Point2D[] drawpoint(int N)
{
Point2D[] p=new Point2D[N];
for(int i=0;i { double x=Math.random(); double y=Math.random(); p[i]=new Point2D(x, y) ; p[i].draw(); } return p; } public static double findmindist(Point2D[] p) { Point2D p1=p[0]; Point2D p2=p[1]; double mindist =p[0].distanceTo(p[1]); StdDraw.setPenRadius(0.002); StdDraw.setPenColor(StdDraw.RED); int n=p.length ; for(int i=1;i for(int j=i+1;j { double temp=p[i].distanceTo(p[j]); if(temp { mindist=temp; p1=p[i]; p2=p[j]; } } p1.drawTo(p2); StdOut.print("min dist="+mindist +p1.toString()+p2.toString()); return mindist; } public static void main(String[] args) { int N=StdIn.readInt();//读取画点的数量 //StdDraw.setXscale(0,1 ); //StdDraw.setYscale(0,1); drawbox(1,1);//画出一个单位大小的正方形 StdDraw.setPenRadius(0.01); StdDraw.setPenColor(StdDraw.BLACK); //drawpoint(N);//画出N个点 double min=findmindist(drawpoint(N)); } } /* * 编写一个Interval1D的用例，从命令行接受一个整数N。从标准输入中读取N个间隔（每个间隔由一对double值定义）并打印出所有相交的间隔对 */ public class testInterval1D { public testInterval1D() { // TODO Auto-generated constructor stub } public static void main(String[] args) { // TODO Auto-generated method stub int N = StdIn.readInt(); Interval1D[] interval = new Interval1D[N]; int T = N; while (N > 0) { double lo = N; double hi = N + N; interval[T - N] = new Interval1D(lo, hi); StdOut.println(interval[T - N].toString()); N--; } StdOut.println(" OUT:"); for (int i = 0; i < T - 1; i++) for (int j = i + 1; j < T; j++) { if (interval[i].intersects(interval[j]) == true) { StdOut.println(interval[i].toString() + interval[j].toString()); } else { StdOut.println(interval[i].toString() + interval[j].toString() + "none"); } } } } /** * 1.2.3 */ /** * @author Administrator * */ public class TestInterval2D { public static void main(String[] args) { // TODO Auto-generated method stub StdOut.println("enter N:"); int N = 10; StdOut.println("enter min and max:"); double min = 0.1; double max = 0.9; StdDraw.setXscale(0, 1); StdDraw.setYscale(0, 1); StdDraw.setPenRadius(0.001); StdDraw.setPenColor(StdDraw.RED); Interval2D[] box = new Interval2D[N]; Interval1D[] xinterval = new Interval1D[N]; Interval1D[] yinterval = new Interval1D[N]; double average = (max - min); Point2D[][] p = new Point2D[N][2]; /* * Point2D[][] p 使用数组保存点二位平面的对角顶点，用来计算是否包含。 Interval2D[] box * 建立数组对象，保存每个平面的信息。 */ for (int i = 0; i < N; i++) { double x = Math.random(); double y = Math.random(); double x1 = x + average * Math.random(); double y1 = y + average * Math.random(); if (x1 > 1) { x1 = 1; } if (y1 > 1) { y1 = 1; } p[i][0] = new Point2D(x, y); p[i][1] = new Point2D(x1, y1); xinterval[i] = new Interval1D(x, x1); yinterval[i] = new Interval1D(y, y1); box[i] = new Interval2D(xinterval[i], yinterval[i]); box[i].draw(); /* * 检测时候相交 */ for (int i = 0; i < N - 1; i++) for (int j = i + 1; j < N; j++) { if (box[i].intersects(box[j])) { StdDraw.setPenColor(StdDraw.BLACK); box[i].draw(); box[j].draw(); // StdOut.println(box[i].toString()+box[j].toString()); } } /* * 是否包含 */ for (int i = 0; i < N - 1; i++) for (int j = i + 1; j < N; j++) { if (box[i].contains(p[j][0]) && box[i].contains(p[j][1])) { StdDraw.setPenRadius(0.005); StdDraw.setPenColor(StdDraw.BLUE); box[i].draw(); StdDraw.setPenColor(StdDraw.GREEN); box[j].draw(); StdOut.println("i=" + i + "j=" + j + " " + box[i].toString() + box[j].toString()); } } } } /* * 1.2.6 回环变位检测 * 1.2.7 递归返回值 */ public class CircularRotation { public CircularRotation() { // TODO Auto-generated constructor stub public static String mystery(String s) { int N=s.length(); if(N<=1) return s; String a=s.substring(0, N/2); String b=s.substring(N/2, N); StdOut.println(a+b); return mystery(b)+ mystery(a); } public static void main(String[] args) { // TODO Auto-generated method stub String s1 = "ACTGACG"; String s2 = "TGACGAC"; String ss; ss = s1.concat(s1); // int p=ss.indexOf(s2); if (s1.length() == s2.length() && ss.indexOf(s2) > 0) { StdOut.println("Yes!"); } else { StdOut.println("NO!"); StdOut.println(ss.indexOf(s2, ss.indexOf(s2)) + " " + ss.indexOf(s2)); } //测试mystery(s) ss="0123456789"; String a =mystery(ss); StdOut.println("a="+a); } } /*********************************************************************** ** * 1.2.9 * * * Compilation: javac BinarySearch.java * Execution: java BinarySearch whitelist.txt < input.txt * Data files: https://www.wendangku.net/doc/6f5986406.html,/11model/tinyW.txt * https://www.wendangku.net/doc/6f5986406.html,/11model/tinyT.txt * https://www.wendangku.net/doc/6f5986406.html,/11model/largeW.txt * https://www.wendangku.net/doc/6f5986406.html,/11model/largeT.txt * * % java BinarySearch tinyW.txt < tinyT.txt * 50 * 99 * 13 * * % java BinarySearch largeW.txt < largeT.txt | more * 499569 * 984875 * 295754 * 207807 * 140925 * 161828 * [367,966 total values] * *********************************************************************** **/ import java.util.Arrays; /** * The BinarySearch class provides a static method for binary searching * for an integer in a sorted array of integers. * * The rank operations takes logarithmic time in the worst case. * * For additional documentation, see * href="https://www.wendangku.net/doc/6f5986406.html,/11model">Section 1.1 of * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne. * * @author Robert Sedgewick * @author Kevin Wayne */ public class BinarySearch3 { /** * This class should not be instantiated. */ /** * Searches for the integer key in the sorted array a[]. * * @param key * the search key * @param a * the array of integers, must be sorted in ascending order * @return index of key in array a[] if present; -1 if not present */ public static int rank(int key, int[] a, Counter counter) { int lo = 0; int hi = a.length - 1; while (lo <= hi) { // Key is in a[lo..hi] or not present. int mid = lo + (hi - lo) / 2; if (key < a[mid]) { hi = mid - 1; counter.increment(); StdOut.println(" } else if (key > a[mid]) { lo = mid + 1; counter.increment(); StdOut.println(">c="+counter.tally()); } else { StdOut.println("c="+counter.tally()); return mid; } } return -1; } /** * Reads in a sequence of integers from the whitelist file, specified as a * command-line argument. Reads in integers from standard input and prints * to standard output those integers that do *not* appear in the file. */ public static void main(String[] args) { // read the integers from a file In in = new In("LargeW"); int[] whitelist = in.readAllInts(); Counter counter = new Counter("counter"); // sort the array Arrays.sort(whitelist); StdOut.println(whitelist.length); // read integer key from standard input; print if not in whitelist while (!StdIn.isEmpty()) { int key = StdIn.readInt(); if (rank(key, whitelist, counter) == -1) StdOut.println(key); } } } /* * 1.2.10 编写一个VisualCounter类，支持加一和减一操作。它的构造函数接受两个参数N和max， * 其中N指定了操作的最大次数，max指定了计数器的最大绝对值。作为副作用，用图像显示每次计数器变化后的值。 */ public class VisualCounter { private int count; private int maxOperation; private int val;// Record value of the Counter private int maxVal; private int x = 0; public VisualCounter(int N, int max) { maxOperation = N; maxVal = max; StdDraw.setXscale(0, N); StdDraw.setYscale(-max, max); StdDraw.setPenRadius(0.005); // TODO Auto-generated constructor stub } // current value /** * Initializes a new counter starting at 0, with the given id. * * @param id * the name of the counter */ /** * Increments the counter by 1. */ public void increment() { if (count < maxOperation && val < maxVal) { count++; val++; x++; StdDraw.setPenColor(StdDraw.BLACK); StdDraw.point(x, val); } } /** * decrement the counter by 1. */ public void decrement() { if (count < maxOperation && val > -maxVal) { count++; val--; x++; StdDraw.setPenColor(StdDraw.RED); StdDraw.point(x, val); } } /** * Returns the current count. */ public int tally() { return count; } /** * Returns a string representation of this counter */ public String toString() { return count + " "; } public static void main(String[] args) { VisualCounter VC = new VisualCounter(2000, 1000); for (int i = 0; i < 2000; i++) { if (i / 1000 == 1) VC.decrement(); else VC.increment(); } StdOut.println(VC.tally()); } } /* * 1.2.11根据Date的API实现SmartDate类型在日期非法时抛出一个异常 * 1.2.12为SmartDate添加一个方法dayofWeek()，为日期返回一个星期。 * 1.2.19字符串解析。 */ public class SmartDate implements Datable { private final int month; private final int day; private final int year; public int month() { return month; } public int day() { return day; } public int year() { return year; } /* * 原理：蔡勒公式: W={[C/4]-2C+y+[y/4]+[26(m+1)/10]+d-1}%7 （其中[ ]为取整符号） * 其中,W是所求日期的星期数.如果求得的数大于7,可以减去7的倍数,直到余数小于7为止.c是公元年份 * 的前两位数字,y是已知公元年份的后两位数字;m是月数,d是日数.方括[ ]表示只截取该数的整数部分。 */ public String dayofWeek() { int w = (year / 100 / 4 - 2 * (year / 100) + year % 100 + year % 100 / 4 + 26 * (month + 1) / 10 + day - 1) % 7; switch (w) { case 1: return"Monday"; case 2: return"Tuseday"; case 3: return"Wednesday"; case 4: return"Thursday"; case 5: return"Friday"; case 6: return"Saturday"; default: return"Sunday"; } } private static boolean isLeapYear(int y) { return ((y % 4 == 0 && y % 100 != 0) || y % 400 == 0); } private boolean isIllegal(int m, int d, int y) { if (y < 0 || d < 1 || d > 31) return false; if (m > 12 || m < 0) return false; int[] monthofday = { 0, 31, -1, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; if (isLeapYear(y)) { monthofday[2] = 29; } else { monthofday[2] = 28; } if (d > monthofday[m]) return false; else return true; } public SmartDate(int m, int d, int y) { if (!isIllegal(m, d, y)) { throw new IllegalArgumentException("Illegal date"); } else { month = m; day = d; year = y; } } public String toString() { return (month() + "/" + day() + "/" + year()); } /* * 大于返回1，等于返回0，小于返回-1； */ public int comparaTo(SmartDate that){ if(this.year()==that.year()&&this.month()==that.month()&&this.day()= =that.day()) return 0; if(this.year()>that.year()) return 1; if(this.month()>that.month()) return 1; if(this.day()>that.day()) return 1; return -1; } public boolean equals(Object x) { if (this == x) return true; if (x == null) return false; if (this.getClass() != x.getClass()) return false; SmartDate that = (SmartDate) x; if (this.day != that.day) return false; if (this.month != that.month) return false; if (this.year != that.year) return false; return true; } } /* * 1.2.13 实现Transaction模版 * 1.2.14 实现Transaction模版equals()方法 * 1.2.19 字符串解析。 */ public class Transaction { private String who; private SmartDate when; private double amount; public Transaction(String who, SmartDate when, double amount) { // TODO Auto-generated constructor stub if (who == null) throw new IllegalArgumentException("Illegal date"); this.who = who; this.when = when; this.amount = amount; } public String toString() { return (who + " " + when.toString() + " " + amount); } public String getWho() { return who; } public void setWho(String who) { this.who = who; } public SmartDate getWhen() { return when; } public void setWhen(SmartDate when) { this.when = when; } public double getAmount() { return amount; } public void setAmount(double amount) { this.amount = amount; } public boolean equals(Object x) { if (this == x) return true; if (x == null) return false; if (this.getClass() != x.getClass()) return false; Transaction that = (Transaction) x; if (this.who !=that.who) return false; if (this.when != that.when) return false; if (this.amount != that.amount) return false; return true; } public int compareTo(Transaction that) { return https://www.wendangku.net/doc/6f5986406.html,paraTo(that.when); } public int hashCode(){ return this.toString().hashCode(); } } /* * 1.2.16 有理数，实现有理数的加减乘除。 * 1.2.17 有理数的健壮性，使用断言来防止溢出 * */ public class Rational implements Comparable private int num;// 分子 private int den;// 分母 private int INT_max = 2147483647; private int INT_min = -2147483647; private static Rational zero = new Rational(0, 1); public Rational(int numerator, int denominator) { // TODO Auto-generated constructor stub if (denominator == 0) { throw new RuntimeException("Denominator is zero"); } int g = gcd(numerator, denominator); num = numerator / g; den = denominator / g; if (den < 0) { den = -den; num = -num; } } public int numerator() { return num; } public int denominator() { return den; } private int gcd(int numerator, int denominator) { if (numerator < 0) numerator = -numerator; if (denominator < 0) denominator = -denominator; if (denominator == 0) return numerator; return gcd(denominator, numerator % denominator); } /* * 计算最小公倍数 */ private int lcm(int m, int n) { if (m < 0) m = -m; if (n < 0) n = -n; if (n == 0) return m; else { int g = gcd(m, n); assert is_overflow_times(m,n/g):"lcm times overflow"; return m * (n / g); } } public double todouble() { return (double) num / den; } public String toString() { if (den == 1) return num + ""; return num + "/" + den; } /* * (non-Javadoc) * * @see https://www.wendangku.net/doc/6f5986406.html,parable#compareTo(https://www.wendangku.net/doc/6f5986406.html,ng.Object) 大于返回1，小于返回-1，等于返回0； */ public int compareTo(Rational that) { // TODO Auto-generated method stub int lhs = this.num * that.den; int rhs = this.den * that.num; if (lhs < rhs) return -1; if (lhs > rhs) return 1; return 0; } public boolean equals(Object Y) { if (Y == null) return false; if (Y.getClass() != this.getClass()) return false; Rational b = (Rational) Y; return https://www.wendangku.net/doc/6f5986406.html,pareTo(b) == 0; } /* * 判断加法溢出,如果溢出返回ture,不溢出返回flase; */ private boolean is_overflow_plus(int a, int b) { return a >= 0 ? INT_max - a > b : INT_min - a < b; } /* * 判断乘法溢出,如果溢出返回ture,不溢出返回flase; * * */ private boolean is_overflow_times(int a, int b) { if(a<0) a=-a; if(b<0) b=-b; if (a == 0||b==0) return false; else return INT_max / a > b; } public Rational times(Rational that) { Rational c = new Rational(this.num, that.den); Rational d = new Rational(that.num, this.den); assert is_overflow_times(c.num , d.num):"times overflow"; assert is_overflow_times(c.den , d.den):"times overflow"; return new Rational(c.num * d.num, c.den * d.den); } public Rational plus(Rational that) { if (https://www.wendangku.net/doc/6f5986406.html,pareTo(zero) == 0) { return that; } if (https://www.wendangku.net/doc/6f5986406.html,pareTo(zero) == 0) { return this; } int f = gcd(this.num, that.num); int g = gcd(this.den, that.den); assert is_overflow_plus((this.num / f) * (that.den / g), (that.num / f) 第一章 误差 1. 试举例,说明什么是模型误差,什么是方法误差. 解: 例如,把地球近似看为一个标准球体,利用公式2 4A r π=计算其表面积,这个近似看为球体的过程产生 的误差即为模型误差. 在计算过程中,要用到π,我们利用无穷乘积公式计算π的值: 12 222...q q π=? ?? 其中 11 2,3,... n q q n +?=?? ==?? 我们取前9项的乘积作为π的近似值,得 3.141587725...π≈ 这个去掉π的无穷乘积公式中第9项后的部分产生的误差就是方法误差,也成为截断误差. 2. 按照四舍五入的原则,将下列各数舍成五位有效数字: 816.956 7 6.000 015 17.322 50 1.235 651 93.182 13 0.015 236 23 解: 816.96 6.000 0 17.323 1.235 7 93.182 0.015 236 3. 下列各数是按照四舍五入原则得到的近似数,它们各有几位有效数字? 81.897 0.008 13 6.320 05 0.180 0 解: 五位 三位 六位 四位 4. 若1/4用0.25表示,问有多少位有效数字? 解: 两位 5. 若 1.1062,0.947a b ==,是经过舍入后得到的近似值,问:,a b a b +?各有几位有效数字? 解: 已知4311 d 10,d 1022 a b -- 第1章程序设计和C语言1 什么是计算机程序1 什么是计算机语言1 语言的发展及其特点3 最简单的C语言程序5 最简单的C语言程序举例6 语言程序的结构10 运行C程序的步骤与方法12 程序设计的任务14 1-5 #include <> int main ( ) { printf ("**************************\n\n"); printf(" Very Good!\n\n"); printf ("**************************\n"); return 0; } 1-6#include <> int main() {int a,b,c,max; printf("please input a,b,c:\n"); scanf("%d,%d,%d",&a,&b,&c); max=a; if (max 怎样表示一个算法22 用自然语言表示算法22 用流程图表示算法22 三种基本结构和改进的流程图26 用N S流程图表示算法28 用伪代码表示算法31 用计算机语言表示算法32 结构化程序设计方法34 习题36 第章最简单的C程序设计——顺序程序设计37 顺序程序设计举例37 数据的表现形式及其运算39 常量和变量39 数据类型42 整型数据44 字符型数据47 浮点型数据49 怎样确定常量的类型51 运算符和表达式52 语句57 语句的作用和分类57 最基本的语句——赋值语句59 数据的输入输出65 输入输出举例65 有关数据输入输出的概念67 用printf函数输出数据68 用scanf函数输入数据75 字符数据的输入输出78 习题82 3-1 #include <> #include <> int main() {float p,r,n; r=; n=10; p=pow(1+r,n); printf("p=%f\n",p); return 0; } 2.1 用二分法求方程013=--x x 在[1, 2]的近似根，要求误差不超过3102 1-?至少要二分多少？ 解：给定误差限ε＝0.5×10－3，使用二分法时，误差限为 )(211*a b x x k k -≤-+ 只要取k 满足ε<-+)(2 11 a b k 即可，亦即 96678.912lg 10lg 35.0lg 12lg lg )lg(=-+-=---≥εa b k 只要取n ＝10. 2.3 证明方程1 -x –sin x ＝0 在区间[0, 1]内有一个根，使用二分法求误差不超过 0.5×10-4的根要二分多少次？ 证明 令f (x )＝1－x －sin x ， ∵ f (0)=1>0，f (1)=－sin1<0 ∴ f (x )=1－x －sin x =0在[0，1]有根.又 f '(x )=-1－c os x<0 (x ∈[0.1]),故f (x ) 在[0，1]单调减少，所以f (x ) 在区间 [0，1]内有唯一实根. 给定误差限ε＝0.5×10－4，使用二分法时，误差限为 )(211*a b x x k k -≤-+ 只要取k 满足ε<-+)(211 a b k 即可，亦即 7287.1312 lg 10lg 45.0lg 12lg lg )lg(=-+-=---≥εa b k 只要取n ＝14. 2.4 方程0123=--x x 在x =1.5附近有根，把方程写成四种不同的等价形式，并建立相应的迭代公式： （1）211x x +=，迭代公式2111k k x x +=+ （2）231x x +=，迭代公式3211k k x x +=+ （3）112-=x x ，迭代公式111-=+k k x x （4）13-=x x ，迭代公式131-=+k k x x 试分析每种迭代公式的收敛性，并选取一种收敛迭代公式求出具有四位有效数字的近似根。 解：（1）令211)(x x f + =，则3 2)(x x f -='，由于 159.05.112)(33<≈≤='x x f ，因而迭代收敛。 （2）令321)(x x f +=，则322)1(3 2)(-+='x x x f ，由于 第1章程序设计和C语言1 1.1什么是计算机程序1 1.2什么是计算机语言1 1.3C语言的发展及其特点3 1.4最简单的C语言程序5 1.4.1最简单的C语言程序举例6 1.4.2C语言程序的结构10 1.5运行C程序的步骤和方法12 1.6程序设计的任务14 1-5 #include 第章最简单的C程序设计——顺序程序设计37 3.1顺序程序设计举例37 3.2数据的表现形式及其运算39 3.2.1常量和变量39 3.2.2数据类型42 3.2.3整型数据44 3.2.4字符型数据47 3.2.5浮点型数据49 3.2.6怎样确定常量的类型51 3.2.7运算符和表达式52 3.3C语句57 3.3.1C语句的作用和分类57 3.3.2最基本的语句——赋值语句59 3.4数据的输入输出65 3.4.1输入输出举例65 3.4.2有关数据输入输出的概念67 3.4.3用printf函数输出数据68 3.4.4用scanf函数输入数据75 3.4.5字符数据的输入输出78 习题82 3-1 #include 《计算方法》习题答案 第一章 数值计算中的误差 1．什么是计算方法？（狭义解释） 答：计算方法就是将所求的的数学问题简化为一系列的算术运算和逻辑运算，以便在计算机上编程上机，求出问题的数值解，并对算法的收敛性、稳定性和误差进行分析、计算。 2．一个实际问题利用计算机解决所采取的五个步骤是什么？ 答：一个实际问题当利用计算机来解决时，应采取以下五个步骤： 实际问题→建立数学模型→构造数值算法→编程上机→获得近似结果 4．利用秦九韶算法计算多项式4)(5 3 -+-=x x x x P 在3-=x 处的值，并编程获得解。 解：400)(2 3 4 5 -+?+-?+=x x x x x x P ，从而 所以，多项式4)(5 3 -+-=x x x x P 在3-=x 处的值223)3(-=-P 。 5．叙述误差的种类及来源。 答：误差的种类及来源有如下四个方面： （1）模型误差：数学模型是对实际问题进行抽象，忽略一些次要因素简化得到的，它是原始问题的近似，即使数学模型能求出准确解，也与实际问题的真解不同，我们把数学模型与实际问题之间存在的误差称为模型误差。 （2）观测误差：在建模和具体运算过程中所用的一些原始数据往往都是通过观测、实验得来的，由于仪器的精密性，实验手段的局限性，周围环境的变化以及人们的工作态度和能力等因素，而使数据必然带有误差，这种误差称为观测误差。 （3）截断误差：理论上的精确值往往要求用无限次的运算才能得到，而实际运算时只能用有限次运算的结果来近似，这样引起的误差称为截断误差（或方法误差）。 （4）舍入误差：在数值计算过程中还会用到一些无穷小数，而计算机受机器字长的限制，它所能表示的数据只能是一定的有限数位，需要把数据按四舍五入成一定位数的近似的有理数来代替。这样引起的误差称为舍入误差。 6．掌握绝对误差（限）和相对误差（限）的定义公式。 答：设* x 是某个量的精确值，x 是其近似值，则称差x x e -=* 为近似值x 的绝对误差（简称误差）。若存在一个正数ε使ε≤-=x x e * ，称这个数ε为近似值x 的绝对误差限（简称误差限或精度）。 把绝对误差e 与精确值* x 之比* **x x x x e e r -==称为近似值x 的相对误差，称 计算方法第3版习题答案 习题1解答 1.1 解：直接根据定义得 *411()102x δ-≤?*411()102r x δ-≤?*3*12211 ()10,()1026 r x x δδ--≤?≤?*2*5331()10,()102r x x δδ--≤?≤ 1.2 解：取4位有效数字 1.3解：433 5124124124 ()()() 101010() 1.810257.563 r a a a a a a a a a δδδδ----++++++≤≤=?++? 123()r a a a δ≤ 123132231123 ()()() a a a a a a a a a a a a δδδ++0.016= 1.4 解：由于'1(),()n n f x x f x nx -==，故***1*(())()()()n n n f x x x n x x x δ-=-≈- 故** * ***(()) (())()0.02()r r n f x x x f x n n x n x x δδδ-= ≈== 1.5 解： 设长、宽和高分别为 ***50,20,10l l h h εεωωεεεε=±=±=±=±=±=± 2()l lh h ωωA =++，*************()2[()()()()()()]l l l h h l h h εδωωδδδωδδωA =+++++ ***4[]320l h εωε=++= 令3201ε<，解得0.0031ε≤， 1.6 解：设边长为x 时，其面积为S ，则有2()S f x x ==，故 '()()()2()S f x x x x δδδ≈= 现100,()1x S δ=≤，从而得() 1 ()0.00522100 S x x δδ≈ ≤ =? 1.7 解：因S ld =，故 S d l ?=?，S l d ?=?，*****()()()()()S S S l d l d δδδ??≈+?? * 2 ()(3.12 4.32)0.010.0744S m δ=+?=, *** ** * () () 0.0744 ()0.55%13.4784 r S S S l d S δδδ= = = ≈ 1.8 解：（1）4.472 （2）4.47 1.9 解：(1) （B ）避免相近数相减 (2)（C ）避免小除数和相近数相减 (3)（A ）避免相近数相减 (3)（C ）避免小除数和相近数相减，且节省对数运算 1.10 解 （1）357sin ...3!5!7!x x x x x =-+-+ 故有357 sin ..3!5!7! x x x x x -=-+-， （2） 1 (1)(1)1lnxdx ln ln ln N+N =N N +-N N +N +-? 1 (1)1ln ln N +=N +N +-N 1.11 解：0.00548。 1.12解：21 16 27 3102 ()()() -? 1.13解：0.000021 第三章处理机调度与死锁 1，高级调度与低级调度的主要任务是什么？为什么要引入中级调度？ 【解】（1）高级调度主要任务是用于决定把外存上处于后备队列中的那些作业调入内存，并为它们创建进程，分配必要的资源，然后再将新创建的进程排在就绪队列上，准备执行。（2）低级调度主要任务是决定就绪队列中的哪个进程将获得处理机，然后由分派程序执行把处理机分配给该进程的操作。（3）引入中级调度的主要目的是为了提高内存的利用率和系统吞吐量。为此，应使那些暂时不能运行的进程不再占用宝贵的内存空间，而将它们调至外存上去等待，称此时的进程状态为就绪驻外存状态或挂起状态。当这些进程重又具备运行条件，且内存又稍有空闲时，由中级调度决定，将外存上的那些重又具备运行条件的就绪进程重新调入内存，并修改其状态为就绪状态，挂在就绪队列上，等待进程调度。 3、何谓作业、作业步和作业流？ 【解】作业包含通常的程序和数据，还配有作业说明书。系统根据该说明书对程序的运行进行控制。批处理系统中是以作业为基本单位从外存调入内存。作业步是指每个作业运行期间都必须经过若干个相对独立相互关联的顺序加工的步骤。 作业流是指若干个作业进入系统后依次存放在外存上形成的输入作业流；在操作系统的控制下，逐个作业进程处理，于是形成了处理作业流。 4、在什么情冴下需要使用作业控制块JCB？其中包含了哪些内容？ 【解】每当作业进入系统时，系统便为每个作业建立一个作业控制块JCB，根据作业类型将它插入到相应的后备队列中。 JCB 包含的内容通常有：1) 作业标识2)用户名称3)用户账户4)作业类型（CPU 繁忙型、I/O芳名型、批量型、终端型）5)作业状态6)调度信息（优先级、作业已运行）7)资源要求8)进入系统时间9) 开始处理时间10) 作业完成时间11) 作业退出时间12) 资源使用情况等 5．在作业调度中应如何确定接纳多少个作业和接纳哪些作业？ 【解】作业调度每次接纳进入内存的作业数，取决于多道程序度。应将哪些作业从外存调入内存，取决于采用的调度算法。最简单的是先来服务调度算法，较常用的是短作业优先调度算法和基于作业优先级的调度算法。 7．试说明低级调度的主要功能。 【解】（1）保存处理机的现场信息（2）按某种算法选取进程（3）把处理机分配给进程。 8、在抢占调度方式中，抢占的原则是什么？ 【解】剥夺原则有：（1）时间片原则各进程按时间片运行，当一个时间片用完后，便停止该进程的执行而重新进行调度。这种原则适用于分时系统、大多数实时系统，以及要求较高的批处理系统。（2）优先权原则通常是对一些重要的和紧急的作业赋予较高的优先权。当这种作业到达时，如果其优先权比正在执行进程的优先权高，便停止正在执行的进程，将处理机分配给优先权高的进程，使之执行。（3）短作业（进程）优先原则当新到达的作业（进程）比正在执行的作业（进程）明显地短时，将剥夺长作业（进程）的执行，将处理机分配给短作业（进程），使之优先执行。 9、选择调度方式和调度算法时，应遵循的准则是什么？ 【解】应遵循的准则有（1）面向用户的准则：周转时间短，响应时间快，截止时间的保证，优先权准则。（2）面向系统的准则：系统吞吐量高，处理机利用率好，各类资源的平衡利用。 10、在批处理系统、分时系统和实时系统中，各采用哪几种进程（作业）调度算法？ 【解】 批处理系统：FCFS算法、最小优先数优先算法、抢占式最小优先数优先算法 2 分时系统：可剥夺调度、轮转调度 实时系统：时间片轮转调度算法、非抢占优先权调度算法、基于时钟中断抢占的优先权调度算法、立即抢占的优先权调度。 11、何谓静态和动态优先权？确定静态优先权的依据是什么？ 【解】静态优先权是在创建进程时确定的，且在进程的整个运行期间保持不变。动态优先权是指，在创建进程时所赋予的优先权，是可以随进程的推进或随其等待时间的增加而改变的，以便获得更好的调度性能。确定静态优先权的依据是：（1）进程类型，通常系统进程的优先权高于一般用户进程的优先权。（2）进程对资源的需要。（3）用户要求，用户进程的紧迫程度及用户所付费用的多少来确定优先权的。 12、试比较FCFS和SPF两种进程调度算法。 【解】FCFS算法按照作业提交或进程变为就绪状态的先后次序，分派CPU。当前作业或进程占有CPU，直到执行完或阻塞，才让出CPU。在作业或进程唤醒后，并不立即恢复执行，通常等到当前作业或进程让出CPU。FCFS比较有利于长作业，而不利于短作业；有利于CPU繁忙的作业，而不利于I/O繁忙的作业。SPF有利于短进程调度，是从就绪队列中选出一估计运行时间最短的进 《管理运筹学》第四版课后习题解析（下） 第9章 目 标 规 划 1、解： 设工厂生产A 产品1x 件，生产B 产品2x 件。按照生产要求，建立如下目标规划模型。 112212121211122212min ()() s.t 43452530 555086100 ,,,0,1,2 -- +-+-+-++++-+=+-+==i i P d P d x x x x x x d d x x d d x x d d i ≤≤≥ 由管理运筹学软件求解得 12121211.25,0,0,10, 6.25,0x x d d d d --++ ====== 由图解法或进一步计算可知，本题在求解结果未要求整数解的情况下，满意解有无穷多个，为线段(135/14,15/7)(1)(45/4,0),[0,1]ααα+-∈上的任一点。 2、解： 设该公司生产A 型混凝土x 1吨，生产B 型混凝土x 2吨，按照要求建立如下的目标规划模型。 ) 5,,2,1(0,,0,0145 50.060.015550.040.030000100150100 120275200.)()(min 2121215521442331222111215443 32 211 1 =≥≥≥≤+≤+=-++=-+=-+=-++=-++++++++-+-+-+-+-+-- - - + +- i d d x x x x x x d d x x d d x d d x d d x x d d x x t s d p d d p d p d d p i i 由 管 理 运 筹 学 软 件 求 解 得 . 0,0,20,0,0,0, 0,35,40,0,120,120554433221121============+-+-+-+-+-d d d d d d d d d d x x 第5章算法与复杂性 习题 一、选择题 1. B 2. D 3. C 4. A 5. B 6. B 7. D 8.B 9.C 10.A 11.A 12.C 13.A 14.A 二、简答题 1．什么是算法，算法的特性有哪些？ 答：“算法(Algorithm)是一组明确的、可以执行的步骤的有序集合，它在有限的时间内终止并产生结果”。算法的特性有： (1) 有穷性(可终止性)：一个算法必须在有限个操作步骤内以及合理的有限时间内执行完成。 (2) 确定性：算法中的每一个操作步骤都必须有明确的含义，不允许存在二义性。 (3) 有效性(可执行性)：算法中描述的操作步骤都是可执行的，并能最终得到确定的结果。 (4) 输入及输出：一个算法应该有零个或多个输入数据、有1个或多个输出数据。 2．什么是算法的时间复杂度和空间复杂度，如何表示？ 答：时间复杂度是与求解问题规模、算法输入相关的函数，该函数表示算法运行所花费的时间。记为，T(n)，其中，n代表求解问题的规模。 算法的空间复杂度(Space complexity)度量算法的空间复杂性、即执行算法的程序在计算机中运行所占用空间的大小。简单讲，空间复杂度也是与求解问题规模、算法输入相关的函数。记为，S(n)，其中，n代表求解问题的规模。 时间复杂度和空间复杂度同样，引入符号“O”来表示T(n)、S(n)与求解问题规模n之间的数量级关系。 3．用图示法表示语言处理的过程。 答：语言处理的过程如图所示： 4．简述算法设计的策略。 答：作为实现计算机程序实现时解决问题的方法，算法研究的内容是解决问题的方法，而不是计算机程序的本身。一个优秀的算法可以运行在比较慢的计算机上，但一个劣质的算法在一台性能很强的计算机上也不一定能满足应用的需要，因此，在计算机程序设计中，算法设计往往处于核心地位。 要想充分理解算法并有效地应用于实际问题，关键是对算法的分析。通常可以利用实验对比分析、数学方法来分析算法。实验对比分析很简单，两个算法相互比较，它们都能解决同一问题，在相同环境下，一般就会认为哪个算法的速度快这个算法性能更好。在算法设计中，通常采用能近似表达性能的方法来展示某个算法的性能指标。例如，计算机对2n 和22n n 的响应速度，当n 比较大的时,没什么区别，便可直接认为后者算法的复杂度为2n 。 基于算法复杂度简化表达的思想基础上，通常会对算法进行最坏情况分析和平均情况分析。对于一个给定的算法，如果能保证它的最坏情况下的性能依然很好，但是在某些情况下，程序的最坏情况算法的运行时间和实际情况的运行时间相差很大，在实际应用中几乎不会碰到最坏情况下的输入，那么此时进行最坏情况分析显得有些画蛇添足，特别是分析最坏情况算法会花费大量精力的时候。算法的平均情况分析可以帮助估计程序的性能，作为算法分析的基本指标之一，但是平均情况和实际情况仍然会有相差很大的时候，这时便可以使用随机法来尽量模拟现实中的情况，这样可以得到在严格的概率意义上的预测运行时间。另外，对于一个经典算法，没有必要再去对该算法进行改进，研究它的上界和下界，只需要了解该算法的特性，然后在合适的时候使用它。 5．简述并行算法研究的内容。 答：(1) 并行计算模型并行算法作为一门学科，首先研究的是并行计算模型。并行计算模型是算法设计者与体系结构研究者之间的一个桥梁，是并行算法设计和分析的基础。它屏蔽了并行机之间的差异，从并行机中抽取若干个能反映计算特性的可计算或可测量的参数，并按照模型所定义的计算行为构造成本函数，以此进行算法的复杂度分析。 算法-第四版-习题-答案 1.1.1 给出以下表达式的值： a. ( 0 + 15 ) / 2 b. 2.0e-6 * 100000000.1 c. true && false || true && true 答案：a.7,b.200.0000002 c.ture 1.1.2 给出以下表达式的类型和值： a. (1 + 2.236)/2 b. 1 + 2 + 3 + 4.0 c. 4.1 >= 4 d. 1 + 2 + "3" 答案：a.1.618 b. 10.0 c.true d.33 1.1.3 编写一个程序，从命令行得到三个整数参数。如果它们都相等则打印equal，否则打印not equal。 public class TestUqual { public static void main(String[] args) { int a,b,c; a=b=c=0; StdOut.println("Please enter three numbers"); a =StdIn.readInt(); b=StdIn.readInt(); c=StdIn.readInt(); if(equals(a,b,c)==1) { StdOut.print("equal"); } else { StdOut.print("not equal"); } } public static int equals(int a ,int b , int c) { if(a==b&&b==c) { return 1; } else { return 0; } } } 1.1.4 下列语句各有什么问题（如果有的话）？ a. if (a > b) then c = 0; b. if a > b { c = 0; } c. if (a > b) c = 0; d. if (a > b) c = 0 else b = 0; 答案：a. if (a > b) c = 0; b. if (a > b) { c = 0; } 1.1.5 编写一段程序，如果double 类型的变量x 和y 都严格位于0 和1 之间则打印true，否则打印false。 public class TestUqual { public static void main(String[] args) { double x; 第五章 7.试比较缺页中断机构与一般的中断，他们之间有何明显的区别？ 答：缺页中断作为中断，同样需要经历保护CPU现场、分析中断原因、转缺页中断处理程序进行处理、恢复CPU现场等步骤。但缺页中断又是一种特殊的中断，它与一般中断的主要区别是： （ 1）在指令执行期间产生和处理中断信号。通常，CPU都是在一条指令执行完后去检查是否有中断请求到达。若有便去响应中断；否则继续执行下一条指令。而缺页中断是在指令执行期间，发现所要访问的指令或数据不在内存时产生和处理的。 (2)一条指令在执行期间可能产生多次缺页中断。例如，对于一条读取数据的多字节指令，指令本身跨越两个页面，假定指令后一部分所在页面和数据所在页面均不在内存，则该指令的执行至少产生两次缺页中断。 8.试说明请求分页系统中的页面调入过程。 答：请求分页系统中的缺页从何处调入内存分三种情况： （1）系统拥有足够对换区空间时，可以全部从对换区调入所需页面，提高调页速度。在进程运行前将与该进程有关的文件从文件区拷贝到对换区。 （2）系统缺少足够对换区空间时，不被修改的文件直接从文件区调入；当换出这些页面时，未被修改的不必换出，再调入时，仍从文件区直接调入。对于可能修改的，在换出时便调到对换区，以后需要时再从对换区调入。 （3）UNIX 方式。未运行页面从文件区调入。曾经运行过但被换出页面，下次从对换区调入。UNIX 系统允许页面共享，某进程请求的页面有可能已调入内存，直接使用不再调入。 19.何谓工作集？它是基于什么原理确定的？ 答：工作集：在某段时间间隔里，进程实际所要访问页面的集合。 原理：用程序的过去某段时间内的行为作为程序在将来某段时间内行为的近似。 24.说明请求分段式系统中的缺页中断处理过程。 答：在请求分段系统中，每当发现运行进程所要访问的段尚未调入内存时，便由缺段中断机构产生一缺段中断信号，进入操作系统后由缺段中断处理程序将所需的段调入内存。缺段中断机构与缺页中断机构类似，它同样需要在一条指令的执行期间，产生和处理中断，以及在一条指令执行期间，可能产生多次缺段中断。 第六章练习题及参考解答 表是中国1985-2016年货物进出口贸易总额（）与国内生产总值（）的数据。 表中国进出口贸易总额和国内生产总值 单位：亿元 年份 货物进出口贸 易总额（Y） 国内生产总值 （X） 年份货物进出口贸 易总额（Y） 国内生产总值 （X） 19852001 19862002 19872003 19882004 19892005 19902006 19912007 19922008 19932009 19942010 19952011 19962012 1997 1998 1999 20002013 2014 2015 2016 （1）建立货物进出口贸易总额的对数对国内生产总值的对数的回归方程； （2）检测模型的自相关性； （3）采用广义差分法处理模型中的自相关问题。 【练习题参考解答】 回归结果 自相关检验 ①图示法 图1、2 与的散点图以及模型残差图 由上面两个图可以发现模型残差存在惯性表现，很可能存在正自相关。 ②DW检验 由回归结果可知DW统计量为，同时，在的显着性水平下，，因而模型中存在正相关。 ③BG检验 阶数5432 AIC SIC 滞后阶数从5阶减小到2阶，AIC及SIC达到最小时，滞后阶数为2阶，此时，已知，，同时P值为，在的显着性水平下拒绝原假设，即存在自相关。 表2 BG检验2阶回归结果 自相关补救 ①DW反算法求 由，可知，可得广义差分方程： 表3 广义差分结果-DW反算法 DW检验：由回归结果可知DW统计量为，同时，在的显着性水平下， ，即已消除自相关。 BG 阶数5432 AIC SIC 滞后阶数从5阶减小到2阶，AIC及SIC达到最小时，滞后阶数为2阶，此时，已知，，同时P值为，在的显着性水平下不拒绝原假设，即已消除自相关。 表4 广义差分BG检验2阶回归结果 则可知， 最终模型为： 练习题与答案 练习题一 练习题二 练习题三 练习题四 练习题五 练习题六 练习题七 练习题八 练习题答案 练习题一 一、是非题 1.*x=–1 2.0326作为x的近似值一定具有6位有效数字，且其误差限 ≤ 4 10 2 1 - ? 。() 2.对两个不同数的近似数，误差越小，有效数位越多。( ) 3.一个近似数的有效数位愈多，其相对误差限愈小。( ) 4.用 2 1 2 x - 近似表示cos x产生舍入误差。( ) 5. 3.14和 3.142作为π的近似值有效数字位数相同。 ( ) 二、填空题 1. 为了使计算 ()()2334912111y x x x =+ -+ ---的乘除法次数尽量少，应将该 表达式改写为 ； 2. * x =–0.003457是x 舍入得到的近似值，它有 位有效数字，误差限 为 ，相对误差限为 ； 3. 误差的来源是 ； 4. 截断误差为 ； 5. 设计算法应遵循的原则是 。 三、选择题 1．* x =–0.026900作为x 的近似值，它的有效数字位数为( ) 。 (A) 7； (B) 3； (C) 不能确定 (D) 5. 2．舍入误差是( )产生的误差。 (A) 只取有限位数 (B) 模型准确值与用数值方法求得的准确值 (C) 观察与测量 (D) 数学模型准确值与实际值 3．用 1+x 近似表示e x 所产生的误差是( )误差。 (A). 模型 (B). 观测 (C). 截断 (D). 舍入 4．用s *=21 g t 2表示自由落体运动距离与时间的关系式 (g 为重力加速度)，s t 是在 时间t 内的实际距离，则s t - s *是（ ）误差。 (A). 舍入 (B). 观测 (C). 模型 (D). 截断 5．1.41300作为2的近似值，有( )位有效数字。 (A) 3； (B) 4； (C) 5； (D) 6。 四、计算题 第一章 1、 在下列各对数中，x 是精确值 a 的近似值。 3 .14,7/100)4(143 .0,7/1)2(0031 .0,1000/)3(1.3,)1(========x a x a x a x a ππ 试估计x 的绝对误差和相对误差。 解：（1）0132.00416 .01.3≈= ≈-= -=a e e x a e r π （2）0011.00143 .0143.07/1≈= ≈-=-=a e e x a e r （3）0127.000004 .00031.01000/≈= ≈-=-=a e e x a e r π （4）001.00143 .03.147/100≈= ≈-=-=a e e x a e r 2. 已知四个数：x 1=26.3，x 2=0.0250， x 3= 134.25，x 4=0.001。试估计各近似数的有效位数和误差限，并估计运算μ1= x 1 x 2 x 3和μ1= x 3 x 4 /x 1的相对误差限。 解：x 1=26.3 ｎ=3 δx 1=0.05 δr x 1=δx 1/∣x 1∣=0.19011×10-2 x 2=0.0250 ｎ=3 δx 2=0.00005 δr x 2=δx 2/∣x 2∣=0.2×10-2 x 3= 134.25 ｎ=5 δx 3=0.005 δr x 3=δx 3/∣x 3∣=0.372×10 -4 x 4=0.001 ｎ=1 δx 4=0.0005 δr x 4=δx 4/∣x 4∣=0.5 由公式：e r （μ）= e （μ）/∣μ∣≦1/∣μ∣Σn i=1∣?f/?x i ∣δx i e r （μ1）≦1/∣μ1∣［x 2 x 3δx 1+ x 1 x 3δx 2 +x 1 x 2δx 3］ =0.34468/88.269275 =0.0039049 e r （μ2）≦1/∣μ2∣［x 3 x 4/ x 21δx 1+ x 4/ x 1δx 3 + x 3 / x 1δx 4］ =0.501937 3、设精确数ａ>0，x 是ａ的近似值，x 的相对误差限是0.2，求㏑x 的相对误差限。 解：设=()u f x ， ()()()()() ()||||||||||()||()|| | |()||()||||r r r x e u df x e x df x e x e u u dx u dx u x df x x df x x e x x dx u dx u δ= ≈==≤ ()||10.2 (())| |()||ln ln ln r r r r df x x x x f x x x dx u x x x x δδδδ==??== 第一章 误差 1. 试举例,说明什么是模型误差,什么是方法误差. 解: 例如,把地球近似看为一个标准球体,利用公式2 4A r π=计算其表面积,这个近似看为球体的过程产生的误差即为模型误差. 在计算过程中,要用到π,我们利用无穷乘积公式计算π的值: 其中 我们取前9项的乘积作为π的近似值,得 这个去掉π的无穷乘积公式中第9项后的部分产生的误差就是方法误差,也成为截断误差. 2. 按照四舍五入的原则,将下列各数舍成五位有效数字: 816.956 7 6.000 015 17.322 50 1.235 651 93.182 13 0.015 236 23 解: 816.96 6.000 0 17.323 1.235 7 93.182 0.015 236 3. 下列各数是按照四舍五入原则得到的近似数,它们各有几位有效数字? 81.897 0.008 13 6.320 05 0.180 0 解: 五位 三位 六位 四位 4. 若1/4用0.25表示,问有多少位有效数字? 解: 两位 5. 若 1.1062,0.947a b ==,是经过舍入后得到的近似值,问:,a b a b +?各有几位有效数字? 解: 已知4311 d 10,d 1022 a b --< ? 数值分析 （p11页） 4 试证：对任给初值x 0, 0)a >的牛顿迭代公式 112(),0,1 ,2,......k a k k x x x k +=+= 恒成立下列关系式： 2112(1)(,0,1,2,.... (2)1,2,...... k k k x k x x k x k +-=≥= 证明： （1 ）(2 1122k k k k k k x a x x x x +-??=+= =? ?? （2） 取初值00>x ，显然有0>k x ，对任意0≥k ， a a x a x x a x x k k k k k ≥+??? ? ??-=???? ??+=+2 12121 6 证明： 若k x 有n 位有效数字，则n k x -?≤ -1102 1 8， 而() k k k k k x x x x x 28882182 1-=-???? ? ?+=-+ n n k k x x 21221102 1 5.22104185 .28--+?=??<-∴>≥ 1k x +∴必有2n 位有效数字。 8 解： 此题的相对误差限通常有两种解法. ①根据本章中所给出的定理： （设x 的近似数* x 可表示为m n a a a x 10......021*?±=，如果* x 具有l 位有效数字，则其相对误差限为 ()11 * *1021 --?≤ -l a x x x ，其中1a 为*x 中第一个非零数） 则7.21=x ，有两位有效数字，相对误差限为 025.0102 21 111=??≤--x x e 71.22=x ，有两位有效数字，相对误差限为 025.0102 21 122=??≤--x x e 3 2.718x =，有两位有效数字，其相对误差限为： 00025.0102 21 333=??≤--x e x ②第二种方法直接根据相对误差限的定义式求解 对于7.21=x ，0183.01<-e x ∴其相对误差限为00678.07 .20183.011≈<-x e x 同理对于71.22=x ，有 003063 .071 .20083 .022≈<-x e x 对于718.23=x ，有 00012.0718 .20003 .033≈<-x e x 备注：（1）两种方法均可得出相对误差限，但第一种是对于所有具有n 位有效数字的近似数都成立的正确结论，故他对误差限的估计偏大，但计算略简单些；而第二种方法给出较好的误差限估计，但计算稍复杂。 （2）采用第二种方法时，分子为绝对误差限，不是单纯的对真实值与近似值差值的四舍五入，绝对误差限大于或等于真实值与近似值的差。 11. 解: ......142857.3722≈，.......1415929.3113 255≈ 2102 1 722-?≤-∴ π，具有3位有效数字 实验三 数值积分 实验目的: 1、了解数值积分的基本原理和方法； 2、熟练掌握复化梯形公式、复化Simpson 公式及其截断误差的分析； 实验内容：(复化梯形求积公式，根据复化梯形求积公式相关公式和原理自己 填写，以下仅作参考) 由于高阶牛顿--柯特斯公式是不稳定的，因此不可能通过提高阶的方法来提高求积精度，为了提高精度通常可把积分区间分成若干n 等份，再在每个子区间上用梯形公式即当n=2时的Newton-Cotes 公式进行计算，最后将所有区间上的梯形相加即可得该积分的近似值。 )] ()(2)([2)]()([21 1110b f x f a f h x f x f h T n k k k n k k n ++=+=∑∑-=+-=， 它的余项公式是 2 ()()12n b a R f h f η-''=- ， 实际上=-=n n T I f R )()()],(12[1,1 3+-=∈''-∑k k n k x x f h ηη, )(1)(1 0∑-=''=''n k k f n f ηη； 具体计算步骤如下 1）.给出被积函数f （x ）、区间[a ，b ]端点a ，b 和等分数n ； 2）.求出 n a b h h k a x k -= +=,*； 3）.计算)(a f 、)(b f 、 1 1 ()n k k f x -=∑； 4）. 得**21 h T n =?? ? ???+*+∑-=)()(2)(1 1b f x f a f n k k 实验题目1 用复化梯形公式计算由下表数据给出的积分值 1.5 0.3 ()d y x x ? 。 k 1 2 3 4 5 6 7 x k 0.3 0.5 0.7 0.9 1.1 1.3 1.5 y k 0.3895 0.6598 0.9147 1.1611 1.3971 1.6212 1.8325 若已知该表数据为函数y =x +sin x /3所产生，请将计算值与精确值作比较。 1、已知精确积分值为： ()()1.5 222 0.3 1cos 111.50.3cos1.5cos 0.3 1.374866429152632323x x ??-=---= ??? 实验题目2 利用复化梯形求积公式计算圆周率，要求达到10位有效数字(方法可参考课后第三题)。计算方法引论课后答案.
C语言程序设计课后习题答案(第四版)谭浩强
计算方法——第二章——课后习题答案刘师少
#《C语言程序设计》课后习题答案(第四版)谭浩强
计算方法的课后答案
计算方法习题答案
计算机操作系统课后习题答案第三章(第四版)
《管理运筹学》第四版课后习题解析(下)
计算机科学导论(第4版)习题答案-第5、6章
算法-第四版-习题-答案
计算机操作系统(第四版)课后习题答案第五章
练习题及参考解答(第四版)
计算方法练习题与答案
应用数值分析第四版第一章课后作业答案
计算方法引论课后答案
数值计算方法习题答案(第二版)(绪论)
《计算方法引论》实验题目3