Un chemin de ronde Flotte bas

Float round arrondit vers le haut ou vers le bas. J'ai toujours besoin d'arrondir à la baisse.

J'ai la solution mais je n'ai pas vraiment aimé... Peut-être il ya une meilleure façon.

C'est ce que je veux:

1.9999.round_down(2) 
#=> 1.99
1.9901.round_down(2)
#=> 1

Je suis venu avec cette solution, mais je voudrais savoir si il y a une meilleure solution(je n'aime pas que je convertir le flotteur deux fois). Il y a déjà une méthode pour cela? Parce que je l'ai trouvé assez étrange que je ne pourrais pas le trouver.

class Float
  def round_down(n=0)
    ((self * 10**n).to_i).to_f/10**n 
  end
end

Grâce.

J'aime votre solution...
Que voulez-vous faire avec des nombres négatifs? Vers l'infini négatif ou vers zéro?
Ce n'est pas exactement ce que vous voulez (comme vous aurez toujours perdre la partie décimale), mais si vous convertir un entier vous sera toujours arrondi à l'inférieur - 1.9901.to_i - peut être beaucoup mieux en fonction de votre scénario.

OriginalL'auteur Michael Koper | 2011-08-17

11

Basé sur la réponse de @kimmmo ce devrait être un peu plus efficace:
```
class Float
  def round_down n=0
  s = self.to_s
  l = s.index('.') + 1 + n
  s.length <= l ? self : s[0,l].to_f
  end
end

1.9991.round_down(3)
 => 1.999
1.9991.round_down(2)
 => 1.99
1.9991.round_down(0)
 => 1.0
1.9991.round_down(5)
 => 1.9991
```
ou basé sur la réponse de @steenslag, probablement encore plus efficace, car il n'y a pas de conversion de chaîne de caractères:
```
class Float
  def round_down n=0
    n < 1 ? self.to_i.to_f : (self - 0.5 / 10**n).round(n)
  end
end
```
Cette réponse est également bon. Préfèrent encore @kimmmo sa solution, car il est plus court et plus facile à lire. Mais c'est aussi une bonne réponse! Merci
regardez dans la deuxième solution, je pense que c'est plus simple et encore plus efficace.
Dans mon petit test de vitesse, cette version de chaîne est deux fois plus rapide que kimmmo de split version, et la deuxième version en utilisant des mathématiques est environ 4 fois plus vite encore. Mathématiques: bon pour les chiffres.
J'ai des problèmes avec le second (n=5): avec 0 le résultat est -0.00001, avec 0.0000001 le résultat est -0.0
depuis que quelqu'un a commenté sur ma réponse au bout de 5 ans, et je suis ici, je voudrais juste dire que l'utilisation de s.index(?., 1) est probablement encore plus vite. les mathématiques version est gagnant dans tous les cas 🙂

OriginalL'auteur geronime

1.9999.to_i
#=> 1
1.9999.floor
#=> 1

répondu à 1 sec il y a fl00r

"%.2f" % 1.93213
#=> 1.93

@kimmmo est droit.

class Float
  def round_down(n=0)
    self.to_s[/\d+\.\d{#{n}}/].to_f
  end
end

"%.2f" % 1.935 => 1.94, le demandeur veut renvoyer de 1.93
oh, je l'ai eu

OriginalL'auteur fl00r

9

Dirait que vous voulez juste la bande de décimales après n
```
class Float
  def round_down(n=0)
    int,dec=self.to_s.split('.')
    "#{int}.#{dec[0...n]}".to_f
  end
end


1.9991.round_down(3)
 => 1.999
1.9991.round_down(2)
 => 1.99
1.9991.round_down(0)
 => 1.0
1.9991.round_down(10)
 => 1.9991
```
(Edit: un peu plus efficace version sans la regexp)

Hey j'aime cette idée!
Ne devrait pas 1.9991.round_down(0) retour 1 au lieu de 1.0?
signifie simplement qu'il est encore un flotteur. Je suppose que vous pouvez construire sur les fonctionnalités à utiliser to_i si n == 0, mais qui pourrait sans doute donner à quelqu'un des maux de tête de débogage.
Merci s'accoupler. Cette réponse est assez bon. 🙂
Vous êtes à faire des mathématiques avec des cordes.. comment dégoûtant! 🙂

OriginalL'auteur Kimmo Lehto
5

Vous pouvez utiliser le sol de la méthode

http://www.ruby-doc.org/core/classes/Float.html#M000142

Float#sol ne sera jamais 1.999 en 1.99.
Je pense que l'étage est la même que to_i. Elle renvoie l'Entier plus élevée.
C'est la réponse correcte. Vous pourriez avoir un exemple.

OriginalL'auteur Tejo
1

En Ruby 1.9:
```
class Float
  def floor_with_prec(prec = 0)
    (self - 0.5).round(prec)
  end
end
```
(1.9990 - 0.5).round(2) => 1.5 (asker veut le retour de 1,99)
La droite. Vous pouvez vous déplacer qu'avec une révision mineure, je pense: (self - 0.5 / 10**prec).round(prec). Je ne suis pas sûr si cela va être battue en virgule flottante de questions, bien.

OriginalL'auteur steenslag

class Float
  def rownd_down(digits = 1)
    ("%.#{digits+1}f" % self)[0..-2].to_f
  end 
end

> 1.9991.rownd_down(3)
=> 1.999
> 1.9991.rownd_down(2)
=> 1.99
> 1.9991.rownd_down(10)
> 1.9991

OriginalL'auteur Dongzhen Piao

0
```
class Float
  def round_down(n)
    num = self.round(n)
    num > self ? (num - 0.1**n) : num
  end
end
```
56.0.round_down(-1) = 50. Fonctionne avec des nombres négatifs ainsi, si vous êtes d'accord que l'arrondi se fait à un certain nombre de plus petits: -56.09.round_down(1) = -56.1.

OriginalL'auteur EJ2015

Trouvé cet article utile: https://richonrails.com/articles/rounding-numbers-in-ruby

Voici le tour d'horizon et méthodes:

class Float
  def round_down(exp = 0)
   multiplier = 10 ** exp
   ((self * multiplier).floor).to_f/multiplier.to_f
  end

  def round_up(exp = 0)
   multiplier = 10 ** exp
   ((self * multiplier).ceil).to_f/multiplier.to_f
  end
end

OriginalL'auteur Eric

Trouvé un bug pour les réponses que d'essayer de calculer flotter dans round_down méthode.

> 8.7.round_down(1)
=> 8.7
> 8.7.round_down(2)
=> 8.69

vous pouvez utiliser bigdecimal, entier ou peut-être de chaîne pour faire tous les calculs mais flotteur.

 > 8.7 - 0.005
 => 8.694999999999999

Voici ma solution:

require 'bigdecimal'

class Float
  def floor2(n = 0)
    BigDecimal.new(self.to_s).floor(n).to_f
  end
end

> 8.7.floor2(1)
=> 8.7
> 8.7.floor2(2)
=> 8.7

> 1.9991.floor(3)
=> 1.999
> 1.9991.floor(2)
=> 1.99
> 1.9991.floor(1)
=> 1.9

OriginalL'auteur Bob Lu

-1

Cela a fonctionné pour moi.
```
> (1.999).to_i.to_f
```
Pour rassembler vous pouvez simplement utiliser
```
> (1.999+1).to_i.to_f
```
OriginalL'auteur Tejas

Vous devez vous connecter pour publier un commentaire.