【11種言語比較】プログラミング言語の”処理速度”を考える

#include <iostream>
#include <chrono>
#include <cmath>
#include <iomanip>


// ライプニッツ公式計算
double CalculateLeibnizFormula(int n) {
    double pi_approx = 0.0;
    double sign = 1;
    for (int i = 0; i < n; i++) {
        pi_approx += sign / (2.0 * i + 1.0);
        sign = -sign;
    }
    pi_approx *= 4.0;
    return pi_approx;
}


int main() {
    // 計算する項数(1億回)
    const int n = 100000000;
    // 計測開始時間
    const auto start_time = std::chrono::high_resolution_clock::now();

    // ライプニッツ公式計算
    const double pi_approx = CalculateLeibnizFormula(n);

    // 誤差
    const double calculation_error = fabs(M_PI - pi_approx);
    // 計測終了時間
    const auto end_time = std::chrono::high_resolution_clock::now();
    // 計算時間
    const auto elapsed_millisec
        = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count();

    std::cout << "円周率近似値  : " << pi_approx << std::endl;
    std::cout << "計算誤差      : " << calculation_error << std::endl;
    std::cout << "経過時間[msec]: " << elapsed_millisec << std::endl;

    return 0;
}

docker run --rm -v "$PWD":/usr/src/leibniz -w /usr/src/leibniz gcc g++ leibniz.cpp -o leibniz_cpp
./leibniz_cpp

import java.time.Duration;
import java.time.Instant;

public class Leibniz {

    // ライプニッツ公式計算
    public static double calculateLeibnizFormula(int n) {
        double piApprox = 0.0;
        double sign = 1.0;
        for (int i = 0; i < n; i++) {
            piApprox += sign / (2.0 * i + 1.0);
            sign = -sign;
        }
        piApprox *= 4.0;
        return piApprox;
    }
    
    public static void main(String[] args) {
        // 計算する項数(1億回)
        final int n = 100000000;
        // 計測開始時間
        Instant startTime = Instant.now();

        // ライプニッツ公式計算
        final double piApprox = Leibniz.calculateLeibnizFormula(n);

        // 誤差
        final double calculationError = Math.abs(Math.PI - piApprox);
        // 計測終了時間
        Instant endTime = Instant.now();
        // 計算時間
        Duration elapsed = Duration.between(startTime, endTime);

        System.out.println("円周率近似値  : " + piApprox);
        System.out.println("計算誤差      : " + calculationError);
        System.out.println("経過時間[msec]: " + elapsed.toMillis());
    }
}

docker run --rm -v "$PWD":/usr/src/leibniz -w /usr/src/leibniz openjdk javac Leibniz.java

using System;

class Program
{
    // ライプニッツ公式計算
    static double CalculateLeibnizFormula(int terms)
    {
        double piApprox = 0.0;
        double sign = 1.0;
        for (int i = 0; i < terms; i++)
        {
            piApprox += sign / (2.0 * i + 1.0);
            sign = -sign;
        }
        piApprox *= 4.0;
        return piApprox;
    }

    static void Main()
    {
        // 計算する項数(1億回)
        const int n = 100000000;
        //計測開始
        var sw = new System.Diagnostics.Stopwatch();
        sw.Start();

        // ライプニッツ公式計算
        double piApprox = CalculateLeibnizFormula(n);

        // 誤差
        double calculationError = Math.PI - piApprox;
        // 計測停止
        sw.Stop();

        Console.WriteLine("円周率近似値  : {0}", piApprox);
        Console.WriteLine("計算誤差{0}   : {0}", calculationError);
        Console.WriteLine("経過時間[msec]: {0}", sw.ElapsedMilliseconds);
    }
}

docker run --rm -v "$PWD":/usr/src/leibniz -w /usr/src/leibniz mono mcs leibniz.cs
./leibniz.exe

import math
import time

# ライプニッツ公式計算
def calculate_leibniz_formula(n):
    pi_approx = 0
    sign = 1
    for i in range(n):
        pi_approx += sign / (2 * i + 1)
        sign = -sign
    pi_approx *= 4
    return pi_approx


# 計算する項数(1億回)
n = 100000000
# 計測開始時間
start_time = time.monotonic()

# ライプニッツ公式計算
pi_approx = calculate_leibniz_formula(n)

# 誤差
calculation_error = math.pi - pi_approx
# 計測終了時間
end_time = time.monotonic()
# 計算時間
elapsed_millisec = (end_time - start_time) * 1000

print("円周率近似値  : ", pi_approx)
print("計算誤差      : ", calculation_error)
print("経過時間[msec]: ", elapsed_millisec)

docker run -it --rm --name python-leibniz -v "$PWD":/usr/src/leibniz -w /usr/src/leibniz python python leibniz.py

// ライプニッツ公式計算
const calculateLeibnizFormula = (n) => {
    let piApprox = 0;
    let sign = 1;
    for (let i = 0; i < n; i++) {
        piApprox += sign / (2 * i + 1);
        sign = -sign;
    }
    piApprox *= 4;
    return piApprox;
}

// 計算する項数(1億)
const n = 100000000;
// 計測開始時間
startTime = Date.now();

// ライプニッツ公式計算
piApprox = calculateLeibnizFormula(n);

// 誤差
calculationError = Math.abs(Math.PI - piApprox);
// 計測終了時間
endTime = Date.now();
// 計算時間
elapsedMillisec = (endTime - startTime);

console.log(`円周率近似値  : ${piApprox}`);
console.log(`計算誤差      : ${calculationError}`);
console.log(`経過時間[msec]: ${elapsedMillisec}`);

docker run -it --rm --name js-leibniz -v "$PWD":/usr/src/leibniz -w /usr/src/leibniz node node leibniz.js

<?php
// ライプニッツ公式計算
function calculateLeibnizFormula($n) {
    $pi_approx = 0.0;
    $sign = 1.0;
    for ($i = 0; $i < $n; $i++) {
        $pi_approx += $sign / (2 * $i + 1);
        $sign = -$sign;
    }
    return 4 * $pi_approx;
}

// 計算する項数(1億回)
$n = 100000000;
// 計測開始時間
$startTime = microtime(true);

// ライプニッツ公式計算
$piApprox = calculateLeibnizFormula($n);

// 誤差
$calculationError = pi()-$piApprox;
// 計測終了時間
$endTime = microtime(true);
// 計算時間
$elapsedMillsec = ($endTime - $startTime);

echo "円周率近似値  : {$piApprox}";
echo "計算誤差      : {$calculationError}";
echo "経過時間[msec]: {$elapsedMillsec}";
?>

docker run -it --rm --name php-leibniz -v "$PWD":/usr/src/leibniz -w /usr/src/leibniz php php leibniz.php

def calculate_leibniz_formula(n)
  pi_approx = 0.0
  sign = 1.0
  for i in 0...n
    pi_approx += sign / (2.0 * i + 1)
    sign = -sign
  end
  4 * pi_approx
end
  
require 'benchmark'

# 計算する項数(1億回)
n = 100000000

# 計測開始
pi_approx = 0
elapsed_sec = Benchmark.realtime do
  # ライプニッツ公式計算
  pi_approx = calculate_leibniz_formula(n)
end

# 誤差
calculation_error = Math::PI - pi_approx
# 計算時間
elapsed_millisec = elapsed_sec * 1000

puts "円周率近似値  : #{pi_approx}"
puts "計算誤差      : #{calculation_error}"
puts "経過時間[msec]: #{elapsed_millisec}"

docker run -it --rm --name ruby-leibniz -v "$PWD":/usr/src/leibniz -w /usr/src/leibniz ruby ruby leibniz.rb

import Foundation

func calculateLeibnizFormula(n: Int) -> Double {
    var piApprox = 0.0
    var sign = 1.0
    for i in 0..<n {
        piApprox += sign / (Double(i) * 2.0 + 1.0)
        sign = -sign
    }
    return piApprox * 4.0
}

// 計算する項数(1億回)
let n = 100000000
// 計測開始時間
let startTime = Date()

// ライプニッツ公式計算
let piApprox = calculateLeibnizFormula(n: n)

// 誤差
let calculationError = Double.pi - piApprox
// 計算時間
let elapsedMillisec = Date().timeIntervalSince(startTime) * 1000


print("円周率近似値  : \(piApprox)");
print("計算誤差      : \(calculationError)");
print("経過時間[msec]: \(elapsedMillisec)");

docker run --rm -v "$PWD":/usr/src/leibniz -w /usr/src/leibniz swift swift -O leibniz.swift

// ライプニッツ公式計算
fun calculateLeibnizFormula(n: Int): Double {
    var piApprox = 0.0
    var sign = 1.0
    for (i in 0 until n) {
        piApprox += sign / (i * 2 + 1)
        sign = -sign
    }
    return piApprox * 4
}

fun main(args: Array<String>) {
    // 計算する項数(1億回)
    val n = 100000000;
    // 計測開始時間
    val startTime = System.currentTimeMillis()

    // ライプニッツ公式計算
    val piApprox = calculateLeibnizFormula(n)

    // 誤差
    val calculationError = Math.abs(Math.PI - piApprox)
    // 計測終了時間
    val endTime = System.currentTimeMillis()
    // 計算時間
    val elapsedMillisec = endTime - startTime

    println("円周率近似値  : $piApprox");
    println("計算誤差      : $calculationError");
    println("経過時間[msec]: $elapsedMillisec");
}

docker run --rm -v "$PWD":/usr/src/leibniz -w /usr/src/leibniz zenika/kotlin kotlinc leibniz.kt -include-runtime -d leibniz.jar
docker run --rm -v "$PWD":/usr/src/leibniz -w /usr/src/leibniz zenika/kotlin kotlin leibniz.jar

package main

import (
    "fmt"
    "math"
    "time"
)

// ライプニッツ公式計算
func calculateLeibnizFormula(n int) float64 {
    piApprox := 0.0
    sign := 1.0
    for i:= 0; i < n; i++ {
        piApprox += sign / (2.0*float64(i) + 1.0)
        sign = -sign;
    }
    piApprox *= 4.0
    return piApprox
}

func main() {
    // 計算する項数(1億)
    n := 100000000
    // 計測開始時間
    startTime := time.Now()

    // ライプニッツ公式計算
    piApprox := calculateLeibnizFormula(n)

    // 誤差
    calculationError := math.Pi - piApprox
    // 計測終了時間
    endTime := time.Now()
    // 計算時間
    elapsed := endTime.Sub(startTime)

    fmt.Printf("円周率近似値  : %v\n", piApprox)
    fmt.Printf("計算誤差      : %v\n", calculationError)
    fmt.Printf("経過時間[msec]: %v\n", elapsed.Milliseconds())
}

docker run --rm -v "$PWD":/usr/src/leibniz -w /usr/src/leibniz golang go run leibniz.go

use std::time::Instant;

// ライプニッツ公式計算
fn calculate_leibniz_formula(n : i32) -> f64 {
    let mut pi_approx: f64 = 0.0;
    let mut sign: f64 = 1.0;
    for i in 0..n {
        pi_approx += sign / (2.0 * i as f64 + 1.0);
        sign = -sign;
    }
    pi_approx * 4.0
}

fn main() {
    // 計算する項数
    let n = 100000000;
    // 計測開始時間
    let start_time = Instant::now();

    // ライプニッツ公式計算
    let pi_approx = calculate_leibniz_formula(n);

    // 誤差
    let calculation_error = std::f64::consts::PI - pi_approx;

    // 計算時間を計測
    let end_time = Instant::now();
    let elapsed = end_time.duration_since(start_time);

    // 結果を表示
    println!("円周率近似値  : {}", pi_approx);
    println!("計算誤差      : {}", calculation_error);
    println!("経過時間[msec]: {}", elapsed.as_millis());
}

docker run --rm -v "$PWD":/usr/src/leibniz -w /usr/src/leibniz rust cargo run --release