Cherche module de calcul JavaScript [Résolu]

[danielhagnoul]

Bonjour

Pour une page web, projet d'étudiant non accessible sur l'internet, incluant des calculs astronomiques réalisés à la demande de l'utilisateur nous aurions eu besoin de 15 décimales exactes pendant tous les calculs. Je ne parle pas de la présentation des résultats, mais bien de la précision des calculs.

Pour la présentation des résultats, j'ai simplement utilisé nombre.toFixed(13) ce qui donne un nombre non ridicule (style 0.06 + 0.01 = 6.9999..) dans la très grande majorité des cas.

La plupart des langages informatiques disposent d'un module mathématique, j'ai conseillé à l'étudiant de réaliser une seconde version en utilisant Python, mais je n'ai rien trouvé pour le JS sur Internet.

Comme on trouve tout sur le web, j'ai peut-être mal cherché ?

[Loceka]

Y'a un début de réponse sur ce post http://www.developpez.net/forums/d10...ecart-centime/

Sinon y'a probablement quelque chose de plus abouti mais si c'est le cas je ne le connais pas.

[SpaceFrog]

y'a bien une ou deux libs qui trainent, mais je ne sais pas ce qu'elles valent.

En voici la plus connue
http://jsfromhell.com/classes/bignumber

[danielhagnoul]

Bonsoir

Je suis vraiment passé à côté et n'a pas été mon ami. Je devrais peut-être utiliser plus souvent mon copain "bing".

JSFromHell.com, en dehors de BigNumber, le site semble contenir d'autres perles.

J'ai également, en cherchant cette fois avec "js big number", trouvé RSA and ECC in JavaScript

Il me reste beaucoup de travail pour lire, comprendre, tester et comparer avant d'appliquer le meilleur.

@SpaceFrog

[danielhagnoul]

Bonsoir

Malheureusement, BigNumber échoue pour la division (divide) et pour les fonctions qui utilise la division : pow, mod.

60/0.06 = 1000.0114 !!!

60/0.03 = 200.0327 !!!

Pour l'instant, seul BigDecimal passe mes tests !

[Willpower]

parfait! tu vas avoir l'honneur d'être le tout premier testeur de ma lib :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
// constructeur d'instance(Number|num|null) : this(typeof num)
function num_constructor(v){
	if(!v) return this.val=""+(this.neg=this.pos=0),this; // 0
	this.neg = (v = v.toExpString()).charAt(0) == '-';
	this.val = ((v = v.replace(/[^\d.]/g,'').split('.', 2))[0] = v[0].replace(/^0+/,'') || '0') + (v[1] = v[1] || '',v[1].replace(/0+$/,''));
	this.pos = v[1].length;
	delete v
} 
// constructeur(Number|num|null) : new num
function num(v){
	return v instanceof num_constructor?((this instanceof num_constructor)?v.copy():v):new num_constructor(v)
}
// num:prototype
p = num_constructor.prototype = num.prototype;
// "0000000000...00000000000" (^310)
num.MAX_ZERO=(function(max){
	for(var i=1,zero='0';i<max;i*=2)
		zero+=zero;
	return zero.substring(0,max-1)
})(Number(Number.MAX_VALUE.toString().split('e')[1]));
// copy : new num
p.copy = function(){
	var v = new num_constructor();
	v.neg = this.neg;
	v.val = this.val;
	v.pos = this.pos;
	return v
};
// partie entière : String
p.left = function(){
	return this.val.substring(0,this.val.length-this.pos)
};
// partie décimale : String
p.right = function(){
	return this.val.substring(this.val.length-this.pos,this.val.length)
};
// valeur complete : String
p.valueOf = p.toString = function(){
	return (this.neg?'-':'')+this.left()+"."+this.right()
};
// valeur complete : Number
p.Number = function(){
	return Number(this.valueOf())
};
// puissance du nombre : Number
p.power = function(){
	return this.val.replace(/^0+/,'').length-this.pos-1
};
// (this<v)=[-1] (this==v)=[0] (this>v)=[1]
p.compare = function(v){
	return (this.neg != (v=num(v)).neg)?(this.neg?-1:1):(this.neg?(-this.compareAbs(v)):this.compareAbs(v))
};
// (abs(this)<abs(v))=[-1] etc...
p.compareAbs = function(v){
	var a=this,b=num(v);
       if(a.power() != b.power())  
		return ((a.power()>b.power()))?1:-1;
	var l=Math.min((a=a.val.split('')).length,(b=b.val.split('')).length),i=-1;
	while(++i<l)
           if(a[i] != b[i]) 
			return (a[i]>b[i])?1:-1;
	return 0;
}
// renvoie une copie "positive" : new num
p.abs = function(){
	var r=this.copy();
	return r.neg=0,r
};
// supprime les "0" de trop en début et en fin du num : num;
p.clean = function(){
	var a=[];
	a[0]=this.val.substr(0,this.val.length-this.pos).replace(/^0+/,'') || '0';
	a[1]=this.val.substr(this.val.length-this.pos,this.val.length)||'';
	a[1]=a[1].replace(/0+$/,'')
	return this.pos=a[1].length,this.val=a.join(''),this;
};
// ajoute v au num : new num
p.add = function(v){
	var a=this, b=num(v), res=new num_constructor();
	res.neg=(a.compareAbs(b)==1?a.neg:b.neg);
	res.pos=Math.max(a.pos+b.pos);
	res.val=num.MAX_ZERO+Math.abs(
		parseInt((a.neg?'-':'')+a.val+num.MAX_ZERO.substr(0,res.pos-a.pos),10)
		+parseInt((b.neg?'-':'')+b.val+num.MAX_ZERO.substr(0,res.pos-b.pos),10)
	);
	return res.clean();
};
// converti un Number en notation (n.e^x) vers la notation classique : String
Number.prototype.toExpString = function(){
	var val=this+'',t;
	if(!val.match(/^([+-]?\d+(?:.\d+)?)e([-\+]?\d+)$/)) return val;
	if(RegExp.$2<0) return ((val<0)?'-':'')+"0."+num.MAX_ZERO.substring(0,-RegExp.$2-1)+Math.abs(RegExp.$1.replace(".", ""));
	return RegExp.$1.replace(".", "")+num.MAX_ZERO.substring(0,Number(RegExp.$2)-((t=RegExp.$1.split('.')[1])?t.length:0));
} 
// supprime v au num : new num
p.sub = function(b){var r=num(b).copy();return r.neg=1-r.neg,this.add(r);}
// multiplie le num par v : new num
p.multi = function(b){ 
	var a=this, b=num(b), res=new num_constructor();
	res.neg=(a.neg^b.neg);
	res.pos=a.pos+b.pos;
	res.val=(num.MAX_ZERO+(parseInt(a.val,10)*parseInt(b.val,10)).toExpString()).replace('.','');
	return res.clean();
}
// divise le num par v : new num
p.div = function(b){
	var c,a=this, b=num(b), res=new num_constructor();
	res.neg=(a.neg^b.neg);
	res.val=num.MAX_ZERO+(parseInt(a.val,10)/parseInt(b.val,10)).toExpString()+num.MAX_ZERO;
	res.pos=((c=res.val.split('.')[1])?c.length:num.MAX_ZERO.length)-b.pos+a.pos;
	res.val=res.val.replace('.','');
	return res.clean();
}

exemple d'utilisation :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
//== CONSTRUCTEURS ==
// constructeur
var e1 = num(-123.456); // num(Number) -> new num
// cast
e1 = num(e1); // num(num) -> new num[if (typeof e1==Number)] || num[e1]
// copy
var e2 = new num(e1); // new num(num) -> e1.copy() -> new num
// == OPERATIONS ==
// add
var e3 = e1.add(e2); // num.add(Number) || num.add(num) -> new num
// sub
var e4 = e1.sub(e2); // num.sub(Number) || num.sub(num) -> new num
// multi
var e5 = e1.multi(e2); // num.multi(Number) || num.multi(num) -> new num
// div
var e6 = e1.div(e2); // num.div(Number) || num.div(num) -> new num
// abs
var e7 = e1.abs(); // -> new num
 
// == TESTS ==
// comparateur
var e8 = e1.compare(e2); // num.compare(Number) || num.compare(num) -> -1,0,1
 
// == RECUPERATIONS DES VALEURS ==
// valeur sous forme de String
var e9 = e1.toString(); // -> String
var e10 = e1.valueOf(); // -> String
// valeur sous forme de Number
var e11 = e1.Number(); // -> Number
 
for(i=1;i<12;i++)
	document.write(i+') ',window['e'+i],'<br/>');

ps:
- inconvénient : elle ne gère pas encore les "bigNumber" (actuellement limité à 16 chiffres devant ou à 16 chiffres derrière la virgule). (ce sera pour la prochaine version.. pas grand chose à rajouter).

- inconvénient : elle comporte sans doute énormément d'erreurs ! c'est pour ça que j'ai besoin de toi pour la tester.

- avantage : elle corrige les erreurs de opérations flottantes ! et ceci avec une rapidité non négligeable puisque ne comporte aucune boucle (sauf pour la méthode "compare" ... déjà prévue pour les bigNumber et à l'initialisation de lib pour générer un grand string plein de "0").

- avantage : le code fait moins de 4ko contre 200ko pour BigDecimal.



edit: tiens pour une fois mon code est même (presque) lisible !


nb: ce code ne fait rien d'autre que transformer les float en int via des string pour appliquer les opérations sur des entiers et ensuite replacer la virgule(et le signe) au bon endroit.

exemple :

Code :

1
2
3
document.write("20 chiffres de chaque coté: "+num(100000000000000000000).multi(0.00000000000000000001),'<br/>');
document.write("res avec lib: "+num(100000000000).multi(0.00000000001),'<br/>');
document.write("res sans lib: "+100000000000*0.00000000001,'<br/>');

version online de ma lib si tu veux tester certaines opérations en particulier : http://willpower.110mb.com/sources/numeric.htm



nb: n'hésitez pas à rafraîchir la page pour voir différentes valeurs par défauts prouver l'efficacité du brol.


edit: j'ai rajouté une iframe avec une recherche google de l'équation pour comparer avec une résultat (je crois) fiable !

Tiens dans ma lib j'ai des "uncaught illegal access" sur des RegExp.rightContext ... avec des Chaine.match(/[\*\/\+\-]/g) sur mes opérations ... des opérations qui ont toujours qqe chose à droite des opérateurs (quand je fais des alert(Chaine) ). donc je ne comprend pas pourquoi ça plante. -> HELP PLEASE.


edit: apparement ce problème n'apparait que sous chrome ... IE et Firefox marchent nickel "chrome" !

ligne de code incriminée :

Code :

1
2
 
if((e.match(/\*/g)) &&(v=[RegExp.leftContext,RegExp.rightContext]))

voila, j'ai résolu ce bug

Code :

1
2
3
4
5
6
 
	// prevent google chrome bug
	// RegExp.rightContext : illegal acces
	"abc".match("b");
	// strange ! no ?
if((e.match(/\*/g)) &&(v=[RegExp.leftContext,RegExp.rightContext]))

maintenant, tout fonctionne nickel chrome : http://willpower.110mb.com/sources/numeric.htm