Convertir un nombre décimal en fraction/nombre rationnel
En JavaScript, existe-t-il un moyen de convertir un nombre décimal (tel que 0.0002) en une fraction représentée par une chaîne (telle que "2/10000")?
Si une fonction appelée decimalToFraction avait été écrite à cette fin, alors decimalToFraction(0.0002) renverrait la chaîne "2/10000".
Vous pouvez utiliser la bibliothèque fraction.js de Erik Garrison pour le faire et plus d'opérations fractionnaires.
var f = new Fraction(2, 10000);
console.log(f.numerator + '/' + f.denominator);
À faire .003 vous pouvez juste faire
var f = new Fraction(.003);
console.log(f.numerator + '/' + f.denominator);
Un peu googler avec le terme "décimal à la fraction js" le premier a donné ceci:
http://wildreason.com/wildreason-blog/2010/javascript-convert-a-ddecimal-into-a-simplified-fraction/
Cela semble fonctionner:
function HCF(u, v) {
var U = u, V = v
while (true) {
if (!(U%=V)) return V
if (!(V%=U)) return U
}
}
//convert a decimal into a fraction
function fraction(decimal){
if(!decimal){
decimal=this;
}
whole = String(decimal).split('.')[0];
decimal = parseFloat("."+String(decimal).split('.')[1]);
num = "1";
for(z=0; z<String(decimal).length-2; z++){
num += "0";
}
decimal = decimal*num;
num = parseInt(num);
for(z=2; z<decimal+1; z++){
if(decimal%z==0 && num%z==0){
decimal = decimal/z;
num = num/z;
z=2;
}
}
//if format of fraction is xx/xxx
if (decimal.toString().length == 2 &&
num.toString().length == 3) {
//reduce by removing trailing 0's
decimal = Math.round(Math.round(decimal)/10);
num = Math.round(Math.round(num)/10);
}
//if format of fraction is xx/xx
else if (decimal.toString().length == 2 &&
num.toString().length == 2) {
decimal = Math.round(decimal/10);
num = Math.round(num/10);
}
//get highest common factor to simplify
var t = HCF(decimal, num);
//return the fraction after simplifying it
return ((whole==0)?"" : whole+" ")+decimal/t+"/"+num/t;
}
// Test it
alert(fraction(0.0002)); // "1/5000"
J'ai utilisé ce site http://mathforum.org/library/drmath/view/51886.html pour créer une fonction, mais comme le mentionne l'article, vous obtiendrez un grand nombre déraisonnable de radicaux ou de pi.
J'espère que ça aide quand même.
function Fraction(){}
Fraction.prototype.convert = function(x, improper)
{
improper = improper || false;
var abs = Math.abs(x);
this.sign = x/abs;
x = abs;
var stack = 0;
this.whole = !improper ? Math.floor(x) : 0;
var fractional = !improper ? x-this.whole : abs;
/*recursive function that transforms the fraction*/
function recurs(x){
stack++;
var intgr = Math.floor(x); //get the integer part of the number
var dec = (x - intgr); //get the decimal part of the number
if(dec < 0.0019 || stack > 20) return [intgr,1]; //return the last integer you divided by
var num = recurs(1/dec); //call the function again with the inverted decimal part
return[intgr*num[0]+num[1],num[0]]
}
var t = recurs(fractional);
this.numerator = t[0];
this.denominator = t[1];
}
Fraction.prototype.toString = function()
{
var l = this.sign.toString().length;
var sign = l === 2 ? '-' : '';
var whole = this.whole !== 0 ? this.sign*this.whole+' ': sign;
return whole+this.numerator+'/'+this.denominator;
}
//var frac = new Fraction()
//frac.convert(2.56, false)
//console.log(frac.toString())
//use frac.convert(2.56,true) to get it as an improper fraction
Très vieille question, mais peut-être que quelqu'un peut trouver cela utile. C'est itératif, pas récursif et ne nécessite pas de factorisation
function getClosestFraction(value, tol) {
var original_value = value;
var iteration = 0;
var denominator=1, last_d = 0, numerator;
while (iteration < 20) {
value = 1 / (value - Math.floor(value))
var _d = denominator;
denominator = Math.floor(denominator * value + last_d);
last_d = _d;
numerator = Math.ceil(original_value * denominator)
if (Math.abs(numerator/denominator - original_value) < tol)
break;
iteration++;
}
return {numerator: numerator, denominator: denominator};
};
Il existe une solution très simple utilisant la représentation sous forme de chaîne de nombres
string = function(f){ // returns string representation of an object or number
return f+"";
}
fPart = function(f){ // returns the fraction part (the part after the '.') of a number
str = string(f);
return str.indexOf(".")<0?"0":str.substring(str.indexOf(".") + 1);
}
wPart = function(f){ // returns the integer part (the part before the '.') of a number
str = string(f);
return str.indexOf(".")<0?str:str.substring(0, str.indexOf(".")); // possibility 1
//return string(f - parseInt(fPart(f))); // just substract the fPart
}
power = function(base, exp){
var tmp = base;
while(exp>1){
base*=tmp;
--exp;
}
return base;
}
getFraction = function(f){ // the function
var denominator = power(10, fPart(f).length), numerator = parseInt(fPart(f)) + parseInt(wPart(f))*denominator;
return "[ " + numerator + ", " + denominator + "]";
}
console.log(getFraction(987.23));
qui va juste vérifier combien de nombres sont dans la fraction et ensuite développer la fraction de f/1 jusqu'à ce que f soit un entier. Cela peut conduire à des fractions énormes, vous pouvez donc le réduire en divisant le numérateur et le dénominateur par le plus grand commun diviseur des deux, par exemple.
// greatest common divisor brute force
gcd = function(x,y){
for(var i = Math.min(x, y);i>0;i--) if(!(x%i||y%i)) return i;
return 1;
}
La bonne nouvelle est que c'est possible, mais vous devrez le convertir en code.
Allons avec 2.56 sans aucune raison.
Utilisez la partie décimale du nombre .56
Il y a 2 chiffres dans 0,56, écrivez 0,56 comme 56/100.
Nous avons donc 2 + 56/100 et nous devons réduire cette fraction au plus bas en divisant à la fois le numérateur et le dénominateur par le le plus grand commun diviseur , qui est 4 dans ce cas.
Donc, cette fraction réduite aux termes les plus bas est 2 + 14/25.
Pour additionner ces 2 entiers, on multiplie par le diviseur et on ajoute au 14
(2 * 25 + 14)/25 = 64/25
Cela peut être un peu vieux mais le code qui a été posté échoue sur 0 valeurs, j'ai corrigé cette erreur et posterai le code mis à jour ci-dessous
//function to get highest common factor of two numbers (a fraction)
function HCF(u, v) {
var U = u, V = v
while (true) {
if (!(U%=V)) return V
if (!(V%=U)) return U
}
}
//convert a decimal into a fraction
function fraction(decimal){
if(!decimal){
decimal=this;
}
whole = String(decimal).split('.')[0];
decimal = parseFloat("."+String(decimal).split('.')[1]);
num = "1";
for(z=0; z<String(decimal).length-2; z++){
num += "0";
}
decimal = decimal*num;
num = parseInt(num);
for(z=2; z<decimal+1; z++){
if(decimal%z==0 && num%z==0){
decimal = decimal/z;
num = num/z;
z=2;
}
}
//if format of fraction is xx/xxx
if (decimal.toString().length == 2 &&
num.toString().length == 3) {
//reduce by removing trailing 0's
// '
decimal = Math.round(Math.round(decimal)/10);
num = Math.round(Math.round(num)/10);
}
//if format of fraction is xx/xx
else if (decimal.toString().length == 2 &&
num.toString().length == 2) {
decimal = Math.round(decimal/10);
num = Math.round(num/10);
}
//get highest common factor to simplify
var t = HCF(decimal, num);
//return the fraction after simplifying it
if(isNaN(whole) === true)
{
whole = "0";
}
if(isNaN(decimal) === true)
{
return ((whole==0)?"0" : whole);
}
else
{
return ((whole==0)?"0 " : whole+" ")+decimal/t+"/"+num/t;
}
}
Je sais que c’est une vieille question, mais j’ai créé une fonction qui a été grandement simplifiée.
Math.fraction=function(x){
return x?+x?x.toString().includes(".")?x.toString().replace(".","")/(function(a,b){return b?arguments.callee(b,a%b):a;})(x.toString().replace(".",""),"1"+"0".repeat(x.toString().split(".")[1].length))+"/"+("1"+"0".repeat(x.toString().split(".")[1].length))/(function(a,b){return b?arguments.callee(b,a%b):a;})(x.toString().replace(".",""),"1"+"0".repeat(x.toString().split(".")[1].length)):x+"/1":NaN:void 0;
}
Appelez-le avec Math.fraction(2.56)
Ce sera:
- renvoyer NaN si l'entrée n'est pas un nombre
- retourne indéfini si l'entrée est indéfinie
- réduire la fraction
- retourne une
string(utilisezMath.fraction(2.56).split("/")pour un tableau contenant le numérateur et le dénominateur)
Veuillez noter que ceci utilise le arguments.callee obsolète et peut donc être incompatible dans certains navigateurs.
Testez-le ici
Avez-vous essayé quelque chose comme ça?
<script type="texrt/javascript>
var cnum = 3.5,deno = 10000,neww;
neww = cnum * deno;
while(!(neww % 2 > 0) && !(deno % 2 > 0)){
neww = neww / 2;
deno = deno / 2;
}
while(!(neww % 3 > 0) && !(deno % 3 > 0)){
neww = neww / 3;
deno = deno / 3;
}
while(!(neww % 5 > 0) && !(deno % 5 > 0)){
neww = neww / 5;
deno = deno / 5;
}
while(!(neww % 7 > 0) && !(deno % 7 > 0)){
neww = neww / 7;
deno = deno / 7;
}
while(!(neww % 11 > 0) && !(deno % 11 > 0)){
neww = neww / 11;
deno = deno / 11;
}
while(!(neww % 13 > 0) && !(deno % 13 > 0)){
neww = neww / 13;
deno = deno / 13;
}
while(!(neww % 17 > 0) && !(deno % 17 > 0)){
neww = neww / 17;
deno = deno / 17;
}
while(!(neww % 19 > 0) && !(deno % 19 > 0)){
neww = neww / 19;
deno = deno / 19;
}
console.log(neww+"/"+deno);
</script>
Je veux juste laisser une alternative que j'ai trouvée pour convertir les nombres décimaux en fractions et fractions réductrices , c'est une bibliothèque JS.
La bibliothèque appelle fraction.js , elle m’a vraiment aidé et m'a fait gagner beaucoup de temps et de travail. L'espoir peut être utile à quelqu'un d'autre!
J'ai fait ce que popnoodles a suggéré et le voici
function FractionFormatter(value) {
if (value == undefined || value == null || isNaN(value))
return "";
function _FractionFormatterHighestCommonFactor(u, v) {
var U = u, V = v
while (true) {
if (!(U %= V)) return V
if (!(V %= U)) return U
}
}
var parts = value.toString().split('.');
if (parts.length == 1)
return parts;
else if (parts.length == 2) {
var wholeNum = parts[0];
var decimal = parts[1];
var denom = Math.pow(10, decimal.length);
var factor = _FractionFormatterHighestCommonFactor(decimal, denom)
return (wholeNum == '0' ? '' : (wholeNum + " ")) + (decimal / factor) + '/' + (denom / factor);
} else {
return "";
}
}