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

最新推荐文章于 2023-07-04 20:08:10 发布

女主对此感到厌烦

最新推荐文章于 2023-07-04 20:08:10 发布

阅读量1.7k

点赞数 4

分类专栏：编译原理实验报告文章标签： java c语言 python

本文链接：https://blog.csdn.net/m0_56638814/article/details/127690514

版权

编译原理实验报告专栏收录该内容

3 篇文章 15 订阅

订阅专栏

一、实验目的

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

二、实验内容

分别使用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<String> list = new ArrayList<String>();
        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<stdio.h>

#include<time.h>

#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<N;x++)

for(y=0;y<N;y++)

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

fclose(file);

}

void mul()

{

int i,j,k;

for(i=0;i<N;i++)

{

for(j=0;j<N;j++)

{

b[i][j] = 0;

for(k=0;k<N;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编译器必须显式设置优化标志才可以。