实验三 逆波兰表达式的产生及计算
实验三逆波兰表达式的产生及计算
一、实验目的
非后缀式用来表示的算术表达式转换为用逆波兰式来表示的算术表达式，并计算用逆波兰式来表示的算术表达式的值。
二、实验内容
将非后缀式用来表示的算术表达式转换为用逆波兰式来表示的算术表达式，并计算用逆波兰式来表示的算术表达式的值。
三、逆波兰表达式的产生及计算实验设计思想及算法
◆逆波兰式定义
将运算对象写在前面，而把运算符号写在后面。用这种表示法表示的表达式也称做后缀式。逆波兰式的特点在于运算对象顺序不变，运算符号位置反映运算顺序。
◆产生逆波兰式的前提
中缀算术表达式
◆逆波兰式生成的设计思想及算法
(1)首先构造一个运算符栈，此运算符在栈内遵循越往栈顶优先级越高的原则。
(2)读入一个用中缀表示的简单算术表达式，为方便起见,设该简单算术表达式的右端多加上了优先级最低的特殊符号“#”。
(3)从左至右扫描该算术表达式，从第一个字符开始判断，如果该字符是数字，则分析到该数字串的结束并将该数字串直接输出。
(4)如果不是数字，该字符则是运算符，此时需比较优先关系。
做法如下：将该字符与运算符栈顶的运算符的优先关系相比较。如果，该字符优先关系高于此运算符栈顶的运算符，则将该运算符入栈。倘若不是的话，则将此运算符栈顶的运算符从栈中弹出，将该字符入栈。
(5)重复上述操作(1)-(2)直至扫描完整个简单算术表达式，确定所有字符都得到正确处理，我们便可以将中缀式表示的简单算术表达式转化为逆波兰表示的简单算术表达式。
运用以上算法分析表达式(a+b*c)*d的过程如下：
(1)构造一个栈，存放运算对象。
(2)读入一个用逆波兰式表示的简单算术表达式。
(3)自左至右扫描该简单算术表达式并判断该字符，如果该字符是运算对象，则将该字符入栈。若是运算符，如果此运算符是二目运算符，则将对栈顶部的两个运算对象进行该运算，将运算结果入栈，并且将执行该运算的两个运算对象从栈顶弹出。如果该字符是一目运算符，则对栈顶部的元素实施该运算，将该栈顶部的元素弹出，将运算结果入栈。
(4)重复上述操作直至扫描完整个简单算术表达式的逆波兰式，确定所有字符都得到正确处理，我们便可以求出该简单算术表达式的值。
◆逆波兰式计算的设计思想及算法
四、实验要求
1、编程时注意编程风格：空行的使用、注释的使用、缩进的使用等。
2、如果遇到错误的表达式，应输出错误提示信息。
3、程序输入/输出实例：
◆输入以#结束的中缀表达式(包括+ - */（）数字#)。
例：(1)（a+b）(2)(a+b*c) (3) B+(-(A))*C
输出逆波兰表达式的格式如下：
(1) (a+b) ;→ab+)(
(2)(a+b*c)→abc*+)(
(3)B+(-A(A)) *C→BA)(-)(C*+
输入中缀表达式并计算结果：a* (b+c)+(-d)#；
输出逆波兰式:abc+*d@+
输入：a=3; b=1;c=2;d=5;
计算结果为:4
五、实验步骤
1、根据流程图编写出各个模块的源程序代码上机调试。
2、编制好源程序后，设计若干用例对系统进行全面的上机测试，并通过所设计的逆波兰式的产生及计算程序；直至能够得到完全满意的结果。
3、书写实验报告；实验报告正文的内容：
◆描述逆波兰式的产生及计算程序的设计思想。
◆程序结构描述：函数调用格式、参数含义、返回值描述、函数功能；函数
之间的调用关系图。
◆详细的算法描述（程序执行流程图）。
◆给出软件的测试方法和测试结果。
◆实验总结（设计的特点、不足、收获与体会）。
六、源代码
1、操作类
package RPNAnalysis;
public class RPN_Operation {
private char[] expChar = new char[100];//表达式栈
private int expPointer = 0;//表达式栈指针
private char[] ariStack = new char[100];//运算符栈
private int top = 0;//运算符栈指针
private char[] exitChar = new char[100];//输出栈
private int exitPointer = 0;//输出栈指针
private String[][] dataStrings = new String[1000][5];//表格数据private String tempString = new String();//临时字符串
private String result = new String();//结果字符串
private int row = 0;//表格数据行
private String compValue = new String();//计算值
private final char[] Arithmetic = {'+','-','*','/','(',')','#'};//运算符
private final char[] Letter =
{'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p'
,'q','r','s','t','u','v','w','x','y','z','A','B','C','D','E','F', 'G','H','I','J','K','L'
,'M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};//字母表
private final char[] Digit =
{'1','2','3','4','5','6','7','8','9','0'};//数字表
public RPN_Operation() {
for (int i = 0; i < 1000; i++) {
for (int j = 0; j < 5; j++) {
dataStrings[i][j] = new String();
dataStrings[i][j] = "";
}
}
}
//判断字符是否为字母
public boolean isLetter(char word) { int N = 0;
while (N < Letter.length) {
if (word == Letter[N]) {
return true;
}
N++;
}
return false;
}
//判断字符是否为数字
public boolean isDigit(char word) {
int N = 0;
while (N < Digit.length) {
if (word == Digit[N]) {
return true;
}
N++;
}
return false;
}
//判断字符是否为算数运算符
public boolean isArithmetic(char word) { int N = 0;
while (N < Arithmetic.length) {
if (word == Arithmetic[N]) {
return true;
}
N++;
}
return false;
}
//输出剩余字符串
public void printExpChar() {
tempString = new String();
for (int i = expPointer; i < expChar.length; i++) { tempString += expChar[i];
System.out.print(expChar[i]);
result += expChar[i];
}
System.out.print("\t\t");
result += "\t\t";
}
//输出符号栈
public void printAriStack() {
tempString = new String();
for (int i = 0; i < top; i++) {
tempString += ariStack[i];
System.out.print(ariStack[i]);
result += ariStack[i];
}
System.out.print("\t\t");
result += "\t\t";
}
//输出逆波兰式
public void printExitChar() {
tempString = new String();
for (int i = 0; i < exitPointer; i++) {
tempString += exitChar[i];
System.out.print(exitChar[i]);
result += exitChar[i];
}
System.out.print("\r\n");
result += "\r\n";
}
//检查字符
public boolean checkString(String checkString) { char ch;
for (int i = 0; i < checkString.length(); i++) { ch = checkString.charAt(i);
if (isLetter(ch)) {
continue;
}else if (isDigit(ch)) {
continue;
}else if (isArithmetic(ch)) {
continue;
}else {
return false;
}
}
return true;
}
//逆波兰分析
public void RPNAnalysis(String expression) {
expChar = expression.toCharArray();
char ch = expChar[expPointer++];
int temp = 0;
if (checkString(expression)) {
System.out.print("步骤\t当前符号\t输入区\t\t运算符号栈\t\t输出区\r\n");
result += "步骤\t当前符号\t输入区\t\t运算符号栈\t\t输出区
\r\n";
while (ch != '#') {
if (isArithmetic(ch)) {
switch (ch) {
case'(':
ariStack[top++] = ch;
System.out.print(row+"\t"+ch+"\t");
result += row+"\t"+ch+"\t";
dataStrings[row][0] = row+"";
dataStrings[row][1] = String.valueOf(ch);
printExpChar();
dataStrings[row][2] = tempString;
printAriStack();
dataStrings[row][3] = tempString;
printExitChar();
dataStrings[row][4] = tempString;
row++;
break;
case')':
while (ariStack[--top]!='(') {
exitChar[exitPointer++] = ariStack[top];
System.out.print(row+"\t"+ch+"\t");
result += row+"\t"+ch+"\t";
dataStrings[row][0] = row+"";
dataStrings[row][1] = String.valueOf(ch);
printExpChar();
dataStrings[row][2] = tempString;
printAriStack();
dataStrings[row][3] = tempString;
printExitChar();
dataStrings[row][4] = tempString;
row++;
}
System.out.print(row+"\t"+ch+"\t");
dataStrings[row][0] = row+"";
result += row+"\t"+ch+"\t";
dataStrings[row][1] = String.valueOf(ch);
printExpChar();
dataStrings[row][2] = tempString;
printAriStack();
dataStrings[row][3] = tempString;
printExitChar();
dataStrings[row][4] = tempString;
row++;
break;
case'+':
case'-':
temp = top - 1;
if (temp>=0 && (ariStack[temp] == '*' || ariStack[temp] == '/')) {
exitChar[exitPointer++] = ariStack[temp];
top--;
}else if (temp>=0 && (ariStack[temp] == '-' || ariStack[temp] == '+')
&&(expChar[expPointer+1] != '*'
||expChar[expPointer+1] != '/')) {
exitChar[exitPointer++] = ariStack[temp];
top--;
}
while (top<0&&ariStack[temp]!='(') {
exitChar[exitPointer++] = ariStack[temp];
top--;
}
ariStack[top++] = ch;
System.out.print(row+"\t"+ch+"\t");
result += row+"\t"+ch+"\t";
dataStrings[row][0] = row+"";
dataStrings[row][1] = String.valueOf(ch);
printExpChar();
dataStrings[row][2] = tempString;
printAriStack();
dataStrings[row][3] = tempString;
printExitChar();
dataStrings[row][4] = tempString;
row++;
break;
case'*':
case'/':
temp = top - 1;
if (temp >= 0 && (ariStack[temp] == '*' || ariStack[temp] == '/') ) {
exitChar[exitPointer++] = ariStack[temp];
top--;
}
ariStack[top++] = ch;
System.out.print(row+"\t"+ch+"\t");
result += row+"\t"+ch+"\t";
dataStrings[row][0] = row+"";
dataStrings[row][1] = String.valueOf(ch);
printExpChar();
dataStrings[row][2] = tempString;
printAriStack();
dataStrings[row][3] = tempString;
printExitChar();
dataStrings[row][4] = tempString;
row++;
break;
default:
break;
}
}else if (isLetter(ch) || isDigit(ch)) {
exitChar[exitPointer++] = ch;
System.out.print(row+"\t"+ch+"\t");
result += row+"\t"+ch+"\t";
dataStrings[row][0] = row+"";
dataStrings[row][1] = String.valueOf(ch);
printExpChar();
dataStrings[row][2] = tempString;
printAriStack();
dataStrings[row][3] = tempString;
printExitChar();
dataStrings[row][4] = tempString;
row++;
}
ch = expChar[expPointer++];
}
while(top!=0) {
temp = top - 1;
if (ariStack[temp]=='(') {
top--;
continue;
}
exitChar[exitPointer++] = ariStack[--top];
System.out.print(row+"\t"+ch+"\t");
result += row+"\t"+ch+"\t";
dataStrings[row][0] = row+"";
dataStrings[row][1] = String.valueOf(ch);
printExpChar();
dataStrings[row][2] = tempString;
printAriStack();
dataStrings[row][3] = tempString;
printExitChar();
dataStrings[row][4] = tempString;
row++;
}
}
}
//计算值
public void compValue() {
int stack[] = new int[100];
exitChar[exitPointer++] = '#';
char ch;
int i=0,top=0;
ch = exitChar[i++];
while (ch != '#') {
switch (ch) {
case'+':
compValue += stack[top-1] + " + " + stack [top];
stack[top-1] = stack[top-1] + stack [top];
compValue += " := " + stack[top-1] + "\r\n";
top--;
break;
case'-':
compValue += stack[top-1] + " - " + stack [top];
stack[top-1] = stack[top-1] - stack [top];
compValue += " := " + stack[top-1] + "\r\n";
top--;
break;
case'*':
compValue += stack[top-1] + " * " + stack [top];
stack[top-1] = stack[top-1] * stack [top];
compValue += " := " + stack[top-1] + "\r\n";
top--;
break;
case'/':
compValue += stack[top-1] + " / " + stack [top];
stack[top-1] = stack[top-1] / stack [top];
compValue += " := " + stack[top-1] + "\r\n";
top--;
break;
default:
top++;
stack[top] = ch - '0';
break;
}
ch = exitChar[i++];
}
compValue += "结果：" + stack[top];
System.out.print(compValue);
}
public int getRow() {
return row;
}
public void setRow(int row) {
this.row = row;
}
public String[][] getDataStrings() {
return dataStrings;
}
public void setDataStrings(String[][] dataStrings) { this.dataStrings = dataStrings;
}
public String getResult() {
return result;
}
public void setResult(String result) {
this.result = result;
}
public char[] getExitChar() {
return exitChar;
}
public void setExitChar(char[] exitChar) { this.exitChar = exitChar;
}
public String getCompValue() {
return compValue;
}
public void setCompValue(String compValue) { https://www.sodocs.net/doc/9616976541.html,pValue = compValue;
}
}
2、界面类
package RPNAnalysis;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.FileDialog; import org.eclipse.swt.widgets.MessageBox; import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.custom.ScrolledComposite; import org.eclipse.swt.custom.TableEditor; import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn; import org.eclipse.wb.swt.SWTResourceManager; import org.eclipse.swt.events.ModifyEvent; import org.eclipse.swt.events.ModifyListener; import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent; import org.eclipse.swt.events.SelectionAdapter; import org.eclipse.swt.events.SelectionEvent; import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle; public class RPNSWT {
protected Shell shell;
private Text text;
private Table varTable;
private Text resultText;
private Table resultTable;
private MessageBox messageBox;
private TableEditor editor;
private String result = "";
private File sourceFile = null;
private RPN_Operation mOperation;
private String analysisString;
String compValueString = new String();
private int varTableRow = 0;
private char[] varTableVar;
private char[] exitChar;
/**
* Launch the application.
* @param args
*/
public static void main(String[] args) { try {
RPNSWT window = new RPNSWT();
window.open();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* Open the window.
*/
public void open() {
Display display = Display.getDefault();
createContents();
shell.open();
https://www.sodocs.net/doc/9616976541.html,yout();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
}
/**
* Create contents of the window.
*/
protected void createContents() {
shell = new Shell();
shell.setSize(500, 386);
shell.setText("逆波兰表达式分析器");
Menu menu = new Menu(shell, SWT.BAR);
shell.setMenuBar(menu);
MenuItem menuItem = new MenuItem(menu, SWT.NONE);
menuItem.addSelectionListener(new SelectionAdapter() { @Override
public void widgetSelected(SelectionEvent e) {
newTextTable();
}
});
menuItem.setText("\u65B0\u5EFA");
MenuItem menuItem_1 = new MenuItem(menu, SWT.NONE);
menuItem_1.addSelectionListener(new SelectionAdapter() { @Override
public void widgetSelected(SelectionEvent e) {
openFile();
}
});
menuItem_1.setText("\u6253\u5F00");
MenuItem menuItem_2 = new MenuItem(menu, SWT.NONE);
menuItem_2.addSelectionListener(new SelectionAdapter() { @Override
public void widgetSelected(SelectionEvent e) {
try {
analysis();
} catch (Exception e2) {
e2.printStackTrace();
}
}
});
menuItem_2.setText("\u5206\u6790");
MenuItem menuItem_6 = new MenuItem(menu, SWT.NONE);
menuItem_6.addSelectionListener(new SelectionAdapter() { @Override
public void widgetSelected(SelectionEvent e) {
try {
compValue();
} catch (Exception e2) {
e2.printStackTrace();
}
}
});
menuItem_6.setText("\u8BA1\u7B97");
MenuItem menuItem_3 = new MenuItem(menu, SWT.NONE);
menuItem_3.addSelectionListener(new SelectionAdapter() { @Override
public void widgetSelected(SelectionEvent e) {
saveFile();
}
});
menuItem_3.setText("\u4FDD\u5B58");
MenuItem menuItem_4 = new MenuItem(menu, SWT.NONE);
menuItem_4.addSelectionListener(new SelectionAdapter() { @Override
public void widgetSelected(SelectionEvent e) {
shell.dispose();
}
});
menuItem_4.setText("\u9000\u51FA");
MenuItem menuItem_5 = new MenuItem(menu, SWT.NONE);
menuItem_5.addSelectionListener(new SelectionAdapter() { @Override
public void widgetSelected(SelectionEvent e) {
messageBox= new MessageBox(shell,SWT.ICON_INFORMATION);
messageBox.setText("关于");
messageBox.setMessage("逆波兰表达式分析器\n 作者：章进兴\n 0941901228");
messageBox.open();
}
});
menuItem_5.setText("\u5173\u4E8E");
ScrolledComposite scrolledComposite = new
ScrolledComposite(shell, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL);
scrolledComposite.setBounds(10, 10, 202, 119);
scrolledComposite.setExpandHorizontal(true);
scrolledComposite.setExpandVertical(true);
text = new Text(scrolledComposite, SWT.BORDER);
scrolledComposite.setContent(text);
scrolledComposite.setMinSize(https://www.sodocs.net/doc/9616976541.html,puteSize(SWT.DEFAULT, SWT.DEFAULT));
varTable = new Table(shell, SWT.BORDER | SWT.FULL_SELECTION);
varTable.setBounds(218, 10, 127, 119);
varTable.setHeaderVisible(true);
varTable.setLinesVisible(true);
editor = new TableEditor(varTable);
editor.horizontalAlignment = SWT.LEFT;
editor.grabHorizontal = true;
createEditorContents();
TableColumn tableColumn = new TableColumn(varTable, SWT.NONE);
tableColumn.setWidth(61);
tableColumn.setText("\u53D8\u91CF");
TableColumn tblclmnNewColumn = new TableColumn(varTable, SWT.NONE);
tblclmnNewColumn.setWidth(61);
tblclmnNewColumn.setText("\u503C");
ScrolledComposite scrolledComposite_1 = new
ScrolledComposite(shell, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL);
scrolledComposite_1.setBounds(351, 10, 123, 119);
scrolledComposite_1.setExpandHorizontal(true);
scrolledComposite_1.setExpandVertical(true);
resultText = new Text(scrolledComposite_1, SWT.BORDER |
SWT.H_SCROLL | SWT.V_SCROLL | SWT.CANCEL);
resultText.setBackground(SWTResourceManager.getColor(SWT.COLOR_LI ST_BACKGROUND));
resultText.setEditable(false);
scrolledComposite_1.setContent(resultText);
scrolledComposite_1.setMinSize(https://www.sodocs.net/doc/9616976541.html,puteSize(SWT.DEFAULT, SWT.DEFAULT));
resultTable= new Table(shell, SWT.BORDER| SWT.FULL_SELECTION);
resultTable.setBounds(10, 135, 464, 183);
resultTable.setHeaderVisible(true);
resultTable.setLinesVisible(true);
TableColumn tblclmnNewColumn_1 = new TableColumn(resultTable, SWT.NONE);
tblclmnNewColumn_1.setResizable(false);
tblclmnNewColumn_1.setWidth(59);
tblclmnNewColumn_1.setText("\u6B65\u9AA4");
TableColumn tblclmnNewColumn_2 = new TableColumn(resultTable, SWT.NONE);
tblclmnNewColumn_2.setWidth(100);
tblclmnNewColumn_2.setText("\u5F53\u524D\u7B26\u53F7");
TableColumn tblclmnNewColumn_3 = new TableColumn(resultTable, SWT.NONE);
tblclmnNewColumn_3.setWidth(100);
tblclmnNewColumn_3.setText("\u8F93\u5165\u533A");
TableColumn tblclmnNewColumn_4 = new TableColumn(resultTable, SWT.NONE);
tblclmnNewColumn_4.setWidth(100);
tblclmnNewColumn_4.setText("\u8FD0\u7B97\u7B26\u53F7\u6808");
TableColumn tblclmnNewColumn_5 = new TableColumn(resultTable, SWT.NONE);
tblclmnNewColumn_5.setWidth(100);
tblclmnNewColumn_5.setText("\u8F93\u51FA\u533A");
}
public void openFile() {
FileDialog openFileDialog = new FileDialog(shell,SWT.OPEN);
openFileDialog.setText("选择需要分析的文件");
openFileDialog.setFilterExtensions(new String[] {"*.txt"});
openFileDialog.setFilterNames(new String[]{"txt文本文件
(*.txt)"});
openFileDialog.setFilterPath("D:\\");
String selectedOpenFile = openFileDialog.open();
this.result = "";
if (selectedOpenFile!=null) {
sourceFile = new File(selectedOpenFile);
try {
FileReader fileReader = new FileReader(sourceFile);
BufferedReader reader = new BufferedReader(fileReader);
StringBuffer stringBuffer = new StringBuffer();
String lineString = null;
while((lineString = reader.readLine())!=null)
{
stringBuffer.append(lineString);
stringBuffer.append("\n");
}
text.setText(stringBuffer.toString());
shell.setText("逆波兰表达式分析器 - " + openFileDialog.getFileName());
fileReader.close();
varTable.removeAll();
resultTable.removeAll();
} catch (Exception e) {
e.printStackTrace();
}
}else {
messageBox = new MessageBox(shell,SWT.ICON_WARNING);
messageBox.setMessage("文件未载入！请重新打开需要分析的文件！");
messageBox.setText("提示");
messageBox.open();
}
}
public void newTextTable() {
this.result = "";
this.text.setText("");
this.resultText.setText("");
this.varTable.removeAll();
this.resultTable.removeAll();
}
public void saveFile() {
if (result != "") {
result += "\r\n"+compValueString;
FileWriter fileWriter = null;
try {
fileWriter = new FileWriter("Result.txt");
fileWriter.write(result);
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
Runtime runtime = Runtime.getRuntime();
messageBox = new MessageBox(shell);
messageBox.setMessage("保存成功！");
messageBox.setText("提示");
fileWriter.flush();
fileWriter.close();
messageBox.open();
sourceFile = new File("Result.txt");
runtime.exec("rundll32 url.dll FileProtocolHandler "+sourceFile.getAbsolutePath());
} catch (Exception e2) {
e2.printStackTrace();
}
}
}else {
messageBox = new MessageBox(shell,SWT.ICON_WARNING);
messageBox.setMessage("未分析，保存失败！");
messageBox.setText("提示");
messageBox.open();
}
}
public void analysis() {
mOperation = new RPN_Operation();
this.resultTable.removeAll();
this.varTable.removeAll();
this.resultText.setText("");
this.analysisString = text.getText();
this.result = "";
boolean flag = false;
if (mOperation.checkString(this.analysisString)) {
《计算方法》课内实验报告
《计算方法》实验报告 姓名： 班级： 学号： 实验日期: 2011年10月26日
一、实验题目： 数值积分 二、实验目的： 1．熟悉matlab 编写及运行数值计算程序的方法。 2．进一步理解数值积分的基础理论。 3．进一步掌握应用不同的数值积分方法求解给定的积分并给出数据结果及误差分析。 三、实验内容： 1．分别用复合梯形求积公式及复合辛普森求积公式计算积分xdx x ln 10 ? , 要求计算精度达到410-,给出计算结果并比较两种方法的计算节点数. 2．用龙贝格求积方法计算积分dx x x ?+3 021,使误差不超过510-. 3．用3=n 的高斯-勒让德公式计算积分?3 1 sin x e x ,给出计算结果. 4．用辛普森公式(取2==M N ) 计算二重积分.5 .00 5 .00 dydx e x y ? ? - 四、实验结果： 1.（1）复合梯形法: 将区间[a,b]划分为n 等份，分点n k n a b h kh a x k ,2,1,0,,=-=+=在每个区间[1,+k k x x ](k=0,1,2,···n-1)上采用梯形公式，则得 )()]()([2)()(1 11 1 f R x f x f h dx x f dx x f I n n k k k b a n k x x k k ++===∑?∑? -=+-=+ 故)]()(2)([21 1 b f x f a f h T n k k n ++=∑-=称为复合梯形公式 计算步长和划分的区间 Eps=1E-4 h1=sqrt(Eps/abs(-(1-0)/12*1/(2+1))) h1 =0.0600 N1=ceil(1/h1) N1 =17 用复合梯形需要计算17个结点。 复合梯形： function T=trap(f,a,b,n) h=(b-a)/n;
数据结构表达式求值实验报告
竭诚为您提供优质文档/双击可除数据结构表达式求值实验报告 篇一：数据结构实验二——算术表达式求值实验报告 《数据结构与数据库》 实验报告 实验题目算术表达式求值 学院：化学与材料科学学院 专业班级：09级材料科学与工程系pb0920603 姓学 邮名：李维谷号：pb09206285箱： liwg@https://www.sodocs.net/doc/9616976541.html,指导教师：贾伯琪 实验时间：20XX年10月10日 一、需要分析 问题描述： 表达式计算是实现程序设计语言的基本问题之一，它的实现是栈的应用的一个典型例子。设计一个程序，演示通过将数学表达式字符串转化为后缀表达式，并通过后缀表达式结合栈的应用实现对算术表达式进行四则混合运算。
问题分析： 在计算机中，算术表达式由常量、变量、运算符和括号组成。由于不同的运算符具有不同的优先级，又要考虑括号，因此，算术表达式的求值不可能严格地从左到右进行。因而在程序设计时，借助栈实现。 设置运算符栈（字符型）和运算数栈（浮点型）辅助分析算符优先关系。在读入表达式的字符序列的同时完成运算符和运算数的识别处理，然后进行运算数的数值转换在进行四则运算。 在运算之后输出正确运算结果，输入表达式后演示在求值中运算数栈内的栈顶数据变化过程，最后得到运算结果。 算法规定： 输入形式：一个(:数据结构表达式求值实验报告)算术表达式，由常量、变量、运算符和括号组成（以字符串形式输入）。为使实验更完善，允许操作数为实数，操作符为（、）、.（表示小数点）、+、-、*、/、^（表示乘方），用#表示结束。 输出形式：演示表达式运算的中间结果和整个表达式的最终结果，以浮点型输出。 程序功能：对实数内的加减乘除乘方运算能正确的运算出结果，并能正确对错误输入和无定义的运算报错，能连续测试多组数据。 测试数据：正确输入：12*（3.6/3+4^2-1）#
并行计算1
并行计算 实 验 报 告 学院名称计算机科学与技术学院专业计算机科学与技术 学生姓名 学号 年班级 2016年5 月20 日
一、实验内容 本次试验的主要内容为采用多线程的方法计算pi的值，熟悉linux下pthread 形式的多线程编程，对实验结果进行统计并分析以及加速比曲线分析，从而对并行计算有初步了解。 二、实验原理 本次实验利用中值积分定理计算pi的值 图1 中值定理计算pi 其中公式可以变换如下： 图2 积分计算pi公式的变形 当N足够大时，可以足够逼近pi，多线程的计算方法主要通过将for循环的计算过程分到几个线程中去，每次计算都要更新sum的值，为避免一个线程更新sum 值后，另一个线程仍读到旧的值，所以每个线程计算自己的部分，最后相加。三、程序流程图 程序主体部分流程图如下：
多线程执行函数流程图如下： 四、实验结果及分析
令线程数分别为1、2、5、10、20、30、40、50和100，并且对于每次实验重复十次求平均值。结果如下： 图5 时间随线程的变化 实验加速比曲线的计算公式类似于 结果如下： 图5 加速比曲线 实验结果与预期类似，当线程总数较少时，线程数的增多会对程序计算速度带来明显的提升，当线程总数增大到足够大时，由于物理节点的核心数是有限的，因此会给cpu带来较多的调度，线程的切换和最后结果的汇总带来的时间开销较大，所以线程数较大时，增加线程数不会带来明显的速度提升，甚至可能下降。 五、实验总结
本次试验的主要内容是多线程计算pi的实现，通过这次实验，我对并行计算有了进一步的理解。上学期的操作系统课程中，已经做过相似的题目，因此程序主体部分相似。不同的地方在于，首先本程序按照老师要求应在命令行提供参数，而非将数值写定在程序里，其次是程序不是在自己的电脑上运行，而是通过ssh和批处理脚本等登录到远程服务器提交任务执行。 在运行方面，因为对批处理任务不够熟悉，出现了提交任务无结果的情况，原因在于windows系统要采用换行的方式来表明结束。在实验过程中也遇到了其他问题，大多还是来自于经验的缺乏。 在分析实验结果方面，因为自己是第一次分析多线程程序的加速比，因此比较生疏，参考网上资料和ppt后分析得出结果。 从自己遇到的问题来看，自己对批处理的理解和认识还比较有限，经过本次实验，我对并行计算的理解有了进一步的提高，也意识到了自己存在的一些问题。 六、程序代码及部署 程序源代码见cpp文件 部署说明： 使用gcc编译即可，编译时加上-pthread参数，运行时任务提交到服务器上。 编译命令如下： gcc -pthread PI_3013216011.cpp -o pi pbs脚本(runPI.pbs)如下： #!/bin/bash #PBS -N pi #PBS -l nodes=1:ppn=8 #PBS -q AM016_queue #PBS -j oe cd $PBS_O_WORKDIR for ((i=1;i<=10;i++)) do ./pi num_threads N >> runPI.log
数值分析实验报告1
实验一误差分析 实验1.1（病态问题） 实验目的：算法有“优”与“劣”之分，问题也有“好”与“坏”之别。对数值方法的研究而言，所谓坏问题就是问题本身对扰动敏感者，反之属于好问题。通过本实验可获得一个初步体会。 数值分析的大部分研究课题中，如线性代数方程组、矩阵特征值问题、非线性方程及方程组等都存在病态的问题。病态问题要通过研究和构造特殊的算法来解决，当然一般要付出一些代价（如耗用更多的机器时间、占用更多的存储空间等）。 问题提出：考虑一个高次的代数多项式 显然该多项式的全部根为1,2,…,20共计20个，且每个根都是单重的。现考虑该多项式的一个扰动 其中ε（1.1）和（1.221,,,a a 的输出b ”和“poly ε。 （1（2 （3）写成展 关于α solve 来提高解的精确度，这需要用到将多项式转换为符号多项式的函数poly2sym,函数的具体使用方法可参考Matlab 的帮助。 实验过程： 程序： a=poly(1:20); rr=roots(a); forn=2:21 n form=1:9 ess=10^(-6-m);
ve=zeros(1,21); ve(n)=ess; r=roots(a+ve); -6-m s=max(abs(r-rr)) end end 利用符号函数：（思考题一）a=poly(1:20); y=poly2sym(a); rr=solve(y) n
很容易的得出对一个多次的代数多项式的其中某一项进行很小的扰动，对其多项式的根会有一定的扰动的，所以对于这类病态问题可以借助于MATLAB来进行问题的分析。 学号：06450210 姓名：万轩 实验二插值法
太原理工大学数值计算方法实验报告
本科实验报告 课程名称：计算机数值方法 实验项目：方程求根、线性方程组的直接解 法、线性方程组的迭代解法、代数插值和最 小二乘拟合多项式 实验地点：行勉楼 专业班级： ******** 学号： ********* 学生姓名： ******** 指导教师：李誌，崔冬华 2016年 4 月 8 日
y = x*x*x + 4 * x*x - 10; return y; } float Calculate(float a,float b) { c = (a + b) / 2; n++; if (GetY(c) == 0 || ((b - a) / 2) < 0.000005) { cout << c <<"为方程的解"<< endl; return 0; } if (GetY(a)*GetY(c) < 0) { return Calculate(a,c); } if (GetY(c)*GetY(b)< 0) { return Calculate(c,b); } } }; int main() { cout << "方程组为：f(x)=x^3+4x^2-10=0" << endl; float a, b; Text text; text.Getab(); a = text.a; b = text.b; text.Calculate(a, b); return 0; } 2.割线法： // 方程求根（割线法）.cpp : 定义控制台应用程序的入口点。// #include "stdafx.h" #include"iostream"
心得体会 使用不同的方法，可以不同程度的求得方程的解，通过二分法计算的程序实现更加了解二分法的特点，二分法过程简单，程序容易实现，但该方法收敛比较慢一般用于求根的初始近似值，不同的方法速度不同。面对一个复杂的问题，要学会简化处理步骤，分步骤一点一点的循序处理，只有这样，才能高效的解决一个复杂问题。
数据结构实验二——算术表达式求值实验报告
《数据结构与数据库》 实验报告 实验题目 算术表达式求值 学院：化学与材料科学学院 专业班级：09级材料科学与工程系PB0920603 姓名：李维谷 学号：PB09206285 邮箱：liwg@https://www.sodocs.net/doc/9616976541.html, 指导教师：贾伯琪 实验时间：2010年10月10日 一、需要分析 问题描述：
表达式计算是实现程序设计语言的基本问题之一，它的实现是栈的应用的一个典型例子。设计一个程序，演示通过将数学表达式字符串转化为后缀表达式，并通过后缀表达式结合栈的应用实现对算术表达式进行四则混合运算。 问题分析： 在计算机中，算术表达式由常量、变量、运算符和括号组成。由于不同的运算符具有不同的优先级，又要考虑括号，因此，算术表达式的求值不可能严格地从左到右进行。因而在程序设计时，借助栈实现。 设置运算符栈（字符型）和运算数栈（浮点型）辅助分析算符优先关系。在读入表达式的字符序列的同时完成运算符和运算数的识别处理，然后进行运算数的数值转换在进行四则运算。 在运算之后输出正确运算结果，输入表达式后演示在求值中运算数栈内的栈顶数据变化过程，最后得到运算结果。 算法规定： 输入形式：一个算术表达式，由常量、变量、运算符和括号组成（以字符串形式输入）。为使实验更完善，允许操作数为实数，操作符为（、）、.（表示小数点）、+、-、*、/、^（表示乘方），用#表示结束。 输出形式：演示表达式运算的中间结果和整个表达式的最终结果，以浮点型输出。 程序功能：对实数内的加减乘除乘方运算能正确的运算出结果，并能正确对错误输入和无定义的运算报错，能连续测试多组数据。 测试数据：正确输入：12*（3.6/3+4^2-1）# 输出结果：194.4
计算方法上机实验报告
《计算方法》上机实验报告 班级：XXXXXX 小组成员：XXXXXXX XXXXXXX XXXXXXX XXXXXXX 任课教师：XXX 二〇一八年五月二十五日
前言 通过进行多次的上机实验，我们结合课本上的内容以及老师对我们的指导，能够较为熟练地掌握Newton 迭代法、Jacobi 迭代法、Gauss-Seidel 迭代法、Newton 插值法、Lagrange 插值法和Gauss 求积公式等六种算法的原理和使用方法，并参考课本例题进行了MATLAB 程序的编写。 以下为本次上机实验报告，按照实验内容共分为六部分。 实验一： 一、实验名称及题目： Newton 迭代法 例2.7(P38):应用Newton 迭代法求 在 附近的数值解 ，并使其满足 . 二、解题思路： 设'x 是0)(=x f 的根,选取0x 作为'x 初始近似值,过点())(,00x f x 做曲线)(x f y =的切线L ,L 的方程为))((')(000x x x f x f y -+=,求出L 与x 轴交点的横坐标) (') (0001x f x f x x - =,称1x 为'x 的一次近似值,过点))(,(11x f x 做曲线)(x f y =的切线,求该切线与x 轴的横坐标) (') (1112x f x f x x - =称2x 为'x
的二次近似值,重复以上过程,得'x 的近似值序列{}n x ,把 ) (') (1n n n n x f x f x x - =+称为'x 的1+n 次近似值，这种求解方法就是牛顿迭代法。 三、Matlab 程序代码： function newton_iteration(x0,tol) syms z %定义自变量 format long %定义精度 f=z*z*z-z-1; f1=diff(f);%求导 y=subs(f,z,x0); y1=subs(f1,z,x0);%向函数中代值 x1=x0-y/y1; k=1; while abs(x1-x0)>=tol x0=x1; y=subs(f,z,x0); y1=subs(f1,z,x0); x1=x0-y/y1;k=k+1; end x=double(x1) K 四、运行结果： 实验二：
数值计算实验报告
(此文档为word格式，下载后您可任意编辑修改！) 2012级6班###(学号)计算机数值方法 实验报告成绩册 姓名:宋元台 学号： 成绩：
数值计算方法与算法实验报告 学期： 2014 至 2015 第 1 学期 2014年 12月1日课程名称: 数值计算方法与算法专业:信息与计算科学班级 12级5班 实验编号： 1实验项目Neton插值多项式指导教师：孙峪怀 姓名：宋元台学号：实验成绩： 一、实验目的及要求 实验目的： 掌握Newton插值多项式的算法，理解Newton插值多项式构造过程中基函数的继承特点，掌握差商表的计算特点。 实验要求： 1. 给出Newton插值算法 2. 用C语言实现算法 二、实验内容 三、实验步骤(该部分不够填写.请填写附页)
1.算法分析： 下面用伪码描述Newton插值多项式的算法： Step1 输入插值节点数n，插值点序列{x(i),f(i)},i=1,2,……,n,要计算的插值点x. Step2 形成差商表 for i=0 to n for j=n to i f(j)=((f(j)-f(j-1)(x(j)-x(j-1-i)); Step3 置初始值temp=1,newton=f(0) Step4 for i=1 to n temp=(x-x(i-1))*temp*由temp(k)=(x-x(k-1))*temp(k-1)形成 (x-x(0).....(x-x(i-1)* Newton=newton+temp*f(i); Step5 输出f（x）的近似数值newton(x)=newton. 2.用C语言实现算法的程序代码 #include
c 计算器实验报告
简单计算器 姓名: 周吉祥 实验目的：模仿日常生活中所用的计算器，自行设计一个简单的计算器程序，实现简单的计算功能。 实验内容： (1)体系设计： 程序是一个简单的计算器，能正确输入数据，能实现加、减、乘、除等算术运算，运算结果能正确显示，可以清楚数据等。 (2)设计思路： 1)先在Visual C++ 6.0中建立一个MFC工程文件，名为 calculator. 2)在对话框中添加适当的编辑框、按钮、静态文件、复选框和单 选框 3)设计按钮，并修改其相应的ID与Caption. 4)选择和设置各控件的单击鼠标事件。 5)为编辑框添加double类型的关联变量m_edit1. 6)在calculatorDlg.h中添加math.h头文件，然后添加public成 员。 7)打开calculatorDlg.cpp文件，在构造函数中，进行成员初始 化和完善各控件的响应函数代码。 (3)程序清单：
●添加的public成员： double tempvalue; //存储中间变量 double result; //存储显示结果的值 int sort; //判断后面是何种运算：1.加法2.减法3. 乘法 4.除法 int append; //判断后面是否添加数字 ●成员初始化： CCalculatorDlg::CCalculatorDlg(CWnd* pParent /*=NULL*/) : CDialog(CCalculatorDlg::IDD, pParent) { //{{AFX_DATA_INIT(CCalculatorDlg) m_edit1 = 0.0; //}}AFX_DATA_INIT // Note that LoadIcon does not require a subsequent DestroyIcon in Win32 m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME); tempvalue=0; result=0; sort=0; append=0; }
数据结构算术表达式求值实验报告
软件技术基础实验报告 实验名称：表达式计算器 系别：通信工程 年级： 班级： 学生学号： 学生姓名： 《数据结构》课程设计报告 题目简易计算表达式的演示 【题目要求】 要求：实现基本表达式计算的功能 输入：数学表达式，表达式由整数和“+”、“-”、“×”、“/”、“（”、“）”组成输出：表达式的值 基本操作：键入表达式，开始计算，计算过程和结果记录在文档中 难点：括号的处理、乘除的优先级高于加减
1．前言 在计算机中，算术表达式由常量、变量、运算符和括号组成。由于不同的运算符具有不同的优先级，又要考虑括号，因此，算术表达式的求值不可能严格地从左到右进行。因而在程序设计时，借助栈实现。 算法输入：一个算术表达式，由常量、变量、运算符和括号组成（以字符串形式输入）。为简化，规定操作数只能为正整数，操作符为+、-*、/、=，用#表示结束。 算法输出：表达式运算结果。 算法要点：设置运算符栈和运算数栈辅助分析算符优先关系。在读入表达式的字符序列的同时，完成运算符和运算数的识别处理，以及相应运算。 2．概要设计 2.1 数据结构设计 任何一个表达式都是由操作符，运算符和界限符组成的。我们分别用顺序栈来寄存表达式的操作数和运算符。栈是限定于紧仅在表尾进行插入或删除操作的线性表。顺序栈的存储结构是利用一组连续的存储单元依次存放自栈底到栈顶的数据元素，同时附设指针top 指示栈顶元素在顺序栈中的位置，base 为栈底指针，在顺序栈中，它始终指向栈底，即top=base 可作为栈空的标记，每当插入新的栈顶元素时，指针top 增1，删除栈顶元素时，指针top 减1。 2.2 算法设计 为了实现算符优先算法。可以使用两个工作栈。一个称为OPTR ，用以寄存运算符，另一个称做OPND ，用以寄存操作数或运算结果。 1.首先置操作数栈为空栈，表达式起始符”#”为运算符栈的栈底元素； 2.依次读入表达式，若是操作符即进OPND 栈，若是运算符则和OPTR 栈的栈顶运算符比较优先权后作相应的操作，直至整个表达式求值完毕（即OPTR 栈的栈顶元素和当前读入的字符均为”#”）。 2.3 ADT 描述 ADT Stack{ 数据对象：D={ i a |i a ∈ElemSet,i=1,2,…，n, n ≧0} 数据对象：R1={< 1 ,-i i a a >| 1-i a ,D a i ∈,i=2,…，n}
多核编程与并行计算实验报告 (1)
(此文档为word格式，下载后您可任意编辑修改！) 多核编程与并行计算实验报告 姓名： 日期：2014年 4月20日
实验一 // exa1.cpp : Defines the entry point for the console application. // #include"stdafx.h" #include 实验二 // exa2.cpp : Defines the entry point for the console application. // #include"stdafx.h" #include 《数值计算方法》上机实验报告华北电力大学 实验名称数值il?算方法》上机实验课程名称数值计算方法专业班级：电力实08学生姓名：李超然学号:200801001008 成绩: 指导教师:郝育黔老师实验日期：2010年04月华北电力大学实验报告数值计算方法上机实验报吿一. 各算法的算法原理及计算机程序框图1、牛顿法求解非线性方程 *对于非线性方程，若已知根的一个近似值，将在处展开成一阶 xxfx ()0, fx ()xkk 泰勒公式 "f 0 / 2 八八,fxfxfxxxxx 0 0 0 0 0 kkkk2! 忽略高次项，有 ，fxfxfxxx 0 ()()()，，, kkk 右端是直线方程，用这个直线方程来近似非线性方程。将非线性方程的 **根代入，即fx ()0, X ，* fxfxxx 0 0 0 0, ,, kkk fx 0 fx 0 0, 解出 fX 0 *k XX,, k' fx 0 k 水将右端取为，则是比更接近于的近似值，即xxxxk, Ik, Ik fx ()k 八XX, Ikk* fx()k 这就是牛顿迭代公式。 ,2,计算机程序框图:，见, ,3,输入变量、输出变量说明: X输入变量:迭代初值，迭代精度，迭代最大次数，\0 输出变量:当前迭代次数，当前迭代值xkl ,4,具体算例及求解结果: 2/16 华北电力大学实验报吿 开始 读入 l>k /fx()0?,0 fx 0 Oxx，，01* fx ()0 XX,,，?10 kk, ,1，kN, ?xx, 10 输出迭代输出X输出奇异标志1失败标志 ,3,输入变量、输出变量说明: 结束 例：导出计算的牛顿迭代公式，并il ?算。（课本P39例2-16） 115cc （0）, 求解结果: 10. 750000 10.723837 10. 723805 10. 723805 2、列主元素消去法求解线性方程组，1,算法原理: 高斯消去法是利用现行方程组初等变换中的一种变换，即用一个不为零的数乘 -个 方程后加只另一个方程，使方程组变成同解的上三角方程组，然后再自下而上 对上三角 3/16 华北电力大学实验报告方程组求解。 列选主元是当高斯消元到第步时，从列的以下（包括）的各元素中选出绝 aakkkkkk 对值最大的，然后通过行交换将其交换到的位置上。交换系数矩阵中的 两行（包括常ekk 数项），只相当于两个方程的位置交换了，因此，列选主元不影响求解的结 ,2,计算机程序框图:，见下页, 输入变量:系数矩阵元素，常向量元素baiji 输出变量:解向量元素bbb,,12n 计算方法实验报告格式 小组名称: 组长姓名(班号)： 小组成员姓名(班号): 按贡献排序情况: 指导教师评语: 小组所得分数: 一个完整的实验，应包括数据准备、理论基础、实验内容及方法，最终对实验结果进行分析，以达到对理论知识的感性认识，进一步加深对相关算法的理解，数值实验以实验报告形式完成，实验报告格式如下： 一、实验名称 实验者可根据报告形式需要适当写出． 二、实验目的及要求 首先要求做实验者明确，为什么要做某个实验，实验目的是什么，做完该实验应达到什么结果，在实验过程中的注意事项，实验方法对结果的影响也可以以实验目的的形式列出． 三、算法描述（实验原理与基础理论） 数值实验本身就是为了加深对基础理论及方法的理解而设置的，所以要求将实验涉及到的理论基础，算法原理详尽列出． 四、实验内容 实验内容主要包括实验的实施方案、步骤、实验数据准备、实验的算法以及可能用到的仪器设备． 五、程序流程图 画出程序实现过程的流程图，以便更好的对程序执行的过程有清楚的认识，在程序调试过程中更容易发现问题． 六、实验结果 实验结果应包括实验的原始数据、中间结果及实验的最终结果，复杂的结果可以用表格 形式列出，较为简单的结果可以与实验结果分析合并出现． 七、实验结果分析 实验结果分析包括对对算法的理解与分析、改进与建议． 数值实验报告范例 为了更好地做好数值实验并写出规范的数值实验报告，下面给出一简单范例供读者参考． 数值实验报告 小组名称: 小组成员(班号): 按贡献排序情况: 指导教师评语: 小组所得分数: 一、实验名称 误差传播与算法稳定性． 二、实验目的 1．理解数值计算稳定性的概念． 2．了解数值计算方法的必要性． 3．体会数值计算的收敛性与收敛速度． 三、实验内容 计算dx x x I n n ? += 1 10 ，1,2,,10n = ． 四、算法描述 由 dx x x I n n ? += 1 10 ，知 dx x x I n n ?+=--101110，则 中南民族大学计算机科学学院本科课程设计 任务书 设计名称：算术表达式语法检查 指导教师：下达时间： 2015-5-8 学生姓名：学号： 专业： 一、课程设计的基本要求 根据所学知识，编写指定题目的C++语言程序，并规范地完成课程设计报告。通过课程设计，加深对《C++面向对象程序设计》课程所学知识的理解，熟练掌握和巩固C++语言的基本知识和语法规范，掌握C++语言的基础知识，理解面向对象系统的封装性、继承性和多态性；熟练使用C语言中的函数、数组、指针、链表和字符串等基本知识；掌握类的定义、标准String类和向量；理解掌握友元函数和重载操作符，动态数组；理解掌握继承和多态性；掌握模版的使用；能够进行程序调试过程中的异常处理；进一步掌握利用C++进行类的定义和操作方法；进一步掌握类的继承和派生方法；进一步理解虚函数和多态；综合利用上述知识，学习设计并编写面向对象的C++简单应用程序；培养解决复杂任务功能分解方法（自顶向下逐步求精、模块化设计、信息隐藏等）。 学会编制结构清晰、风格良好、数据结构适当的C++语言程序，从而具备利用计算机编程分析解决综合性实际问题的初步能力。 具体要求如下： 1、采取模块化方式进行程序设计，要求程序的功能设计、数据结构设计及整体结构设计合理。学生也可根据自己对题目的理解增加新的功能模块（视情况可另外加分）。 2、系统以菜单界面方式（至少采用文本菜单界面，如能采用图形菜单界面更好）工作，运行界面友好，演示程序以用户和计算机的对话方式进行。 3、程序算法说明清晰，理论分析与计算正确，运行情况良好，实验测试数据无误，容错性强（能对错误输入进行判断控制）。 4、编程风格良好（包括缩进、空行、适当注释、变量名和函数名见名知意，程序容易阅读等）； 5、写出规范的课程设计报告，具体要求见相关说明文档。 并行计算上机实验报告题目：多线程计算Pi值 学生姓名 学院名称计算机学院 专业计算机科学与技术时间 一. 实验目的 1、掌握集群任务提交方式； 2、掌握多线程编程。 二.实验内容 1、通过下图中的近似公式，使用多线程编程实现pi的计算； 2、通过控制变量N的数值以及线程的数量，观察程序的执行效率。 三.实现方法 1. 下载配置SSH客户端 2. 用多线程编写pi代码 3. 通过文件传输界面，将文件上传到集群上 4.将命令行目录切换至data，对.c文件进行编译 5.编写PBS脚本，提交作业 6.实验代码如下： #include #include 数值分析实验报告模板 篇一：数值分析实验报告(一)(完整) 数值分析实验报告 1 2 3 4 5 篇二：数值分析实验报告 实验报告一 题目：非线性方程求解 摘要：非线性方程的解析解通常很难给出，因此线性方程的数值解法就尤为重要。本实验采用两种常见的求解方法二分法和Newton法及改进的Newton法。利用二分法求解给定非线性方程的根，在给定的范围内，假设f(x,y)在[a,b]上连续，f(a)xf(b) 直接影响迭代的次数甚至迭代的收敛与发散。即若x0 偏离所求根较远，Newton法可能发散的结论。并且本实验中还利用利用改进的Newton法求解同样的方程，且将结果与Newton法的结果比较分析。 前言：（目的和意义） 掌握二分法与Newton法的基本原理和应用。掌握二分法的原理，验证二分法，在选对有根区间的前提下，必是收 敛，但精度不够。熟悉Matlab语言编程，学习编程要点。体会Newton使用时的优点，和局部收敛性，而在初值选取不当时，会发散。 数学原理： 对于一个非线性方程的数值解法很多。在此介绍两种最常见的方法：二分法和Newton法。 对于二分法，其数学实质就是说对于给定的待求解的方程f(x)，其在[a,b]上连续，f(a)f(b) Newton法通常预先要给出一个猜测初值x0，然后根据其迭代公式xk?1?xk?f(xk) f'(xk) 产生逼近解x*的迭代数列{xk}，这就是Newton法的思想。当x0接近x*时收敛很快，但是当x0选择不好时，可能会发散，因此初值的选取很重要。另外，若将该迭代公式改进为 xk?1?xk?rf(xk) 'f(xk) 其中r为要求的方程的根的重数，这就是改进的Newton 法，当求解已知重数的方程的根时，在同种条件下其收敛速度要比Newton法快的多。 程序设计： 本实验采用Matlab的M文件编写。其中待求解的方程写成function的方式，如下 function y=f(x); HUNAN UNIVERSITY 课程实习报告 题目：四则运算表达式求值 学生姓名： 学生学号： 专业班级： 指导老师： 完成日期： 一、需求分析 四则运算表达式求值，将四则运算表达式用中缀表达式表示，然后转换为后缀表达式，并计算结果。 本程序要求利用二叉树后序遍历来实现表达式的转换，同时可以使用实验2的结果来求解后缀表达式的值。 在字符界面上输入一个中缀表达式，回车表示结束。如果该中缀表达式正确，那么在字符界面上输出其后缀表达式，其中后缀表达式中两相邻操作数之间利用空格隔开；如果不正确，在字符界面上输出表达式错误提示。 测试数据 输入： 21+23*（12-6） 输出： 21 23 12 6 -*+ 二、详细设计 输入和输出的格式 输入 本程序可以将输入的四则运算表达式（中缀表达式）转换为后缀表达式 输出 后缀表达式为：//输出结果的位置 表达式的值为：//输出结果的位置 三、调试分析 本次实验的难点主要是在建立二叉树的问题上。关于如何把中缀表达式存入二叉树中，我参考了网上的一些方法，成功实现了目标，但是却遇到了一个问题，那就是不能处理小数，甚至两位或两位以上的整数。因为如果采用字符数组来存储操作数，运算符合一位整数还可以处理，但对于两位数就就会出问题，最后我改进采用字符串数组来存储操作数，成功解决了问题。 另外在处理输入的非法表达式问题中，我也费了很大功夫，但总体问题不大。 四、测试结果 五、用户使用说明（可选） 1、运行程序时 提示输入四则运算表达式 本程序可以将中缀表达式转化为后缀表达式，并计算结果 请输入四则运算表达式： 输出 后缀表达式为： 表达式的值为： 程序源代码（c++） #include 华中科技大学 课程名称并行处理 实验名称矩阵乘法的实现及加速比分析考生姓名李佩佩 考生学号 M201372734 系、年级计算机软件与理论2013级类别硕士研究生 考试日期 2014年1月3日 一. 实验目的 1) 学会如何使用集群 2) 掌握怎么用并行或分布式的方式编程 3) 掌握如何以并行的角度分析一个特定的问题 二. 实验环境 1) 硬件环境：4核CPU、2GB内存计算机； 2) 软件环境：Windows XP、MPICH2、VS2010、Xmanager Enterprise3； 3) 集群登录方式：通过远程桌面连接211.69.198.2，用户名：pppusr，密码：AE2Q3P0。 三. 实验内容 1. 实验代码 编写四个.c文件，分别为DenseMulMatrixMPI.c、DenseMulMatrixSerial.c、SparseMulMatrixMPI.c和SparseMulMatrixSerial.c，用于比较并行和串行矩阵乘法的加速比，以及稀疏矩阵和稠密矩阵的加速比。这里需要说明一下，一开始的时候我是把串、并行放在一个程序中，那么就只有两个.c文件DenseMulMatrix.c 和SparseMulMatrix.c，把串行计算矩阵乘的部分放到了主进程中，即procsID=0的进程，但是结果发现执行完串行后，再执行并行就特别的慢。另外，对于稀疏矩阵的处理方面可能不太好，在生成稀疏矩阵的过程中非0元素位置的生成做到了随机化，但是在进行稀疏矩阵乘法时没有对矩阵压缩，所以跟稠密矩阵乘法在计算时间上没多大区别。 方阵A和B的初始值是利用rand()和srand()函数随机生成的。根据稀疏矩阵和稠密矩阵的定义，对于稀疏矩阵和稠密矩阵的初始化方法InitMatrix(int *M,int *N,int len)会有所不同。这里需要说明一下，一开始对于矩阵A和B的初始化是两次调用InitMatrix(int *M ,int len)，生成A和B矩阵，但是随后我发现，由于两次调用方法InitMatrix的时间间隔非常短，又由于srand()函数的特点，导致生成的矩阵A和B完全一样；然后，我就在两次调用之间加入了语句“Sleep(1000)；”，加入头文件“#include 南京信息工程大学实验（实习）报告 一、实验目的: 用最小二乘法将给定的十个点拟合成三次多项式。 二、实验步骤： 用matlab编制以函数为基的多项式最小二乘拟合程序，并用于对下列数据作三次多项式最小二乘拟合(取权函数wi=1) x -2.5 -2 -1.5 -1 -0.5 0 0.5 1 1.5 2 y -2.30 -1 -0.14 -0.25 0.61 1.03 1.75 2.75 4.42 6.94 给定直线方程为：y=1/4*x3+1/2*x2+x+1 三、实验结论： 最小二乘法：通过最小化误差的平方和寻找数据的最佳函数匹配。利用最小二乘法可以简便地求得未知的数据，并使得这些求得的数据与实际数据之间误差的平方和为最小。最小二乘法还可用于曲线拟合。 一般地。当测量数据的散布图无明显的规律时，习惯上取n次代数多项式。 程序运行结果为： a = 0.9731 1.1023 0.4862 0.2238 即拟合的三次方程为：y=0.9731+1.1023x+0.4862*x2+0.2238*x3 -2.5 -2-1.5-1-0.5 00.51 1.52 2.5 -4-20246 81012 x 轴 y 轴 拟合图 离散点 y=a(1)+a(2)*x+a(3)*x.2+a(4)*x.3 结论： 一般情况下，拟合函数使得所有的残差为零是不可能的。由图形可以看出最小二乘解决了残差的正负相互抵消的问题，使得拟合函数更加密合实验数据。 优点：曲线拟合是使拟合函数和一系列的离散点与观测值的偏差平方和达到最小。 缺点：由于计算方法简单，若要保证数据的精确度，需要大量的数据代入计算。 多核编程与并行计算实验报告 姓名： 日期：2014年 4月20日 实验一 // exa1.cpp : Defines the entry point for the console application. // #include"stdafx.h" #include 实验二 // exa2.cpp : Defines the entry point for the console application. // #include"stdafx.h" #include《数值计算方法》上机实验报告
计算方法实验报告格式
算术表达式语法检查实验报告
并行计算第一次实验报告
数值分析实验报告模板
四则运算表达式求值实验报告
并行处理实验报告：用MPI实现的矩阵乘法的加速比分析
计算方法实验报告 拟合
多核编程与并行计算实验报告 (1)
相关文档
- 编译原理实验报告6 逆波兰式的翻译和计算
- 编译原理 逆波兰式的产生及计算
- 编译原理-实验报告4-逆波兰
- 逆波兰式
- 算术表达式的算符优先分析法 逆波兰
- 逆波兰式
- 编译原理实验三逆波兰式生成
- (编译原理)逆波兰式算法地源代码
- 编译原理实验三逆波兰式的产生及计算
- (编译原理)逆波兰式算法的源代码
- 编译原理(逆波兰表达式)c语言版
- 编译原理-逆波兰式的产生及计算
- 编译原理(逆波兰表达式)C语言版
- 算术表达式转换为用逆波兰式来表示的算术表达式
- 逆波兰式的产生与计算
- 编译原理实验报告6 逆波兰式的翻译和计算
- 编译原理-逆波兰式的产生及计算
- 逆波兰式算法
- 逆波兰式的转化与求值 栈与队列 实验报告
- 编译原理-逆波兰式的产生及计算