实验 3 方法和数组

合集下载

数组实验报告反思心得

一、实验背景本次实验旨在通过学习数组的相关知识，掌握数组的定义、初始化、赋值、引用等方法，以及数组的操作和应用。

通过本次实验，我对数组有了更深入的理解，同时也对编程思维和算法设计有了更全面的提升。

二、实验过程1. 实验一：一维数组的定义与初始化实验过程中，我首先学习了如何定义一维数组，以及如何对数组进行初始化。

通过实验，我掌握了以下知识：（1）一维数组的定义格式：类型符数组名[常量表达式]；（2）一维数组的初始化方法：在定义数组时，可以在方括号内指定数组的长度，并为数组元素赋初值。

2. 实验二：二维数组的定义与初始化在实验二，我学习了二维数组的定义与初始化。

通过实验，我掌握了以下知识：（1）二维数组的定义格式：类型符数组名[常量表达式1][常量表达式2]；（2）二维数组的初始化方法：可以在定义数组时，指定数组的行数和列数，并为数组元素赋初值。

3. 实验三：数组元素的引用与赋值在实验三，我学习了如何引用数组元素，以及如何为元素赋值。

通过实验，我掌握了以下知识：（1）数组元素的引用方法：数组名[下标]；（2）数组元素的赋值方法：使用赋值运算符“=”。

4. 实验四：数组的操作与应用在实验四，我学习了数组的操作与应用，包括冒泡排序、选择排序等。

通过实验，我掌握了以下知识：（1）冒泡排序算法：通过比较相邻元素的大小，将较大的元素交换到后面，直到整个数组有序。

（2）选择排序算法：通过比较相邻元素的大小，选择最小（或最大）的元素放到数组的起始位置，然后继续对剩余的元素进行排序。

三、实验反思1. 数组的定义与初始化在实验过程中，我深刻体会到了数组在编程中的重要性。

数组作为一种数据结构，可以有效地存储和操作一组具有相同数据类型的元素。

通过对数组的定义与初始化，我学会了如何创建一个符合实际需求的数组，并为数组元素赋初值。

2. 数组元素的引用与赋值在实验过程中，我学会了如何引用数组元素，以及如何为元素赋值。

这使我更加熟练地掌握了数组的使用方法，为后续的编程实践打下了基础。

实验三刚体转动惯量的测定

实验三刚体转动惯量的测定转动惯量是刚体转动中惯性大小的量度。

它与刚体的质量、形状大小和转轴的位置有关。

形状简单的刚体，可以通过数学计算求得其绕定轴的转动惯量；而形状复杂的刚体的转动惯量，则大都采用实验方法测定。

下面介绍一种用刚体转动实验仪测定刚体的转动惯量的方法。

实验目的：1. 理解并掌握根据转动定律测转动惯量的方法；2. 熟悉电子毫秒计的使用。

实验仪器：刚体转动惯量实验仪、通用电脑式毫秒计。

仪器描述：刚体转动惯量实验仪如图一，转动体系由十字型承物台、绕线塔轮、遮光细棒等(含小滑轮）组成。

遮光棒随体系转动，依次通过光电门，每π弧度(半圈）遮光电门一次的光以计数、计时。

塔轮上有五个不同半径(r）的绕线轮。

砝码钩上可以放置不同数量的砝码，以获得不同的外力矩。

图一刚体转动惯量实验仪图二承物台俯视图实验原理：空实验台(仅有承物台）对于中垂轴OO’的转动惯量用J o表示，加上试样(被测物体）后的总转动惯量用J表示，则试样的转动惯量J1：J1＝ J –J o (1) 由刚体的转动定律可知：T r – M r＝ J (2) 其中M r为摩擦力矩。

而 T ＝ m(g -r α) (3) 其中 m —— 砝码质量g —— 重力加速度 α —— 角加速度 T —— 张力1. 测量承物台的转动惯量J o未加试件，未加外力(m ＝0 , T ＝0)令其转动后，在M r 的作用下，体系将作匀减速转动，α＝α1，有-M r1 ＝ J o α1(4) 加外力后，令α ＝α2m(g –r α2)r –M r1 ＝ J o α2(5)(4)(5)式联立得J o ＝212212mr mgrααααα---(6)测出α1 , α2，由(6)式即可得J o 。

2. 测量承物台放上试样后的总转动惯量J ，原理与1.相似。

加试样后，有-M r2＝J α3 (7) m(g –r α4)r –Mr 2＝ J α4 (8)∴ J ＝234434mr mgrααααα---(9)注意：α1 , α3值实为负，因此(6)、(9)式中的分母实为相加。

java 数组实验报告

java 数组实验报告Java 数组实验报告引言：在计算机科学领域中，数组是一种非常重要的数据结构。

它是一组相同类型的元素的集合，可以按照索引值来访问和操作其中的元素。

在本实验中，我们将探索 Java 中数组的特性和用法，并通过实际的代码示例来加深对数组的理解。

一、数组的定义和初始化在 Java 中，可以使用以下方式来定义和初始化一个数组：1. 声明数组变量并分配内存空间：int[] numbers = new int[5];这行代码声明了一个名为 numbers 的整型数组，它可以存储 5 个整数。

在内存中，会为这个数组分配连续的 5 个整型空间。

2. 直接初始化数组元素：int[] numbers = {1, 2, 3, 4, 5};这行代码声明了一个名为numbers 的整型数组，并直接初始化了数组的元素。

3. 动态初始化数组元素：int[] numbers = new int[5];numbers[0] = 1;numbers[1] = 2;numbers[2] = 3;numbers[3] = 4;numbers[4] = 5;这段代码先声明了一个名为 numbers 的整型数组，并为其分配了 5 个整型空间。

然后，通过索引值将具体的数值赋给数组的元素。

二、数组的访问和操作1. 访问数组元素：数组的元素可以通过索引值来访问，索引值从 0 开始，最大值为数组长度减一。

int firstNumber = numbers[0];这行代码将数组 numbers 的第一个元素赋值给整型变量 firstNumber。

2. 修改数组元素：数组的元素可以通过索引值进行修改。

numbers[0] = 10;这行代码将数组 numbers 的第一个元素修改为 10。

3. 数组的长度：数组的长度可以通过数组的 length 属性来获取。

int length = numbers.length;这行代码将数组 numbers 的长度赋值给整型变量 length。

数组的应用实验原理

数组的应用实验原理1. 实验目的本实验旨在掌握数组的概念、特性和应用，并通过实际案例加深对数组的理解。

2. 实验原理数组是一种用来存储相同类型的数据元素的数据结构。

它可以在内存中连续的存储多个元素，并通过索引值来访问和操作这些元素。

在实际应用中，数组常被用来存储一组相同类型的数据，例如整数、浮点数、字符等。

3. 实验步骤1.声明数组：首先需要声明一个数组，并指定数组的类型和名称。

例如，int[] numbers;表示声明一个整数类型的数组变量名为numbers。

2.创建数组：使用new关键字来创建数组。

例如，numbers = newint[5];表示创建了一个包含5个整数的数组。

3.初始化数组：可以在数组创建后对其中的元素进行初始化，也可以在声明数组时直接进行初始化。

例如，int[] numbers = {1, 2, 3, 4, 5};表示创建并初始化一个包含5个整数的数组。

4.访问数组元素：使用索引值来访问数组中的元素。

索引值从0开始，到数组长度减一。

例如，int x = numbers[2];表示将数组numbers中索引为2的元素赋值给变量x。

5.修改数组元素：通过索引值可以修改数组中的元素。

例如，numbers[0] = 10;表示将数组numbers中索引为0的元素修改为10。

6.遍历数组：使用循环结构可以遍历数组中的所有元素。

通过循环动态改变索引值，从而逐个访问数组中的元素。

例如，使用for循环来遍历数组：for (int i = 0; i < numbers.length; i++) {System.out.println(numbers[i]);}4. 实验案例下面通过一个简单的案例来说明数组的应用原理。

4.1 案例描述某班级有10名学生，需要统计每个学生的成绩，并计算平均分。

4.2 案例解决思路1.声明一个整数类型的数组scores用于存储学生成绩。

2.创建长度为10的数组：scores = new int[10];3.使用循环结构输入每个学生的成绩，并将其存储到数组中。

java数组实验报告

java数组实验报告《Java数组实验报告》在计算机编程中，数组是一种非常重要的数据结构，它可以存储多个相同类型的数据，并且可以通过索引来访问和操作这些数据。

在Java编程语言中，数组也是一个非常常用的数据类型，它可以用来解决各种问题，比如存储一组数字、字符串或者其他对象。

为了更好地理解和掌握Java数组的使用，我们进行了一系列的实验。

首先，我们学习了如何声明和初始化一个数组，以及如何访问和修改数组中的元素。

接着，我们实验了数组的遍历和排序，掌握了常见的数组操作技巧。

然后，我们深入研究了多维数组的使用，比如二维数组和三维数组，以及如何在程序中使用这些复杂的数据结构。

在实验过程中，我们发现了一些有趣的现象。

比如，在数组遍历和排序的过程中，我们可以通过循环和条件判断来实现各种不同的算法，从而对数组进行高效的操作。

另外，多维数组的使用也为我们提供了更多的可能性，可以用来表示更加复杂的数据结构，比如矩阵和图等。

通过这些实验，我们不仅深入理解了Java数组的使用方法，还提高了自己的编程技能。

我们相信，掌握了数组这一基础的数据结构，我们在以后的编程工作中一定会更加得心应手，能够更加高效地解决各种问题。

同时，我们也意识到，数组作为一种基础的数据结构，它的重要性不言而喻，我们应该不断地加强对它的学习和理解，以便更好地应用它来解决实际问题。

总之，通过这次实验，我们对Java数组有了更加深入的了解，也提高了自己的编程能力。

我们相信，通过不断地学习和实践，我们一定能够成为更加优秀的程序员，为社会的发展做出更大的贡献。

计算机系统基础实验介绍Lab3

Lab3 实验任务（续）
4）任务四：boom（续）本阶段的实验任务就是构造这样一个攻击字符串，使得 getbuf函数不管获得什么输入，都能将正确的cookie值返回给test函数，而不是返回值1。除此之外，你的攻击代码应还原任何被破坏的状态，将正确返回地址压入栈中，并执行ret 指令从而真正返回到test函数。
目标程序bufbomb续?缓冲区攻击从getbuf函数开始函数gets并不判断buf数组是否足够大它只是简单地向目标地址复制全部输入字符串因此输入如果超出预先分配的存储空间边界就会造成缓冲区溢出
计算机系统基础实验介绍Lab3
学术诚信
如果你确实无法完成实验, 你可以选择不提交。如果抄袭，不管抄袭者还是被抄袭者，均以零分论处并按作弊处分。
正常情况下，如果你的操作不符合预期（!success），会看到信息“Better luck next time”，这时你就要继续-8尝-
目标程序BUFBOMB（续）
• 本实验的主要内容从分析test函数开始。
test函数中调用了getbuf函数， getbuf函数的功能是从标准输入（stdin）读入一个字符串。
熟练运用gdb、objdump、gcc等工具。
-4-
二、实验数据
• /s/1hs2Mw1Q • 下载实验数据包： lab3.tar
在本地目录将数据包解压： tar –xf lab3.tar
数据包中至少包含下面四个文件：
* bufbomb：可执行程序，攻击所用的目标程序bufbomb。 * bufbomb.c： C语言源程序，目标程序bufbomb的主程序。 * makecookie：可执行程序，该程序基于你的学号产生一个唯一的由8
void fizz(int val) {

C语言程序设计实验指导含答案

C语言程序设计实验指导含答案实验一：C语言程序设计基础实验内容：本实验主要以C语言的基础语法为主，通过一些简单的示例和练习来帮助学生熟悉C语言的基本概念和语法规则。

实验步骤：1. 编写一个简单的C程序，输出"Hello, World!"。

要求程序能够顺利编译并执行。

答案：#include <stdio.h>int main(){printf("Hello, World!");return 0;}2. 基于上一题的程序，修改代码，要求程序输入一个整数，并将其乘以2输出。

答案：#include <stdio.h>int main(){int num;printf("请输入一个整数：");scanf("%d", &num);printf("乘以2的结果为：%d", num * 2);return 0;}3. 编写一个C程序，输入一个圆的半径，计算并输出其面积和周长。

要求保留2位小数。

答案：#include <stdio.h>#define PI 3.14159int main(){float radius;printf("请输入圆的半径：");scanf("%f", &radius);float area = PI * radius * radius;float circumference = 2 * PI * radius;printf("圆的面积为：%.2f\n", area);printf("圆的周长为：%.2f\n", circumference);return 0;}实验二：循环和判断语句实验内容：本实验主要通过不同的练习来帮助学生熟悉和掌握C语言中的循环和判断语句的使用方法。

C语言实验报告《数组》

C语言实验报告《数组》《数组》实验报告实验目的：掌握C语言中数组的定义、初始化和使用方法，了解数组在程序中的作用和用途，熟悉数组的基本操作。

实验内容：1.数组的定义和初始化2.数组的基本操作-访问数组元素-修改数组元素-遍历数组-数组作为函数参数实验步骤：1.数组的定义和初始化定义一个整型数组，数组名为array，数组大小为10。

使用for循环将数组元素初始化为0。

2.数组的基本操作1) 访问数组元素：通过下标访问数组的元素，例如array[0]表示数组的第一个元素。

2)修改数组元素：通过下标将数组的元素修改为新的值。

3) 遍历数组：使用for循环遍历数组的每个元素，并输出其值。

4)数组作为函数参数：将数组作为函数的参数传递，并在函数内对数组进行操作。

实验结果：1.数组的定义和初始化：int array[10];for (int i = 0; i < 10; i++)array[i] = 0;}2.数组的基本操作：1)访问数组元素：int x = array[0]; // 访问第一个元素的值，即数组的第一个元素2)修改数组元素：array[0] = 1; // 将第一个元素的值修改为13)遍历数组：for (int i = 0; i < 10; i++)printf("%d ", array[i]); // 输出每个元素的值}4)数组作为函数参数：void printArray(int arr[], int len)for (int i = 0; i < len; i++)printf("%d ", arr[i]); // 输出数组的每个元素}}int maiint myArray[5] = {1, 2, 3, 4, 5};printArray(myArray, 5); // 将数组myArray作为参数传递给printArray函数return 0;}实验总结：通过本次实验，我们掌握了C语言中数组的定义和初始化方法，学会了访问数组元素、修改数组元素、遍历数组的操作，还了解了数组作为函数参数的使用。

Python程序设计实验3：列表、元组的应用

Python程序设计实验3：列表、元组的应⽤实验3：列表、元组的应⽤1. 查找最⼤元素的索引编写函数 indicesOfLargestElement(list)，输⼊整数列表list, 返回 list 中最⼤元素所有的索引，索引以列表形式返回。

例⼦：IndexOfLargestElement([2, 1, 3, 1, 3]) # return [2,4]（1）具体思路通过max函数获取列表中的最⼤值，并通过循环在列表中查找，如果当前值等于最⼤值，则将下标存⼊列表中。

（2）编程实现# 定义函数def IndexOfLargestElement(list):return[i for i, a in enumerate(list)if a ==max(list)]# 主函数temp =[]print("Please input numbers to end with -1:")# 循环获取输出while True:a =eval(input())if a ==-1:breaktemp.append(a)# 进⾏输出print(IndexOfLargestElement(temp))函数部分通过enumerate()对列表进⾏遍历，并通过max函数获取列表中的最⼤值，并通过循环在列表中查找，如果当前值等于最⼤值，则将下标存⼊列表中。

主函数部分先定义空列表，使⽤while循环读⼊数字并以-1结束，若输⼊值为-1则break出循环，若不为-1则存⼊列表中。

完成列表元素读⼊后调⽤函数并输出。

（3）运⾏并测试①开始运⾏程序，将提⽰输⼊数字并以-1结尾：②完成输⼊后即输出结果：2. 合并两个排序的列表编写函数 merge(list1, list2)，将两个排序好的整数列表合并到⼀个新的排序列表中，返回这个新的列表。

使⽤两种⽅法实现 merge 函数：不使⽤ sort() 或 sorted()；使⽤ sort() 或 sorted()。

java实验报告--数组

java实验报告--数组Java实验报告 - 数组引言：Java是一种广泛应用于软件开发的编程语言，其强大的数组功能使得它成为处理大量数据的理想选择。

本实验报告将探讨Java中数组的基本概念、使用方法以及一些常见的应用场景。

一、数组的定义与初始化在Java中，数组是一种用于存储多个相同类型元素的数据结构。

数组可以存储基本数据类型（如整数、浮点数等）或者对象。

声明一个数组需要指定元素的类型和数组的名称，然后使用关键字"new"来创建数组对象。

二、数组的访问与操作通过索引（index）可以访问数组中的元素，索引从0开始计数。

例如，对于一个长度为10的整数数组，可以使用arr[0]来访问第一个元素，arr[1]来访问第二个元素，以此类推。

数组的长度可以通过arr.length来获取。

三、数组的遍历与排序遍历数组是指逐个访问数组中的元素。

常用的遍历方法有使用for循环和foreach循环。

对于需要对数组进行排序的情况，可以使用Java提供的排序算法（如快速排序、冒泡排序等）或者使用Arrays类中的sort方法。

四、多维数组除了一维数组，Java还支持多维数组。

多维数组可以看作是数组的数组，可以用于存储表格、矩阵等结构化数据。

在声明多维数组时，需要指定每一维的长度。

五、数组的应用场景1. 数据存储与处理：数组可以用于存储和处理大量数据，如学生成绩、员工工资等。

通过数组，可以方便地进行数据的查找、排序和统计等操作。

2. 图像处理：图像可以用二维数组表示，每个元素代表一个像素点的颜色值。

通过对数组的操作，可以实现图像的旋转、缩放等功能。

3. 算法实现：许多算法的实现都需要使用数组，如查找算法、排序算法等。

数组的高效访问和操作使得算法的实现更加简洁和高效。

六、实验案例：数组的查找与统计为了更好地理解数组的应用，我们设计了一个实验案例：数组的查找与统计。

假设有一个整数数组，我们需要找到其中的最大值、最小值、平均值以及某个特定元素的出现次数。

数组实验报告实验小结

一、实验背景随着计算机技术的不断发展，数组作为一种基本的数据结构，在编程领域得到了广泛的应用。

为了更好地理解和掌握数组的相关知识，我们进行了一系列的数组实验。

本次实验报告将对实验过程进行总结，并对实验结果进行分析。

二、实验目的1. 理解数组的基本概念和特点；2. 掌握数组的创建、访问和操作方法；3. 熟悉数组在编程中的应用；4. 培养实验操作能力和问题解决能力。

三、实验内容1. 数组的定义与创建2. 数组的初始化3. 数组元素的访问与修改4. 数组的排序与查找5. 数组的应用实例四、实验过程1. 数组的定义与创建实验一：定义一个整型数组，并初始化为10个元素。

代码如下：```c#include <stdio.h>int main() {int arr[10];// 初始化数组for (int i = 0; i < 10; i++) {arr[i] = i 2;}// 打印数组元素for (int i = 0; i < 10; i++) {printf("%d ", arr[i]);}printf("\n");return 0;}```2. 数组的初始化实验二：使用初始化列表直接初始化数组。

代码如下：```c#include <stdio.h>int main() {int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};// 打印数组元素for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) { printf("%d ", arr[i]);}printf("\n");return 0;}```3. 数组元素的访问与修改实验三：访问和修改数组元素。

代码如下：```c#include <stdio.h>int main() {int arr[5] = {1, 2, 3, 4, 5};// 访问数组元素printf("The first element is: %d\n", arr[0]);// 修改数组元素arr[0] = 10;printf("After modification, the first element is: %d\n", arr[0]); return 0;}```4. 数组的排序与查找实验四：使用冒泡排序算法对数组进行排序。

R语言实验三

R语⾔实验三实验三数组的运算、求解⽅程（组）和函数极值、数值积分【实验类型】验证性【实验学时】2 学时【实验⽬的】1、掌握向量的四则运算和内积运算、矩阵的⾏列式和逆等相关运算；2、掌握线性和⾮线性⽅程（组）的求解⽅法，函数极值的求解⽅法；3、了解 R 中数值积分的求解⽅法。

【实验内容】1、向量与矩阵的常见运算；2、求解线性和⾮线性⽅程（组）；3、求函数的极值，计算函数的积分。

【实验⽅法或步骤】第⼀部分、课件例题：1.向量的运算x<-c(-1,0,2)y<-c(3,8,2)v<-2*x+y+1vx*yx/yy^xexp(x)sqrt(y)x1<-c(100,200); x2<-1:6; x1+x22.x<-1:5y<-2*1:5x%*%ycrossprod(x,y)x%o%ytcrossprod(x,y)outer(x,y)3.矩阵的运算A<-matrix(1:9,nrow=3,byrow=T);AA+1 #A的每个元素都加上1B<-matrix(1:9,nrow=3); BC<-matrix(c(1,2,2,3,3,4,4,6,8),nrow=3); C D<-2*C+A/B; D #对应元素进⾏四则运算x<-1:9A+x #矩阵按列与向量相加E<-A%*%B; E #矩阵的乘法y<-1:3A%*%y #矩阵与向量相乘crossprod(A,B) #A的转置乘以Btcrossprod(A,B) #A乘以B的转置4.矩阵的运算A<-matrix(c(1:8,0),nrow=3);At(A) #转置det(A) #求矩阵⾏列式的值diag(A) #提取对⾓线上的元素A[lower.tri(A)==T]<-0;A #构造A对应的上三⾓矩阵qr.A<-qr(A);qr.A #将矩阵A分解成正交阵Q与上三⾓阵R的乘积，该结果为⼀列表Q<-qr.Q(qr.A);Q;R<-qr.R(qr.A);R #显⽰分解后对应的正交阵Q与上三⾓阵Rdet(Q);det(R);Q%*%R #A=Q*Rqr.X(qr.A) #显⽰分解前的矩阵5.解线性⽅程组A<-matrix(c(1:8,0),nrow=3,byrow=TRUE) b<-c(1,1,1)x<-solve(A,b); x #解线性⽅程组Ax=bB<-solve(A); B #求矩阵A 的逆矩阵BA%*%B #结果为单位阵f<-function(x) x^3-x-1 #建⽴函数uniroot(f,c(1,2)) #输出列表中f.root为近似解处的函数值，iter为迭代次数，estim.prec为精度的估计值uniroot(f,lower=1,upper=2) #与上述结果相同polyroot(c(-1,-1,0,1)) #专门⽤来求多项式的根，其中c(-1,-1,0,1)表⽰对应多项式从零次幂项到⾼次幂项的系数7.求解⾮线性⽅程组（1）⾃编函数： (Newtons.R)Newtons<-function (funs, x, ep=1e-5, it_max=100){index<-0; k<-1while (k<=it_max){ #it_max 表⽰最⼤迭代次数x1 <- x; obj <- funs(x);x <- x - solve(obj$J, obj$f); #Newton 法的迭代公式norm <- sqrt((x-x1) %*% (x-x1))if (norm}; k<-k+1 }obj <- funs(x);list(root=x, it=k, index=index, FunVal= obj$f)} # 输出列表（2）调⽤求解⾮线性⽅程组的⾃编函数funs<-function(x){ f<-c(x[1]^2+x[2]^2-5, (x[1]+1)*x[2]-(3*x[1]+1)) # 定义函数组J<-matrix(c(2*x[1], 2*x[2], x[2]-3, x[1]+1), nrow=2,byrow=T) # 函数组的 Jacobi 矩阵list(f=f, J=J)} # 返回值为列表 : 函数值 f 和 Jacobi 矩阵 Jsource("F:/wenjian_daima/Newtons.R") # 调⽤求解⾮线性⽅程组的⾃编函数Newtons(funs, x=c(0,1))8.⼀元函数极值f<-function(x) x^3-2*x-5 # 定义函数optimize(f,lower=0,upper=2) # 返回值 : 极⼩值点和⽬标函数f<-function(x,a) (x-a)^2 # 定义含有参数的函数optimize(f,interval=c(0,1),a=1/3) # 在函数中输⼊附加参数9.多元函数极值（1）obj <-function (x){ # 定义函数F<-c(10*(x[2]-x[1]^2),1-x[1]) # 视为向量sum (F^2) } # 向量对应分量平⽅后求和nlm(obj,c(-1.2,1))（2）fn<-function(x){ # 定义⽬标函数F<-c(10*(x[2]-x[1]^2), 1-x[1])t(F)%*%F } # 向量的内积gr <- function(x){ # 定义梯度函数F<-c(10*(x[2]-x[1]^2), 1-x[1])J<-matrix(c(-20*x[1],10,-1,0),2,2,byrow=T) #Jacobi 矩阵2*t(J)%*%F } # 梯度optim(c(-1.2,1), fn, gr, method="BFGS")最优点 (par) 、最优函数值 (value)10.梯形求积分公式（1）求积分程序： (trape.R)trape<-function(fun, a, b, tol=1e-6){ # 精度为 10 -6N <- 1; h <- b-a ; T <- h/2 * (fun(a) + fun(b)) # 梯形⾯积 repeat{h <- h/2; x<-a+(2*1:N-1)*h; I <-T/2 + h*sum(fun(x)) if(abs(I-T) < tol) break; N <- 2 * N; T = I }; I}（2）source("F:/wenjian_daima/trape.R") # 调⽤函数f<-function(x) exp(-x^2)trape(f,-1,1)（3）常⽤求积分函数f<-function(x)exp(-x^2) # 定义函数integrate(f,0,1)integrate(f,0,10)integrate(f,0,100)integrate(f,0,10000) # 当积分上限很⼤时，结果出现问题integrate(f,0,Inf) # 积分上限为⽆穷⼤ft<-function(t) exp(-(t/(1-t))^2)/(1-t)^2 # 对上述积分的被积函数 e 2 作变量代换 t=x/(1+x) 后的函数integrate(ft,0,1) # 与上述计算结果相同，且精度较⾼第⼆部分、教材例题：1.随机抽样（1）等可能的不放回的随机抽样:> sample(x, n) 其中x为要抽取的向量, n为样本容量（2）等可能的有放回的随机抽样:> sample(x, n, replace=TRUE)其中选项replace=TRUE表⽰有放回的, 此选项省略或replace=FALSE表⽰抽样是不放回的sample(c("H", "T"), 10, replace=T)sample(1:6, 10, replace=T)（3）不等可能的随机抽样:> sample(x, n, replace=TRUE, prob=y)其中选项prob=y⽤于指定x中元素出现的概率, 向量y与x等长度sample(c("成功", "失败"), 10, replace=T, prob=c(0.9,0.1))sample(c(1,0), 10, replace=T, prob=c(0.9,0.1))2.排列组合与概率的计算1/prod(52:49)1/choose(52,4)3.概率分布qnorm(0.025) #显著性⽔平为5%的正态分布的双侧临界值qnorm(0.975)1 - pchisq(3.84, 1) #计算假设检验的p值2*pt(-2.43, df = 13) #容量为14的双边t检验的p值4.limite.central( )的定义limite.central <- function (r=runif, distpar=c(0,1), m=.5,s=1/sqrt(12),n=c(1,3,10,30), N=1000) {for (i in n) {if (length(distpar)==2){x <- matrix(r(i*N, distpar[1],distpar[2]),nc=i)}else {x <- matrix(r(i*N, distpar), nc=i)}x <- (apply(x, 1, sum) - i*m )/(sqrt(i)*s)hist(x,col="light blue",probability=T,main=paste("n=",i), ylim=c(0,max(.4, density(x)$y))) lines(density(x), col="red", lwd=3)curve(dnorm(x), col="blue", lwd=3, lty=3, add=T)if( N>100 ) {rug(sample(x,100))}else {rug(x)}}}5.直⽅图x=runif(100,min=0,max=1)hist(x)6.⼆项分布B（10，0.1）op <- par(mfrow=c(2,2))limite.central(rbinom,distpar=c(10,0.1),m=1,s=0.9)par(op)7.泊松分布: pios（1）op <- par(mfrow=c(2,2))limite.central(rpois, distpar=1, m=1, s=1, n=c(3, 10, 30 ,50)) par(op)8.均匀分布：unif(0,1)op <- par(mfrow=c(2,2))limite.central( )par(op)9.指数分布：exp(1)op <- par(mfrow=c(2,2))limite.central(rexp, distpar=1, m=1, s=1)par(op)10.混合正态分布的渐近正态性mixn <- function (n, a=-1, b=1){rnorm(n, sample(c(a,b),n,replace=T))}limite.central(r=mixn, distpar=c(-3,3),m=0, s=sqrt(10), n=c(1,2,3,10)) par(op)11.混合正态分布的渐近正态性op <- par(mfrow=c(2,2))mixn <- function (n, a=-1, b=1){rnorm(n, sample(c(a,b),n,replace=T))}limite.central(r=mixn, distpar=c(-3,3),m=0,s=sqrt(10),n=c(1,2,3,10)) par(op)第三部分、课后习题：3.1a=sample(1:100,5)asum(a)3.2（1）抽到10、J、Q、K、A的事件记为A，概率为P(A)=其中在R中计算得：> 1/choose(52,20)[1] 7.936846e-15（2）抽到的是同花顺P(B)=在R中计算得：> (choose(4,1)*choose(9,1))/choose(52,5) [1] 1.385e-05 3.3#(1)x<-rnorm(1000,mean=100,sd=100)hist(x)#(2)y<-sample(x,500)hist(y)#(3)mean(x)mean(y)var(x)var(y)3.4x<-rnorm(1000,mean=0,sd=1) y=cumsum(x)plot(y,type = "l")plot(y,type = "p")3.5x<-rnorm(100,mean=0,sd=1) qnorm(.025)qnorm(.975)t.test(x)由R结果知：理论值为[-1.96,1.96]，实际值为：[-0.07929,0.33001]3.6op <- par(mfrow=c(2,2))limite.central(rbeta, distpar=c(0.5 ,0.5),n=c(30,200,500,1000))par(op)3.7N=seq(-4,4,length=1000)f<-function(x){dnorm(x)/sum(dnorm(x))}n=f(N)result=sample(n,replace=T,size = 1000)standdata=rnorm(1000)op<-par(mfrow=c(1,2)) #1⾏2列数组按列（mfcol）或⾏（mfrow）各⾃绘图hist(result,probability = T) lines(density(result),col="red",lwd=3)hist(standdata,probability = T)lines(density(standdata),col="red",lwd=3) par(op)。

数据类型实验报告(3篇)

第1篇一、实验目的1. 理解和掌握基本数据类型的概念及特点。

2. 掌握不同数据类型的存储方式和表示方法。

3. 能够根据实际需求选择合适的数据类型。

二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.8.53. 开发工具：PyCharm三、实验内容1. 基本数据类型实验2. 复杂数据类型实验3. 数据类型转换实验四、实验步骤及结果1. 基本数据类型实验（1）实验目的：了解基本数据类型的概念及特点。

（2）实验步骤：① 定义变量并赋值：a = 10，b = 'hello'，c = 3.14② 输出变量的类型：print(type(a))，print(type(b))，print(type(c))（3）实验结果：变量a的类型为int，变量b的类型为str，变量c的类型为float。

2. 复杂数据类型实验（1）实验目的：了解复杂数据类型的概念及特点。

（2）实验步骤：① 定义列表：list1 = [1, 2, 3, 'a', 'b', 'c']② 定义元组：tuple1 = (1, 2, 3, 'a', 'b', 'c')③ 定义字典：dict1 = {'name': 'Tom', 'age': 18, 'gender': 'male'}④ 定义集合：set1 = {1, 2, 3, 'a', 'b', 'c'}（3）实验结果：列表list1的类型为list，元组tuple1的类型为tuple，字典dict1的类型为dict，集合set1的类型为set。

3. 数据类型转换实验（1）实验目的：掌握不同数据类型之间的转换方法。

（2）实验步骤：① 将字符串转换为整数：str1 = '123'，int1 = int(str1)②将整数转换为浮点数：int2 = 10，float1 = float(int2)③ 将浮点数转换为字符串：float2 = 3.14，str2 = str(float2)（3）实验结果：字符串str1转换为整数int1的结果为123，整数int2转换为浮点数float1的结果为10.0，浮点数float2转换为字符串str2的结果为'3.14'。

《数据结构》实验报告三：几种查找算法的实现和比较

第三次实验报告：几种查找算法的实现和比较//2019-12-4//1.随机生成5万个整数，存入一个文件；//2.算法实现：（1）顺序查找：读入文件中的数据，查找一个key，统计时间；// （2）二分查找：读入文件，排序，二分查找key，统计时间；// （3）分块查找：读入文件，分100块，每块300+数字，查找key，统计时间// （4）二分查找树：读入文件，形成BST，查找key，统计时间//二叉排序树：建立，查找#include "stdio.h"#include "time.h"#include "stdlib.h"struct JD{//定义分块查找的链表结点结构int data;JD *next;};struct INDEX_T{//定义分块查找中，索引表结构int max;//这一块中最大的数字，<maxJD *block;//每一块都是一个单向链表，这是指向块的头指针};INDEX_T myBlock[100];//这是索引表的100项struct NODE{//定义的二分查找树结点结构int data;NODE *left;NODE *right;};const int COUNT=50000;//结点个数int key=666;//待查找的关键字int m=1;//int *array2;void createData(char strFileName[]){//产生随机整数，存入文件srand((unsigned int)time(0));FILE *fp=fopen(strFileName,"w");for(int i=1;i<=COUNT;i++)fprintf(fp,"%d,",rand());fclose(fp);}void createBST(NODE* &bst){//产生5万个随机整数，创建二叉排序树FILE *fp=fopen("data.txt","r");for(int i=1;i<=COUNT;i++){int num;fscanf(fp,"%d,",&num);//从文件中读取一个随机整数//若bst是空子树，第一个结点就是根结点//若bst不是空子树，从根结点开始左小右大，查找这个数字，找到了直接返回，//找不到，就插入到正确位置//创建一个结点NODE* p=new NODE;p->data=num;p->left=0;p->right=0;if(0==bst)//空子树{bst=p;continue;}//非空子树,//在bst中，查找给结点，NODE *q=bst;//总是从根结点开始查找while(1){if(p->data == q->data)//找到了，直接退出break;if(p->data < q->data && q->left==0){//小，往左找，且左边为空，直接挂在q之左q->left=p;break;}if(p->data < q->data && q->left!=0){//小，往左找，且左边非空，继续往左边找q=q->left;continue;}if(p->data > q->data && q->right==0){//大，往右找，且右边为空，直接挂在q之右q->right=p;break;}if(p->data > q->data && q->right!=0){//大，往右找，且右边非空，继续往右边找q=q->right;continue;}}}}int BST_Search(NODE *bst,int key){//在bst中找key，if(0==bst)return -1;//非空子树,//在bst中，查找给结点，NODE *q=bst;//总是从根结点开始查找while(1){if(key == q->data)//找到了，直接退出return 1;if(key < q->data && q->left==0)//小，往左找，且左边为空，找不到return -1;if(key < q->data && q->left!=0)//小，往左找，且左边非空，继续往左边找{q=q->left;continue;}if(key > q->data && q->right==0)//大，往右找，且右边为空，找不到return -1;if(key > q->data && q->right!=0){//大，往右找，且右边非空，继续往右边找q=q->right;continue;}}}void inOrder(NODE *bst){if(bst!=0){inOrder(bst->left);array2[m]=bst->data;//反写回array数组，使数组有序// printf("%7d",array2[m]);m++;inOrder(bst->right);}}int getBSTHeight(NODE *bst){if(bst==0)return 0;else{int hl=getBSTHeight(bst->left);int hr=getBSTHeight(bst->right);int h=hl>hr?hl:hr;return h+1;}}void makeArray(int array[],char strFileName[]) {//生成5万个随机整数FILE *fp=fopen(strFileName,"r");int i=1;while(!feof(fp)){fscanf(fp,"%d,",&array[i]);// printf("%6d",array[i]);i++;}}int Seq_Search(int array[],int key){//在无序顺序数组中，找data是否存在，-1=不存在，存在返回位置下标//监视哨：把要找的那个数放到首部array[0]=key;//for(int i=COUNT;array[i]!=key;i--);if(i>0)//找到了，返回下标return i;return -1;//查找不成功，返回-1}int Bin_Search(int array[],int key){//在有序存储的数组中查找key，找到返回位置，找不到返回-1 int low=1,high=COUNT,mid;while(1){if(low>high)//找不到return -1;mid=(low+high)/2;if(key == array[mid])return mid;else if(key<array[mid])high=mid-1;elselow=mid+1;}}void makeBlock(INDEX_T myBlock[],char strFileName[]) {//从文件中读取整数，分配到块中去//1.初始化块索引表，分100块，400,800,1200，for(int i=0;i<=99;i++){myBlock[i].max=400+400*i;//400,800,1200, (40000)myBlock[i].block=0;}//2.打开文件，读取整数，把每一个整数分配到相应的块中去FILE *fp=fopen(strFileName,"r");while(!feof(fp)){int num=0;fscanf(fp,"%d,",&num);//把num分配到num/400块中，挂到该块链表第一个int blockID=num/400;//求出应该挂在的块号//生成一个新节点，把num放进去，挂上JD *p=new JD;p->data=num;p->next=myBlock[blockID].block;myBlock[blockID].block=p;}fclose(fp);}int Block_Search(INDEX_T myBlock[],int key){int blockID=key/400;//找到块号JD* p=myBlock[blockID].block;while(p!=0){if(p->data==key)return blockID;//能找到p=p->next;}return -1;//找不到}void main(){clock_t begin,end;int pos=-1;//1.生成文件，存入5万个随机整数createData("data.txt");//2.顺序查找int *array=new int[COUNT+1];makeArray(array,"data.txt");//从文件中读取数据begin=clock();for(int k=1;k<=10000;k++)pos=Seq_Search(array,key);end=clock();printf("顺序查找：%d所在的位置=%d.时间=%d毫秒\n",key,pos,end-begin);//3.二分查找树NODE *bst=0;createBST(bst);//产生5万个随机数字，建立一个二叉排序树begin=clock();for(k=1;k<=10000;k++)pos=BST_Search(bst,key);//在bst中找key，找到返回1，找不到返回-1end=clock();printf("二叉排序树查找：%d所在的位置=%d.时间=%d毫秒\n",key,pos,end-begin);array2=new int[COUNT+1];inOrder(bst);//中序输出bst// int height=getBSTHeight(bst);//求出bst的高度// printf("BST高度=%d.\n\n",height);//4.二分查找，利用前面二叉排序树产生的array2，查找key begin=clock();for(k=1;k<=10000;k++)pos=Bin_Search(array2,key);end=clock();printf("二分查找：%d所在的位置=%d.时间=%d毫秒\n",key,pos,end-begin);//5.分块查找，关键字范围[0,32767],分配到100块中去，每一块中存400个数字makeBlock(myBlock,"data.txt");//从文件中读取数据，产生块begin=clock();for(k=1;k<=10000;k++)pos=Block_Search(myBlock,key);//在block中查找key，找到返回块号，找不到返回-1end=clock();printf("分块查找：%d所在的块=%d.时间=%d毫秒\n",key,pos,end-begin);/*for(k=0;k<=99;k++){printf("\n\n\n第%d块<%d:\n",k,myBlock[k].max);JD *q=myBlock[k].block;//让q指向第k块的第一个结点while(q!=0){//输出第k块中所有数字printf("%7d ",q->data);q=q->next;}}*/}。

MATLAB实验报告一二三

2015秋2013级《MATLAB程序设计》实验报告实验一班级：软件131 姓名：付云雷学号：132872一、实验目的：1、了解MATLAB程序设计的开发环境，熟悉命令窗口、工作区窗口、历史命令等窗口的使用。

2、掌握MATLAB常用命令的使用。

3、掌握MATLAB帮助系统的使用。

4、熟悉利用MATLAB进行简单数学计算以及绘图的操作方法。

二、实验内容：1、启动MATLAB软件，熟悉MATLAB的基本工作桌面，了解各个窗口的功能与使用。

图1 MATLAB工作桌面2、MATLAB的常用命令与系统帮助:(1)系统帮助help：用来查询已知命令的用法。

例如已知inv是用来计算逆矩阵，键入help inv即可得知有关inv命令的用法。

lookfor：用来寻找未知的命令。

例如要寻找计算反矩阵的命令，可键入lookfor inverse，MATLAB即会列出所有和关键字inverse相关的指令。

找到所需的命令後，即可用help进一步找出其用法。

(2)数据显示格式:常用命令：说明format short 显示小数点后4位（缺省值）format long 显示15位format bank 显示小数点后2位format + 显示+，-，0format short e 5位科学记数法format long e 15位科学记数法format rat 最接近的有理数显示(3)命令行编辑：键盘上的各种箭头和控制键提供了命令的重调、编辑功能。

具体用法如下：↑----重调前一行（可重复使用调用更早的）↓----重调后一行→----前移一字符←----后移一字符home----前移到行首end----移动到行末esc----清除一行del----清除当前字符backspace----清除前一字符(4)MATLAB工作区常用命令：who--------显示当前工作区中所有用户变量名whos--------显示当前工作区中所有用户变量名及大小、字节数和类型disp(x) -----显示变量X的内容clear -----清除工作区中用户定义的所有变量save文件名-----保存工作区中用户定义的所有变量到指定文件中load文件名-----载入指定文件中的数据3、在命令窗口执行命令完成以下运算，观察workspace的变化，记录运算结果。

java实验报告--数组

java实验报告--数组实验名称：Java实验报告--数组实验目的：通过本次实验，掌握Java中数组的基本概念、声明和初始化方法，以及数组的基本操作和常见问题解决方法。

实验过程：1. 数组的声明和初始化在Java中，数组是一种特殊的数据类型，用于存储同一类型的多个数据。

数组的声明和初始化可以通过以下方式进行：```javaint[] arr1 = new int[5]; // 声明一个长度为5的整型数组int[] arr2 = {1, 2, 3, 4, 5}; // 声明并初始化一个整型数组String[] arr3 = new String[]{"Java", "C", "Python"}; // 声明并初始化一个字符串数组```2. 数组的基本操作数组的基本操作包括访问元素、修改元素、获取数组长度等。

例如：```javaint[] arr = {1, 2, 3, 4, 5};System.out.println(arr[0]); // 访问数组的第一个元素arr[1] = 10; // 修改数组的第二个元素System.out.println(arr.length); // 获取数组的长度```3. 数组的常见问题解决方法在使用数组时，常见的问题包括数组越界、空指针异常等。

针对这些问题，可以采取以下解决方法：- 使用循环结构遍历数组时，注意控制循环变量的范围，避免数组越界；- 在访问数组元素之前，先判断数组是否为空，避免空指针异常的发生。

实验结果：通过本次实验，我掌握了Java中数组的基本概念、声明和初始化方法，以及数组的基本操作和常见问题解决方法。

在实际编程中，我能够更加灵活地运用数组，提高代码的效率和可靠性。

结论：数组是Java中非常重要的数据结构，掌握数组的基本概念和操作方法对于编写高效、健壮的程序至关重要。

通过本次实验，我对数组有了更深入的了解，为以后的Java编程打下了坚实的基础。

数组实验报告实验分析

一、实验目的1. 理解数组的概念和基本操作。

2. 掌握数组的创建、初始化、访问和修改方法。

3. 学习数组的排序、查找和统计等常用算法。

4. 分析数组在实际应用中的优缺点。

二、实验内容1. 数组的创建与初始化2. 数组元素的访问与修改3. 数组的排序4. 数组的查找5. 数组的统计6. 数组在实际应用中的优缺点分析三、实验过程1. 数组的创建与初始化在实验中，我们首先学习了如何创建一个数组。

在C语言中，可以使用以下语句创建一个整型数组：int arr[10];这里创建了一个包含10个整数的数组，名称为arr。

接下来，我们学习了如何初始化数组。

初始化可以通过以下语句实现：int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};这里初始化了一个包含10个整数的数组，并将前10个整数依次赋值给数组元素。

2. 数组元素的访问与修改访问数组元素可以通过以下语句实现：int value = arr[3]; // 获取数组第4个元素的值修改数组元素可以通过以下语句实现：arr[5] = 20; // 将数组第6个元素的值修改为203. 数组的排序在实验中，我们学习了冒泡排序算法。

冒泡排序是一种简单的排序算法，其基本思想是通过比较相邻的元素，将较大的元素交换到数组的后面。

以下是冒泡排序算法的C语言实现：void bubbleSort(int arr[], int n) {int i, j, temp;for (i = 0; i < n - 1; i++) {for (j = 0; j < n - i - 1; j++) {if (arr[j] > arr[j + 1]) {temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}4. 数组的查找在实验中，我们学习了二分查找算法。

二分查找算法是一种高效的查找算法，其基本思想是将查找区间分为两半，每次查找时缩小查找范围。

matlab 实验三 matlab程序设计与优化

matlab 实验三 matlab程序设计与优化Matlab是一种高级的计算机编程语言，广泛应用于科学、工程、金融和其他领域。

在Matlab实验三中，我们将学习Matlab程序设计与优化。

本文将介绍Matlab实验三的内容和要求，并提供一些有用的技巧和建议，帮助读者更好地完成实验。

实验三的主要内容包括：1. Matlab程序设计基础2. Matlab程序优化技巧3. Matlab代码调试方法4. Matlab性能分析工具5. 实例分析与练习题下面我们将逐个介绍这些内容。

1. Matlab程序设计基础在本节中，我们将学习如何使用Matlab编写简单的程序。

以下是一些重要的概念和技巧：1）变量和数据类型：在Matlab中，变量可以存储不同类型的数据，如数字、字符串、逻辑值等。

常见的数据类型包括double、char、logical等。

2）运算符：Matlab支持各种数学运算符，包括加减乘除、幂运算等。

此外，还有逻辑运算符（如and、or）和比较运算符（如==、~=）。

3）控制结构：控制结构可以控制程序执行流程。

常见的控制结构包括if语句、for循环和while循环。

4）函数：函数是一种可重复使用的代码块，可以接受输入参数并返回输出结果。

Matlab中有很多内置函数，也可以编写自己的函数。

2. Matlab程序优化技巧在本节中，我们将学习如何优化Matlab程序以提高其性能。

以下是一些重要的技巧：1）向量化：向量化是一种将循环操作转换为矩阵操作的技术。

这样可以减少程序执行时间，并且使代码更简洁。

2）预分配数组：在编写Matlab程序时，应尽可能避免动态数组分配。

相反，应该预先分配所需大小的数组。

3）使用内置函数：Matlab中有许多内置函数，它们通常比用户自定义函数更快。

因此，在编写程序时应尽可能使用内置函数。

4）避免不必要的计算：在编写程序时，应尽可能避免不必要的计算。

例如，在循环中进行重复计算或计算已知结果等。

实验3 数组编程

实验三数组编程（设计性实验）一、实验目的1．进一步理解和掌握Java语言中数组的概念；2．掌握数组在方法中的使用，包括把数组传递给方法和从方法中返回数组，并能使用数组进行程序设计。

二、实验教学要求1．性质：必做实验实验类型：设计性2．时间要求：在讲完“数组”之后安排，需要6学时。

2．对学生的要求：编写好程序。

3．对教师的要求：预做本实验。

4．对实验室的要求：在windows环境中装有Java开发工具（如J2SE5.0版），以及IE6.0以上版本。

二、实验原理创建Java数组需要下面三个步骤：①声明数组声明数组的语法格式有如下两种：数组元素类型数组名[ ];数组元素类型[ ] 数组名;如int a[ ];int[ ] a;②创建数组空间声明数组仅仅指定了数组的名字和数组元素的类型，要想真正使用数组还需要为它分配内存空间，即创建数组空间。

在创建数组空间时，必须指明数组的长度，以确定空间的精确大小。

语法格式为：数组名=new 数组元素类型[数组元素的个数];如：int a[ ];a=new int[10];以上两步可组合在一起，用一条语句完成：int a[ ]=new int[10];用new运算符为数组分配内存空间的同时，数组的每个元素都会被自动赋予一个默认值。

整型为0，浮点型为0.0，字符型为'\0'，布尔型为false，引用型为null。

③初始化数组元素如果是基本数据类型，那么这个步骤可以自行省略。

也可以在创建数组空间的时候，同时将初始值给出。

如：int a[ ]={1,2,3,4}; //int[] a=new int[]{1,2,3,4}在Java语言中，一个数组就是一个对象。

每个数组都有一个属性length，用来指明数组的长度。

数组元素的类型可以是基本数据类型，也可以是类类型，因此可以使用数组来包含一系列的对象。

student ——类名student s[ ]=new student[50];创建元素需使用如下形式的代码段：for(int i=0;i<s.length;++i){s[i]=new student( );}三、实验实例1.数据排序。

实验 3 方法和数组

数组实验报告反思心得

实验三 刚体转动惯量的测定

java 数组实验报告

数组的应用实验原理

java数组实验报告

计算机系统基础实验介绍Lab3

C语言程序设计实验指导含答案

C语言实验报告《数组》

Python程序设计实验3：列表、元组的应用

java实验报告--数组

数组实验报告实验小结

R语言实验三

数据类型实验报告(3篇)

《数据结构》实验报告三：几种查找算法的实现和比较

MATLAB实验报告一二三

java实验报告--数组

数组实验报告实验分析

matlab 实验三 matlab程序设计与优化

实验3 数组编程

实验三刚体转动惯量的测定