编译原理实验一、程序设计语言认知实验报告

一、实验目的

了解程序设计语言的发展历史，了解不同程序设计语言的各自特点：感受编译执行和解释执行两种不同的执行方式，初步体验语言对编译器设计的影响，为后续编译程序的设计和开发奠定良好的基础。

二、实验内容

分别使用C、Java、Python实现矩阵乘法，对采用这几种语言实现的编程效率，程序的规模，程序的运行效率进行对比分析。方便起见，本次实验采用的都是n维方阵的矩阵乘法。同时为了保证实验的合理性，所有矩阵乘法均未采用其他库。

本次实验的方阵维度分别为：10、100、500、1000，为了减少误差，每组数据均重复十次并取时间的平均值。

三、实验环境

Linux系统（Ubuntu、Debian、Gentoo等系统均可），gcc 7.3.0，g++ 7.3.0，Java JDK 1.8，Python 3.6(以上编译器\解释器均可使用更高版本)。

四、数据准备

本次实验数据均在data文件夹下，由该文件夹下的produce_data.py脚本生成，生成的数据范围为[-100, 100)。如需更多实验数据，可自行修改脚本内容进行数据生成。

文件名	含义
matrix10.txt	维度为10的方阵
matrix100.txt	维度为100的方阵
matrix500.txt	维度为500的方阵
matrix1000.txt	维度为1000的方阵

五、实验过程设计

本实验分别使用C、Java、Python实现矩阵乘法，c语言由Dev-C++执行, Java由idea执行，Python由Visual Studio Code执行，本次实验采用的都是n维方阵的矩阵乘法，方阵维度分别为：10、100、500、1000，从矩阵计算函数开始执行计时，到执行完毕结束计时，打印出计算时间，为了减少误差，每组数据均重复十次并取时间的平均值。

import time
def readFile():
    data_list = []
    with open("./matrix500.txt", 'r') as f:
        lines = f.readlines()
        for line in lines:
            line = line.rstrip()
            intData_List = list(map(int,line.split(" ")))
           data_list.append(intData_List)
    return data_list

def matrixMul(A, B):
    C = [[0] * len(B[0]) for i in range(len(A))]

    start = time.perf_counter()
    for i in range(len(A)):
               for j in range(len(B[0])):
                        for k in range(len(B)):
                C[i][j] += A[i][k] * B[k][j]
    end = time.perf_counter()
    return end-start

if __name__ == '__main__':
    A = readFile()
    t = matrixMul(A, A)
    print("time = " + str(t) + "s")

Java

package 矩阵;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class Juzhen {
    static int N = 10;
    int[][] m = new int[N][N];
    int[][] r = new int[N][N];

    public Juzhen() throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("src/矩阵/matrix10.txt"));
        List list = new ArrayList();
        String line = null;
        while((line = br.readLine())!=null){
            list.add(line);
        }
        br.close();
        for (int i = 0; i < N; i++) {
            String[] arr = list.get(i).trim().split(" ");
            for (int j = 0; j < N; j++) {
                m[i][j] = Integer.parseInt(arr[j]);
            }

        }
    }
    public void MatrixMulti(){
        long start,end;
        double t = 0;
        start = System.nanoTime();

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                for (int k = 0; k < N; k++) {
                    r[i][j] += m[i][k] * m[k][j];
                }
            }
        }
        end = System.nanoTime();
        t = (double)(end - start)/1000000000;
        System.out.println("time = " + t + "s");
    }
    public static void main(String[] args) throws IOException {
        Juzhen r = new Juzhen();
        r.MatrixMulti();
    }
}

#include

#define N 10

static int a[N][N],b[N][N];

void readFile()

{

int x,y;

FILE *file=fopen("matrix10.txt","r");

for(x=0;x

for(y=0;y

fscanf(file,"%d",&a[x][y]);

fclose(file);

}

void mul()

{

int i,j,k;

for(i=0;i

{

for(j=0;j

{

b[i][j] = 0;

for(k=0;k

b[i][j] += a[i][k] * a[k][j];

}

int main()

{

int i,time[10];

clock_t start,end;

readFile();

start = clock();

mul();

end = clock();

printf("time=%f\n",((double)end-start)/1000);

}

七、实验结果及分析

Python

N	10	100	500	1000
1	0.0002438	0.172358	19.65427	163.9216
2	0.0002352	0.168675	19.65298	163.7512
3	0.0002298	0.178036	19.65433	163.6524
4	0.0002438	0.173581	19.65589	163.5193
5	0.0002512	0.172653	19.65281	163.6217
6	0.0002487	0.174702	19.65094	163.4518
7	0.0002365	0.172974	19.65853	163.6539
8	0.0002279	0.172853	19.65706	163.5210
9	0.0002394	0.175673	19.65573	163.6218
10	0.0002447	0.169228	19.65924	163.3516
平均	0.0002	0.17	19.65	163.6

JAVA

N	10	100	500	1000
1	0.0000547	0.008729	0.222921	2.257617
2	0.0000492	0.008135	0.226725	2.256743
3	0.0000537	0.009169	0.222178	2.247857
4	0.0000584	0.009054	0.222836	2.259637
5	0.0000463	0.007247	0.223849	2.257346
6	0.0000582	0.008315	0.225821	2.258659
7	0.0000527	0.008292	0.222672	2.260627
8	0.0000519	0.007346	0.228923	2.256752
9	0.0000537	0.008791	0.227241	2.252926
10	0.0000482	0.008213	0.223921	2.247617
平均	0.00005	0.008	0.22	2.25

N	10	100	500	1000
1	0.0	0.0	0.003	0.009
2	0.0	0.0	0.003	0.010
3	0.0	0.0	0.004	0.013
4	0.0	0.0	0.002	0.009
5	0.0	0.0	0.004	0.011
6	0.0	0.0	0.003	0.010
7	0.0	0.0	0.003	0.009
8	0.0	0.0	0.002	0.010
9	0.0	0.0	0.002	0.012
10	0.0	0.0	0.004	0.009
平均	0.0	0.0	0.003	0.010

通过上述实验数据的对比，清晰得展现出了当数组维数较少时三种语言的执行速度差不多，随着维数增大，表现出C语言执行速度最快，Python执行速度最慢。

八、实验心得体会

通过这次实验，我了解了不同程序设计语言的各自特点并感受到编译执行和解释执行两种不同的执行方式，初步体验语言对编译器设计的影响，从数据可以看出Python作为一门解释型语言确实执行效率很慢，但是Python代码相比C语言、Java语言代码稍微简短一些，另外Java JIT编译器会自动执行优化，但对于GCC编译器必须显式设置优化标志才可以。

相关阅读:
学习笔记二十九：K8S配置管理中心Configmap实现微服务配置管理
 数据结构——队列
 性能分析插件
 为 GitHub 设置 SSH 密钥
 Rust有没有信号量机制，在缓存有数据的时候才允许等待的进程取数据？
Hydra常用爆破命令
 JavaScript基础(11)_方法、枚举对象中的属性、作用域
 C++二分查找算法：有序矩阵中的第 k 个最小数组和
 将java的项目jar包打成镜像
 OpenGait：首个步态识别框架开源了！
原文地址：https://blog.csdn.net/m0_56638814/article/details/127690514

编译原理实验一、 程序设计语言认知实验报告

编译原理实验一、程序设计语言认知实验报告