编译原理实验一·比较四种语言Python C++ Java Haskell编程效率，程序规模，运行效率，使用上述语言实现矩阵乘法的功能

实验目的

给定一个特定的功能，分别使用 C/C++、Java、Python 和 Haskell 实现该功 能，对采用这几种语言实现的编程效率，程序的规模，程序的运行效率进行对比 分析。例如分别使用上述几种语言实现一个简单的矩阵乘法程序，输入两个矩阵， 输出一个矩阵，并分析相应的执行效果。

实验过程

要求所有程序都执行以下相同的步骤：
1.创建两个200*200的矩阵，矩阵填入的内容就为矩阵当前列的列数
2.开始计时，然后执行矩阵乘法
3.打印结果并结束计时
4.输出计时时间

Haskell环境配置

brew install ghc

实验效果

c++

先编译后运行

Java

Python

直接运行，不用编译

Haskell

编译运行

源码

C++

#include <iostream>
#include <vector>
#include <sys/time.h>

using namespace std;

void printMat(vector<vector<int> > mat)
{
    for (int i = 0; i < mat.size(); i++)
    {
        for (int j = 0; j < mat[0].size(); j++)
        {
            cout << mat[i][j] << " ";
        }
        cout << endl;
    }
}

vector<vector<int> > mulMat(vector<vector<int> > mat1, vector<vector<int> > mat2)
{
    vector<vector<int> > result(mat1.size(), vector<int>(mat2[0].size(), 0));
    for (int i = 0; i < result.size(); i++)
    {
        for (int j = 0; j < result[0].size(); j++)
        {
            for (int k = 0; k < mat1[0].size(); k++)
            {
                result[i][j] += mat1[i][k] * mat2[k][j];
            }
        }
    }
    return result;
}

int main()
{
    vector<vector<int> > matrix_one;
    vector<vector<int> > matrix_two;

    for (int i = 0; i < 200; i++)
    {
        matrix_one.push_back(vector<int>());
        for (int j = 0; j < 200; j++)
        {
            matrix_one[i].push_back(j + 1);
        }
    }
    for (int i = 0; i < 200; i++)
    {
        matrix_two.push_back(vector<int>());
        for (int j = 0; j < 200; j++)
        {
            matrix_two[i].push_back(j + 1);
        }
    }
    timeval start, end;

    gettimeofday(&start, NULL);
    vector<vector<int> > result = mulMat(matrix_one, matrix_two);
    printMat(result);
    gettimeofday(&end, NULL);

    cout << "time : " << end.tv_usec - start.tv_usec << endl;
    return 0;
}

java

import javax.swing.plaf.synth.SynthUI;

public class Matrix
{
    public static void printMat(int mat[][])
    {
        for (int i = 0; i < mat.length; i++)
        {
            for (int j = 0; j < mat[0].length; j++)
            {
                System.out.print(mat[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static int[][] multiplyMatrix(int mat1[][], int mat2[][])
    {
        int[][] result = new int[mat1.length][mat2[0].length];
        for (int i = 0; i < result.length; i++)
        {
            for (int j = 0; j < result[i].length; j++)
            {
                for (int k = 0; k < mat1[0].length; k++)
                {
                    result[i][j] += mat1[i][k] * mat2[k][j];
                }
            }
        }
        return result;
    }

    public static void main(String[] args)
    {
        int matrix_num = 200;
        int[][] matrix_one = new int[matrix_num][matrix_num];
        int[][] matrix_two = new int[matrix_num][matrix_num];

        for (int i = 0; i < matrix_num; i++)
        {
            for (int j = 0; j < matrix_num; j++)
            {
                matrix_one[i][j] = j + 1;
            }
        }

        for (int i = 0; i < matrix_num; i++)
        {
            for (int j = 0; j < matrix_num; j++)
            {
                matrix_two[i][j] = j + 1;
            }
        }

        long start = System.currentTimeMillis();
        int result[][] = multiplyMatrix(matrix_one, matrix_two);
        printMat(result);
        long end = System.currentTimeMillis();

        System.out.println("time: " + (end - start) );
    }
}

python

import numpy
import time

matrix_num = 200
matrix_one = numpy.empty([matrix_num, matrix_num], dtype=int)
matrix_two = numpy.empty([matrix_num, matrix_num], dtype=int)

for i in range(matrix_num):
    for j in range(matrix_num):
        matrix_one[i][j] = j + 1

for i in range(matrix_num):
    for j in range(matrix_num):
        matrix_two[i][j] = j + 1

start = time.time()
result = numpy.dot(matrix_one, matrix_two)
print(result)
end = time.time()

print("time: " + str(end - start))

Haskell

import Text.Printf
import System.CPUTime

matrixGenerator n =
  let rowIndex n k = [x | x <- [1,2..n]]
  in [rowIndex n k | k <- [1,2..n]]

matMul x y =
    let
        col m = [x|x:xs <- m]
        rights m = [xs|x:xs <- m,length(xs) > 0 ]
        rowMulMat r []  = []
        rowMulMat r m   = sum(zipWith (*) r (col m)):(rowMulMat r (rights m))
    in case x of
        [r]     -> [rowMulMat r y]
        (r:rs)  -> (rowMulMat r y):(matMul rs y)

main = do
  let matrix_one = matrixGenerator 200
  let matrix_two = matrixGenerator 200

  startTime <- getCPUTime
  let product = matMul matrix_one matrix_two
  print product
  endTime <- getCPUTime

  let totalTime = (fromIntegral(endTime - startTime))/ (10 ^ 6)
  printf "time: %f ms\n" (totalTime :: Double)