5 : 25 JavaScriptで巨大整数演算

function bset( canon ) {
    var Work = new Array();
    var size = Math.ceil( canon.length / 5 );

    // 最大要素の桁数
    var len0 = canon.length % 5;
    if(len0==0) len0=5;

    // とりあえず降順に格納。先頭には0がないので必ず十進法で評価される
    Work[0] = eval( canon.substr( 0, len0 ) );

    var pos = len0;
    var tmp;

    for( var i=1; i<size; i++ ) {
        tmp = canon.substr( pos , 5 );
        pos += 5;

        // 数値に変換。必ず十進法で評価されるよう0を消す
        Work[i] = eval( "1" + tmp ) - BIG_UNIT;
    }
    // 昇順にする
    return my_reverse( Work );
}

function badd( B1, B2 ) {
    var sign1 = bsign(B1), sign2 = bsign(B2);
    var ret_sign;

    // 結果の正負の判定
    if( sign1 * sign2 <0 ) {
        var abscmp = babscmp( B1, B2 );
        if( abscmp > 0 ) ret_sign = sign1;
        else if( abscmp < 0 ) ret_sign = sign2;
        else ret_sign = 1; // 符号だけ異なって絶対値が同じ、和はゼロ

    } else if( sign1 >= 0 ) {
        ret_sign = 1; // 正の数同士の足し算
    } else {
        ret_sign = -1; // 負の数同士の足し算
    }

    var sum = new Array();

    var max = Math.max( B1.length, B2.length );

    for( var i=0; i < max; i++ ) {
        sum[i] = 0;
        if( B1[i] ) sum[i] += B1[i];
        if( B2[i] ) sum[i] += B2[i];
    }

    // くりあがり等
    for( var i=0; i<sum.length; i++ ) {
        if( ret_sign >= 0 ) { // 結果は非負
            while( sum[i] >= BIG_UNIT ) {
                sum[i]-=BIG_UNIT;
                if(typeof sum[i+1] == "number" ) sum[i+1]++;
                else sum[i+1] = 1;
            }
            while( sum[i] < 0 ) { sum[i]+=BIG_UNIT; sum[i+1]--; }
        } else { // 結果は負
            while( sum[i] > 0 ) { sum[i]-=BIG_UNIT; sum[i+1]++; }
            while( sum[i] <= - BIG_UNIT ) {
                sum[i]+=BIG_UNIT;
                if(typeof sum[i+1] == "number" ) sum[i+1]--;
                else sum[i+1] = -1;
            }
        }
    }

    return bset( bshow( sum ) );
}

function bsub( B1, B2 ) {
    return ( badd( B1, bneg(B2) ) );
}

function bmul( B1, B2 ) {
    var zeros, _mul;
    var Work = bset("0");

    for( var idx1=0; idx1 < B1.length; idx1++ ) {
        for( var idx2=0; idx2 <B2.length; idx2++ ) {
            zeros = getZeros( ( idx1 + idx2 )*5 );
            _mul = ( B1[idx1] * B2[idx2] ).toString(10) + zeros;
            Work = badd( Work, bset(_mul) );
        }
    }
    return Work;
}

function getZeros( how_many ) {

    var _z = how_many % 10;
    var _z10 = (how_many - _z) / 10;

    var ret = "";

    for( var i = 0; i < _z10; i++ ) ret += "0000000000";
    for( var i = 0; i < _z; i++ ) ret += "0";

    return ret;
}

// PはBigInt形式でも通常の自然数でもかまわない。
function bpow( B, P ) {
    var power;
    if( typeof P == "number" ) power = P;
    else if( typeof P == "object") power = b2float(P);
    else return null;

    if( power != Math.floor(power) || power > 2048 || power < 0 ) {
        _debug("[ERROR] inadequate power at function bpow(): power=" + power );
        return null
    }

    // 3乗までは直接計算する
    if( power == 0 ) {
        if( babscmp( B, [0] ) == 0 ) return [ 0 ];
        else return [1];
    } else if( power == 1 ) return B;
    else if( power == 2 ) return bmul( B, B );
    else if( power == 3 ) return bmul( bmul( B, B ), B );

    // powerを2進展開する
    var bin_str = power.toString(2);
    var max = bin_str.length - 1;
    var bin_digit = new Array();
    for( var i=0; i<=max ; i++ ) {
        bin_digit[i] = bin_str.charAt( max - i );
    }

    // Bの2^n乗を計算する
    var _B = new Array(); // 配列の配列
    _B[0] = B; // 最初の要素はB自身
    for( var n = 1; n <= max; n++ ) {
        _B[n] = bmul( _B[ n-1 ] , _B[ n-1 ] );
    }

    var Ret = [1];
    for( var i = 0; i < bin_digit.length; i++ ) {
        if( bin_digit[i] == 1 ) Ret = bmul( Ret, _B[i] );
    }

    return Ret;
}

function bdivmod( B1, B2 ) {

    var sign2 = bsign( B2 );

    // 第0近似
    var _Q = _b2fdiv2b( B1, B2 );

    var _R = new Array();

    var step;

    for( step=1; step<100; step++ ) {

        // 剰余を求める
        _R = bsub( B1, bmul( B2, _Q ) );

        // 剰余が非負で割る数B2より絶対値が小さければ計算終了
        if( bsign( _R ) >=0 && babscmp( _R, B2 ) < 0 ) return [ _Q, _R ];

        // しからざれば ...
        if( sign2 >= 0 || step%2==0 ) {
            // 残差をB2で割った商を足して_Qを補正
            _Q = badd( _Q, _b2fdiv2b( _R, B2 ) );
        } else {
            // 負数で割る場合、商+1も試さねばならない
            _Q = badd( _Q , [1] );
        }
    }
    _debug("[Error] Too many steps at function bdivmod: _R=" + bshow(_R));
    return null;
}

function _b2fdiv2b( B1, B2 ) {
    return bset(   Math.floor( b2float(B1)/b2float(B2) ).toString()   );
}

    var part = str.match(/^(\-?)(\d+)\.(\d+)e([\+|\-]\d+)/i);
    if(part) {
        var power = eval( part[4] );
        if( power < 0 ) return "0";

        // part[3] の右端に必要なだけ文字0をつなげる
        // もしpart[3]がe10をかけても小数部分があるなら、小数部分は捨てる
        var c;
        var ret = "";
        for( var i=0; i < power; i++ ) {
            c = part[3].charAt(i) || "0" ;
            ret += c;
        }

        ret = part[2].toString() + ret;
        // マイナス符号
        if( part[1] ) ret = part[1] + ret;

        return ret;
    }

function bdiv( B1, B2 ) {
    var result = bdivmod( B1, B2 );
    return result[0];
}

function bmod( B1, B2 ) {
    var result = bdivmod( B1, B2 );
    return result[1];
}

var A=bset("2"), B=bset("59"), C=bset("1");
var N = bsub( bpow( A, B ), C );
var I;

document.write("<p>Checking whether it is divisible by:<br>");
for(var i=100001; i<200000; i+=2 ) {
    if(i%1000==1) document.write( "" + (i-1) + " ...<br>");

    if(i%3==0||i%5==0||i%7==0||i%11==0||i%13==0||i%17==0||i%19==0||
    i%23==0||i%29==0||i%31==0||i%37==0||i%41==0||i%43==0||i%47==0||
    i%53==0||i%59==0||i%61==0||i%67==0||i%71==0||i%73==0||i%79==0||
    i%83==0||i%89==0||i%93==0||i%97==0||i%101==0||i%103==0||i%107==0||
    i%109==0||i%113==0||i%127==0||i%131==0||i%137==0||i%139==0||i%149==0)continue;

    var I = bset( i.toString() );

    if( bmod( N, I ) == 0 ) {
        document.write( " <strong>" + i + "</strong> found!</p>" );
        break;
    }
}

// BのP乗をmodで割ったときの余りを求める
// P, mod はBigInt形式でも数値でもかまわない。
function bpowmod( B, P, mod ) {
    if( !isBigInt(B) ) return null;

    var power;
    if( typeof P == "number" ) power = P;
    else if( typeof P == "object") power = b2float(P);
    else return null;

    if( power != Math.floor(power) || power < 0 ) {
        _debug("[ERROR] inadequate power at function bpowmod(): power=" + power );
        return null
    } else if( power > Math.pow(2, 52) ) {
        _debug("[NOT IMPLEMENTED YET] a big power at function bpowmod(): power=" + power );
        return null
    }

    var M = new Array();
    if( typeof mod == "number" ) M = bset( mod.toString(10) );
    else if( isBigInt( mod ) ) M = bcopy( mod );
    else return null;

    var fmod = b2float(M);
    // modは2以上でなければならない
    if( fmod <= 1 ) {
        _debug("[ERROR] inadequate mod at function bpowmod(): mod=" + bshow(M) );
        return null
    }

    // 0乗と1乗は直接計算
    if( power == 0 ) {
        if( babscmp( B, [0] ) == 0 ) return [ 0 ];
        else return [1];
    } else if( power == 1 ) return bmod( B, M );

    // powerを2進展開する
    var bin_str = power.toString(2);
    var max = bin_str.length - 1;
    var bin_digit = new Array();
    for( var i=0; i<=max ; i++ ) {
        bin_digit[i] = bin_str.charAt( max - i );
    }

    // Bの2^n乗をMで割った剰余計算する
    var _B = new Array(); // 配列の配列
    _B[0] = bmod( B, M );
    for( var n = 1; n <= max; n++ ) {
        _B[n] = bmod( bmul( _B[ n-1 ] , _B[ n-1 ] ) , M );
    }

    var Ret = [1];
    for( var i = 0; i < bin_digit.length; i++ ) {
        if( bin_digit[i] == 1 ) Ret = bmod( bmul( Ret, _B[i] ), M );
    }

    return Ret;
}

document.write( Math.pow( 7, 20 ) ); //  79792266297612000
document.write( Math.bpow( 7, 20 ) ); // 79792266297612001