Ruby / MRI és Rubinius sebesség

$_[0] vs @_[0]

Az előbbi visszaadja a @_ tömb (amelyben az argumentumok adódnak át a függvénynek) 0. elemét skalárként. Az utóbbi pedig egy ún. array slice, azaz egy egy elemű tömb, az eredeti @_ tömb 0. elemével.
Véletlenül működik és ugyanazt az eredményt adja ebben az esetben, de nem ugyanaz a kettő.

Igen, ezzel célszerű tisztában kell lenni. A Python integer osztálya figyel a túlcsordulásra és nagy számokat automatikusan szoftverből elvégzett aritmetikával kezel.

C estén 64 bit, illetve __int128 (64 bites OS-eken) típus áll rendelkezésedre például a 64 bites szorzások eredményének átvételéhez. Ellenben natív proci sebességen adja.
Utána jöhet a gmp vagy boost lib, amely szoftverből számol tovább.

Példakód C-ben (szedd ki a megfelelő // -t a típusválasztáshoz):

#include <stdio.h>

// ---> __fp16 IEEE754:2008 ... ARM-okon megy
//#define TYPE __fp16
//#define TYPE float
//#define TYPE double
//#define TYPE long double
//#define TYPE __float128

// ---> unsigned +1 bit
//#define TYPE byte
//#define TYPE short
//#define TYPE int
//#define TYPE long long
//#define TYPE __int128


int main() {
    TYPE ro, r2, r = 1;
    for (int i = 0; i < 9999; i++) {
        ro = r;
        r *= 2;
        r2 = r+1;
        if (r <= ro || r2 == r) {
            printf("Felbontas: %d bit\n", i+1);
            break;
        }
    }
    return 0;
}

A szkriptnyelvek numerikus értéknek gyakran double-t használnak. Lásd alábbi teszteket:

#!/usr/bin/nodejs

var ro, r2, r = 1;
for (var i = 0; i < 9999; i++) {
    ro = r;
    r *= 2;
    r2 = r+1;
    if (r <= ro || r2 == r) {
        console.log("Felbontas: %d bit\n", i+1);
        break;
    }
}

#!/usr/bin/luajit

local ro = 0
local r2 = 0
local r = 1
for i=0, 9999 do
    ro = r
    r = r*2
    r2 = r+1
    if r <= ro or r2 == r then
        print("Felbontas: ", i+1, "bit");
        break;
    end
end

#!/usr/bin/php
<?php
    $r = 1;
    for ($i = 0; $i < 9999; $i++) {
        $ro = $r;
        $r *= 2;
        $r2 = $r+1;
        if ($r <= $ro || $r2 == $r) {
            printf("Felbontas: %d bit\n", $i+1);
            break;
        }
    }
?>

C: típusfüggő, unsigned __int128 (128 bit) és __float128 (112 bit felbontás) a natív CPU aritmetika felső határa.
NodeJS, LuaJIT: 53 bit (double)
PHP7: 63 bit, de $r2 = $r+1.5; esetén 54 bit.
Python, Ruby: nincs a számábrázolásnak felső határa.

GMP a barátunk. A C-beli (processzorbeli) aritmetika helyett szoftveresen összerakott aritmetikával dolgozik.
Ellenben ezzel a teszttel eljutunk oda, hogy nem az adott nyelven megírt algoritmus futását teszteljük, hanem azt nézzük, mely programnyelv miként használja fel ugyanazt a C-ben megírt libgmp-t.

#include <gmp.h>
#include <time.h>
#include <stdio.h>

mpz_t *f(int n) {
    static mpz_t fibo;
    mpz_t p1, p2;
    mpz_init_set_ui(p1, 1);
    mpz_init(p2);

    for (int i = 1; i < n; i++) {
        mpz_add(fibo, p2, p1);
        mpz_add_ui(p2, p1, 0);
        mpz_add_ui(p1, fibo, 0);
    }
    mpz_clear(p1);
    mpz_clear(p2);
    return &fibo;
}

int main() {
    struct timespec gstart, gend;
    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &gstart);

    mpz_t *res = f(40);

    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &gend);
    mpz_out_str(stdout, 10, res); puts("");
    double eltime = (gend.tv_sec - gstart.tv_sec) + (gend.tv_nsec - gstart.tv_nsec)/1000./1000./1000.;
    printf("ido: %f mp\n", eltime);
    return 0;
}