[hgseib]

obwohl,

das ist nicht ganz das, was ich meine.
mit 'Square and Multiply' kann man das schneller berechnen, aber das problem 'zahlen mit mehr als 15 signifikante ziffern haben zu müssen' bleibt.

ich dachte mehr an sowas:

/*
trace(10%91);
trace(100%91);
trace(1000%91);
trace(10000%91);
trace(100000%91);
trace(1000000%91);
//
trace(10000000%91);
trace(100000000%91);
trace(1000000000%91);
trace(10000000000%91);
trace(100000000000%91);
trace(1000000000000%91);
////
10
9
90
81
82
1
10
9
90
81
82
1
*/
function moduloSerien(a,b) {
	trace("moduloSerie: "+a+"%"+b);
	var c=a;
	var i=0;
	do {
		trace(i+": "+(c%b));
		i++;
		c*=a;
	} while (c<99999999999999);
	trace(c);
}
moduloSerien(26,7);

in der potenzentwicklung gibt modulo eine sich wiederholende reihe aus. wenn man so eine reihe kennt, dann kann man das modulo jeder x-beliebigen (natürlichen) hochzahl sagen, ohne das wirklich ausrechnen zu müssen. das wärs gewesen ;-)
das problem ist jetzt: wie kommt man am elegantesten zu der jeweiligen reihe und vermutlich gibt es reihen mit extrem vielen werten bis es (wenn überhaupt) zu einer wiederholung kommt?

dann wäre noch diese überlegung möglich:
wie kann man den wert teilen, ohne die potenzen selbst ausrechnen zu müssen, um einen restbetrag zu erhalten (mit weniger als 15 ziffern) von dem auch flash das modulo berechnen kann
so in die richtung etwa:
10000%3 == 10000/3 rest X
(9999/3 + 1/3) == rest 0 + rest 1
vermutlich mit ständig wechselndem multiplizieren und teilen (damit es zu keiner übergrossen zahl kommt) und die berechnungen als bruch behandeln.