7
votes

Ruby Floating Point Math - Problème avec précision en somme Calc

Bonjour à tous,

J'ai des problèmes avec des mathématiques flottantes et je suis totalement perdu dans ".to_f" 's, "* 100"' s et ".0"! P>

J'espérais que quelqu'un puisse m'aider avec mon problème spécifique, et aussi expliquer exactement pourquoi leur solution fonctionne pour que je comprends cela pour la prochaine fois. P>

Mon programme doit faire deux choses:

Sum à une liste de décimales, déterminez s'ils résument exactement 1.0 li>
Déterminez une différence entre 1,0 et une somme de chiffres - définissez la valeur d'une variable à la différence exacte pour rendre la somme égale à 1,0. li> ol>
Par exemple: P>
1. [0,28, 0.55, 0,17] -> devrait-il être somme à 1,0, mais je continue à obtenir 1xxxxxxx. Je suis en train de mettre en œuvre la somme de la mode suivante: p>
```
          sum = 0.0
          array.each do |item|
            sum += item * 100.0
          end
          array[i] = (100 - sum.round)/100.0
```
2. La raison pour laquelle j'ai besoin de cette fonctionnalité est que je lis dans un ensemble de décimales provenant d'Excel. Ils ne sont pas 100% précis (ils manquent de points décimaux) de sorte que la somme sort habituellement de 0,999999xxxxx ou 1.000xxxxx. Par exemple, je vais obtenir des valeurs comme les suivantes: p>
```
0.568887955,0.070564759,0.360547286
```

ruby ruby-on-rails validation math floating-point

0 commentaires

3 Réponses :

2
votes

soit:

continuer à utiliser des flotteurs et rond (2) Vos totaux: 12.341.Round (2) # => 12.34
Utilisez des entiers (c'est-à-dire des cents au lieu de dollars)
Utilisez BigDecimal et vous n'aurez pas besoin de tourner après les en lesomer, tant que vous commencez avec BigDecimal avec seulement deux décimales.



                                                                    
                                    
                                    
                                        0 commentaires


                        
                                            
                            
                                
                                    11
 votes
                                
                            
                            
                                
                                     Si la précision est importante pour vous, vous ne devez pas utiliser les valeurs de points flottants, qui, par définition, ne sont pas exactes. Ruby a des types de données de précision pour faire de l'arithmétique où la précision est importante. Ils sont, au sommet de ma tête,  < Code> BigDecimal  ,   rationnel < / code>  et   complexe  < / a>, selon ce que vous avez réellement besoin de calculer. 
 Il semble que dans votre cas, ce que vous recherchez est BigDecimal, qui est fondamentalement un nombre avec un nombre fixe de chiffres, dont il existe un nombre de chiffres après le point décimal (contrairement à un point flottant, qui a un nombre arbitraire de chiffres après le point décimal).  
 Lorsque vous lisez Excel et jetez délibérément ces cordes comme "0,9987" à Points flottants, vous perdez immédiatement la valeur précise contenue dans la chaîne.   xxx  
 Cette valeur est précise. C'est 0.9987. Pas 0.998732109, ou tout ce qui est proche, mais 0.9987. Vous pouvez utiliser toutes les opérations arithmétiques habituelles sur elle. À condition que vous ne mélangez pas de points flottants dans les opérations arithmétiques, les valeurs de retour resteront précises.  
 Si votre tableau contient les chaînes brutes que vous avez d'Excel (c.-à-d. Vous n'avez pas  # #o_f < / Code> 'd eux), alors cela vous donnera une bigdecimal qui est la différence entre la somme d'entre eux et 1.   xxx                                  


                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            

                        

                        
                                            
                            
                                
                                    0
 votes
                                
                            
                            
                                
                                     Je pense que les algorithmes ont beaucoup plus de choses à voir avec précision et précision qu'un choix de point flottant IEEE sur une autre représentation. 

 Les gens utilisaient des calculs fins tout en faisant des problèmes de précision et de précision. Ils le feraient en gérant les algorithmes qu'ils utilisaient et comprennent comment représenter des fonctions plus profondément. Je pense que vous pourriez faire une erreur en jetant de côté pour mieux comprendre et supposer qu'une autre représentation est la solution. 

 Par exemple, aucune représentation polynomiale d'une fonction ne traitera correctement d'une asymptote ou d'une singularité. 

 Ne supprimez pas le point flottant si rapidement. Je pourrais être aussi intelligent de la façon dont vous les utilisez fera bien.                                 

                                                                    
                                    
                                    
                                        0 commentaires