[11 languages] Considering the “Processing Speed” of Programming Languages

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


// Calculate using the Leibniz formula
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() {
    // Number of terms to compute (100 million iterations)
    const int n = 100000000;

    const auto start_time = std::chrono::high_resolution_clock::now();

    // Compute using the Leibniz formula
    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 << "Approximation of Pi : " << pi_approx << std::endl;
    std::cout << "Calculation Error   : " << calculation_error << std::endl;
    std::cout << "Elapsed Time [msec] : " << elapsed_millisec << std::endl;

    return 0;
}

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

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

public class Leibniz {

    // Calculate using the Leibniz formula
    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) {
        // Number of terms to compute (100 million iterations)
        final int n = 100000000;

        Instant startTime = Instant.now();

        // Compute using the Leibniz formula
        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("Approximation of Pi : " + piApprox);
        System.out.println("Calculation Error   : " + calculationError);
        System.out.println("Elapsed Time [msec] : " + elapsed.toMillis());
    }
}

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

using System;

class Program
{
    // Calculate using the Leibniz formula
    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()
    {
        // Number of terms to compute (100 million iterations)
        const int n = 100000000;

        var sw = new System.Diagnostics.Stopwatch();
        sw.Start();

        // Compute using the Leibniz formula
        double piApprox = CalculateLeibnizFormula(n);

        double calculationError = Math.PI - piApprox;
        sw.Stop();

        Console.WriteLine("Approximation of Pi : {0}", piApprox);
        Console.WriteLine("Calculation Error   : {0}", calculationError);
        Console.WriteLine("Elapsed Time [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

# Calculate using the Leibniz formula
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


# Number of terms to compute (100 million iterations)
n = 100000000

start_time = time.monotonic()

# Compute using the Leibniz formula
pi_approx = calculate_leibniz_formula(n)

calculation_error = math.pi - pi_approx
end_time = time.monotonic()
elapsed_millisec = (end_time - start_time) * 1000

print("Approximation of Pi : ", pi_approx)
print("Calculation Error   : ", calculation_error)
print("Elapsed Time [msec] : ", elapsed_millisec)

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

// Calculate using the Leibniz formula
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;
}

// Number of terms to compute (100 million iterations)
const n = 100000000;

startTime = Date.now();

// Compute using the Leibniz formula
piApprox = calculateLeibnizFormula(n);

calculationError = Math.abs(Math.PI - piApprox);
endTime = Date.now();
elapsedMillisec = (endTime - startTime);

console.log(`Approximation of Pi : ${piApprox}`);
console.log(`Calculation Error   : ${calculationError}`);
console.log(`Elapsed Time [msec] : ${elapsedMillisec}`);

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

<?php
// Calculate using the Leibniz formula
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;
}

// Number of terms to compute (100 million iterations)
$n = 100000000;

$startTime = microtime(true);

// Compute using the Leibniz formula
$piApprox = calculateLeibnizFormula($n);

$calculationError = pi()-$piApprox;
$endTime = microtime(true);
$elapsedMillsec = ($endTime - $startTime);

echo "Approximation of Pi : {$piApprox}";
echo "Calculation Error   : {$calculationError}";
echo "Elapsed Time [msec] : {$elapsedMillsec}";
?>

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

# Calculate using the Leibniz formula
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'

# Number of terms to compute (100 million iterations)
n = 100000000

pi_approx = 0
elapsed_sec = Benchmark.realtime do
  # Compute using the Leibniz formula
  pi_approx = calculate_leibniz_formula(n)
end

calculation_error = Math::PI - pi_approx
elapsed_millisec = elapsed_sec * 1000

puts "Approximation of Pi : #{pi_approx}"
puts "Calculation Error   : #{calculation_error}"
puts "Elapsed Time [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

// Calculate using the Leibniz formula
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
}

// Number of terms to compute (100 million iterations)
let n = 100000000

let startTime = Date()

// Compute using the Leibniz formula
let piApprox = calculateLeibnizFormula(n: n)

let calculationError = Double.pi - piApprox
let elapsedMillisec = Date().timeIntervalSince(startTime) * 1000

print("Approximation of Pi : \(piApprox)");
print("Calculation Error   : \(calculationError)");
print("Elapsed Time [msec] : \(elapsedMillisec)");

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

// Calculate using the Leibniz formula
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>) {
    // Number of terms to compute (100 million iterations)
    val n = 100000000;

    val startTime = System.currentTimeMillis()

    // Compute using the Leibniz formula
    val piApprox = calculateLeibnizFormula(n)

    val calculationError = Math.abs(Math.PI - piApprox)
    val endTime = System.currentTimeMillis()
    val elapsedMillisec = endTime - startTime

    println("Approximation of Pi : $piApprox");
    println("Calculation Error   : $calculationError");
    println("Elapsed Time [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"
)

// Calculate using the Leibniz formula
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() {
    // Number of terms to compute (100 million iterations)
    n := 100000000

    startTime := time.Now()

    // Compute using the Leibniz formula
    piApprox := calculateLeibnizFormula(n)

    calculationError := math.Pi - piApprox
    endTime := time.Now()
    elapsed := endTime.Sub(startTime)

    fmt.Printf("Approximation of Pi : %v\n", piApprox)
    fmt.Printf("Calculation Error   : %v\n", calculationError)
    fmt.Printf("Elapsed Time [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;

// Calculate using the Leibniz formula
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() {
    // Number of terms to compute (100 million iterations)
    let n = 100000000;

    let start_time = Instant::now();

    // Compute using the Leibniz formula
    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!("Approximation of Pi : {}", pi_approx);
    println!("Calculation Error   : {}", calculation_error);
    println!("Elapsed Time [msec] : {}", elapsed.as_millis());
}

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