juanlu.space
-12
README.txt
-12
README.txt
···
1
-
http://puntoflotante.org pretende dar respuestas cortas y sencillas
2
-
a las preguntas recurrentes de programadores principiantes sobre
3
-
números de punto flotante que «no se suman correctamente», e información
4
-
más detallada sobre cómo funcionan los números decimales del IEEE 754,
5
-
cuándo y cómo usarlos correctamente, y qué usar en su lugar cuando
6
-
no son apropiados.
7
-
8
-
Este sitio está hecho usando el generador de sitios estáticos nanoc:
9
-
http://nanoc.stoneship.org/ (requiere las gemas kramdown y adsf)
10
-
11
-
y publicado bajo una licencia Creative Commons Atribución Unported (BY):
12
-
http://creativecommons.org/licenses/by/3.0/deed.es
-1
Rakefile
-1
Rakefile
···
1
-
require 'nanoc3/tasks'
-31
Rules
-31
Rules
···
1
-
#!/usr/bin/env ruby
2
-
3
-
# A few helpful tips about the Rules file:
4
-
#
5
-
# * The order of rules is important: for each item, only the first matching
6
-
# rule is applied.
7
-
#
8
-
# * Item identifiers start and end with a slash (e.g. “/about/” for the file
9
-
# “content/about.html”). To select all children, grandchildren, … of an
10
-
# item, use the pattern “/about/*/”; “/about/*” will also select the parent,
11
-
# because “*” matches zero or more characters.
12
-
13
-
compile '*' do
14
-
case item[:extension]
15
-
when 'html'
16
-
filter :erb
17
-
filter :kramdown
18
-
layout 'default'
19
-
end
20
-
end
21
-
22
-
route '*' do
23
-
case item[:extension]
24
-
when 'html'
25
-
item.identifier + 'index.html'
26
-
else
27
-
item.identifier.chop + '.' + item[:extension]
28
-
end
29
-
end
30
-
31
-
layout '*', :erb
+112
basic/index.html
+112
basic/index.html
···
1
+
<!DOCTYPE HTML>
2
+
<html lang="es">
3
+
<head>
4
+
<meta charset="utf-8">
5
+
<title>La Guía del Punto Flotante - Respuestas básicas</title>
6
+
7
+
<meta name="generator" content="nanoc 3.1.2">
8
+
9
+
<meta name="Description" content="Respuestas concisas a preguntas básicas sobre aritmética de punto flotante, como «¿por qué mis números no se suman bien?»">
10
+
11
+
<link rel="stylesheet" type="text/css" href="/style.css" media="screen">
12
+
<link rel="shortcut icon" href="/favicon.ico" type="image/vnd.microsoft.icon">
13
+
<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
14
+
</head>
15
+
<body>
16
+
<div id="main">
17
+
<h1>Respuestas básicas</h1>
18
+
<h3 id="por-qu-al-sumar-mis-nmeros-como-01--02-en-vez-de-dar-03-da-un-resultado-extrao-como-030000000000000004">¿Por qué al sumar mis números, como 0.1 + 0.2, en vez de dar 0.3 da un resultado extraño como 0.30000000000000004?</h3>
19
+
20
+
<p>Porque internamente, los ordenadores usan un formato (<a href="/formats/fp">punto flotante</a> <a href="/formats/binary">binario</a>)
21
+
que no puede representar de forma precisa números como 0.1, 0.2 o 0.3 <em>de ninguna manera</em>.</p>
22
+
23
+
<p>Cuando el código es compilado o interpretado, tu “0.1” se redondea
24
+
al número más cercano en ese formato, lo que resulta en un pequeño
25
+
<a href="/errors/rounding/">error de redondeo</a> incluso antes de que se haga
26
+
la operación.</p>
27
+
28
+
<h3 id="por-qu-los-ordenadores-usan-un-sistema-tan-estpido">¿Por qué los ordenadores usan un sistema tan estúpido?</h3>
29
+
30
+
<p>No es estúpido, solo diferente. Los números decimales no pueden representar
31
+
con precisión un número como ⅓, así que lo tienes que redondear a algo como
32
+
0.33 ─ y no esperas que 0.33 + 0.33 + 0.33 sea igual a 1 tampoco, ¿no?</p>
33
+
34
+
<p>Los ordenadores usan <a href="/formats/binary/">números binarios</a> porque son más
35
+
rápidos de manejar, y porque para la mayoría de operaciones un error en la
36
+
17ª cifra decimal no importa en absoluto ya que los valores con los que
37
+
trabajas no eran así de precisos de todas formas.</p>
38
+
39
+
<h3 id="qu-puedo-hacer-para-evitar-este-problema">¿Qué puedo hacer para evitar este problema?</h3>
40
+
41
+
<p>Eso depende del tipo de cálculos que estés haciendo.</p>
42
+
43
+
<ul>
44
+
<li>Si de verdad necesitas que tus resultados se sumen con exactitud, especialmente cuando trabajas con dinero: utiliza un <a href="/formats/exact/">tipo de datos decimal</a> especial.</li>
45
+
<li>Si es solo que no quieres ver todos esos decimales extra: simplemente da formato a tu resultado redondeando a un número fijo de cifras decimales cuando lo presentes.</li>
46
+
<li>Si no tienes un tipo de datos decimal, una alternativa es trabajar con <a href="/formats/integer/">enteros</a>, e.g. hacer todos los cálculos con dinero en céntimos. Pero esto requiere más trabajo y tiene algunas desventajas.</li>
47
+
</ul>
48
+
49
+
<h3 id="por-qu-otros-clculos-como-01--04-s-funcionan-bien">¿Por qué otros cálculos como 0.1 + 0.4 sí funcionan bien?</h3>
50
+
51
+
<p>En este caso, el resultado (0.5) <em>sí</em> puede ser representado de manera exacta como un
52
+
número de punto flotante, y es posible que los errores de redondeo de los datos de partida
53
+
se cancelen entre sí ─ aunque no se debería confiar excesivamente en esto (e.g. cuando
54
+
esos dos números fueron almacenados en representaciones de punto flotante de diferente
55
+
tamaño, los errores de redondeo pueden no cancelarse entre ellos).</p>
56
+
57
+
<p>En otros casos como 0.1 + 0.3, el resultado no es <em>realmente</em> 0.4, pero está lo suficientemente
58
+
cerca como para que 0.4 sea el número más corto que está más cerca del resultado que cualquier
59
+
otro número de punto flotante. La mayoría de lenguajes presentan ese número en vez de convertir
60
+
el resultado real a una fracción decimal.</p>
61
+
62
+
<p>Si quieres más información, puedes acudir a las <a href="/references/">Referencias</a>.</p>
63
+
64
+
<g:plusone href="http://puntoflotante.org/"></g:plusone>
65
+
<div id="license">
66
+
<p>© Publicado en <a href="http://puntoflotante.org/">http://puntoflotante.org/</a> bajo una licencia
67
+
<a href="http://creativecommons.org/licenses/by/3.0/deed.es">Creative Commons Atribución Unported (BY)</a>.
68
+
Original en inglés por Michael Borgwardt en
69
+
<a href="http://floating-point-gui.de/">http://floating-point-gui.de/</a>.</p>
70
+
</div>
71
+
</div>
72
+
<div id="sidebar">
73
+
<a href="/"><img src="/logo.png"></a>
74
+
<h2>La Guía del Punto Flotante</h2>
75
+
<ul>
76
+
<li><a href="http://floating-point-gui.de/" alt="in English"><img src="/en.png"></a></li>
77
+
<li><a href="/">Inicio</a></li>
78
+
<li><a href="/basic/">Respuestas básicas</a></li>
79
+
<li><a href="/references/">Referencias</a></li>
80
+
<li><a href="/xkcd/">xkcd</a></li>
81
+
</ul>
82
+
83
+
<h2>Formatos Numéricos</h2>
84
+
<ul>
85
+
<li><a href="/formats/binary/">Fracciones binarias</a></li>
86
+
<li><a href="/formats/fp/">Punto flotante</a></li>
87
+
<li><a href="/formats/exact/">Tipos exactos</a></li>
88
+
<li><a href="/formats/integer/">Sobre usar enteros</a></li>
89
+
</ul>
90
+
91
+
<h2>Errores</h2>
92
+
<ul>
93
+
<li><a href="/errors/rounding/">Redondeo</a></li>
94
+
<li><a href="/errors/comparison/">Comparación</a></li>
95
+
<li><a href="/errors/propagation/">Propagación</a></li>
96
+
</ul>
97
+
98
+
<h2>Cheat sheets</h2>
99
+
<ul>
100
+
<li><a href="/languages/csharp/">C#</a></li>
101
+
<li><a href="/languages/java/">Java</a></li>
102
+
<li><a href="/languages/javascript/">JavaScript</a></li>
103
+
<li><a href="/languages/perl/">Perl</a></li>
104
+
<li><a href="/languages/php/">PHP</a></li>
105
+
<li><a href="/languages/python/">Python</a></li>
106
+
<li><a href="/languages/sql/">SQL</a></li>
107
+
</ul>
108
+
</div>
109
+
<a href="http://github.com/Pybonacci/puntoflotante.org"><img style="position: absolute; top: 0; right: 0; border: 0;" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" alt="Fork me on GitHub" /></a>
110
+
111
+
</body>
112
+
</html>
-41
config.yaml
-41
config.yaml
···
1
-
# A list of file extensions that nanoc will consider to be textual rather than
2
-
# binary. If an item with an extension not in this list is found, the file
3
-
# will be considered as binary.
4
-
text_extensions: [ 'css', 'erb', 'haml', 'htm', 'html', 'js', 'less', 'markdown', 'md', 'php', 'rb', 'sass', 'txt' ]
5
-
6
-
# The path to the directory where all generated files will be written to. This
7
-
# can be an absolute path starting with a slash, but it can also be path
8
-
# relative to the site directory.
9
-
output_dir: ../output
10
-
11
-
# A list of index filenames, i.e. names of files that will be served by a web
12
-
# server when a directory is requested. Usually, index files are named
13
-
# “index.hml”, but depending on the web server, this may be something else,
14
-
# such as “default.htm”. This list is used by nanoc to generate pretty URLs.
15
-
index_filenames: [ 'index.html' ]
16
-
17
-
# Whether or not to generate a diff of the compiled content when compiling a
18
-
# site. The diff will contain the differences between the compiled content
19
-
# before and after the last site compilation.
20
-
enable_output_diff: false
21
-
22
-
# The data sources where nanoc loads its data from. This is an array of
23
-
# hashes; each array element represents a single data source. By default,
24
-
# there is only a single data source that reads data from the “content/” and
25
-
# “layout/” directories in the site directory.
26
-
data_sources:
27
-
-
28
-
# The type is the identifier of the data source. By default, this will be
29
-
# `filesystem_unified`.
30
-
type: filesystem_unified
31
-
32
-
# The path where items should be mounted (comparable to mount points in
33
-
# Unix-like systems). This is “/” by default, meaning that items will have
34
-
# “/” prefixed to their identifiers. If the items root were “/en/”
35
-
# instead, an item at content/about.html would have an identifier of
36
-
# “/en/about/” instead of just “/about/”.
37
-
items_root: /
38
-
39
-
# The path where layouts should be mounted. The layouts root behaves the
40
-
# same as the items root, but applies to layouts rather than items.
41
-
layouts_root: /
-48
content/basic.html
-48
content/basic.html
···
1
-
---
2
-
title: Respuestas básicas
3
-
description: Respuestas concisas a preguntas básicas sobre aritmética de punto flotante, como «¿por qué mis números no se suman bien?»
4
-
---
5
-
6
-
### ¿Por qué al sumar mis números, como 0.1 + 0.2, en vez de dar 0.3 da un resultado extraño como 0.30000000000000004?
7
-
8
-
Porque internamente, los ordenadores usan un formato ([punto flotante](/formats/fp) [binario](/formats/binary))
9
-
que no puede representar de forma precisa números como 0.1, 0.2 o 0.3 *de ninguna manera*.
10
-
11
-
Cuando el código es compilado o interpretado, tu "0.1" se redondea
12
-
al número más cercano en ese formato, lo que resulta en un pequeño
13
-
[error de redondeo](/errors/rounding/) incluso antes de que se haga
14
-
la operación.
15
-
16
-
### ¿Por qué los ordenadores usan un sistema tan estúpido?
17
-
18
-
No es estúpido, solo diferente. Los números decimales no pueden representar
19
-
con precisión un número como ⅓, así que lo tienes que redondear a algo como
20
-
0.33 ─ y no esperas que 0.33 + 0.33 + 0.33 sea igual a 1 tampoco, ¿no?
21
-
22
-
Los ordenadores usan [números binarios](/formats/binary/) porque son más
23
-
rápidos de manejar, y porque para la mayoría de operaciones un error en la
24
-
17ª cifra decimal no importa en absoluto ya que los valores con los que
25
-
trabajas no eran así de precisos de todas formas.
26
-
27
-
### ¿Qué puedo hacer para evitar este problema?
28
-
29
-
Eso depende del tipo de cálculos que estés haciendo.
30
-
31
-
* Si de verdad necesitas que tus resultados se sumen con exactitud, especialmente cuando trabajas con dinero: utiliza un [tipo de datos decimal](/formats/exact/) especial.
32
-
* Si es solo que no quieres ver todos esos decimales extra: simplemente da formato a tu resultado redondeando a un número fijo de cifras decimales cuando lo presentes.
33
-
* Si no tienes un tipo de datos decimal, una alternativa es trabajar con [enteros](/formats/integer/), e.g. hacer todos los cálculos con dinero en céntimos. Pero esto requiere más trabajo y tiene algunas desventajas.
34
-
35
-
### ¿Por qué otros cálculos como 0.1 + 0.4 sí funcionan bien?
36
-
37
-
En este caso, el resultado (0.5) *sí* puede ser representado de manera exacta como un
38
-
número de punto flotante, y es posible que los errores de redondeo de los datos de partida
39
-
se cancelen entre sí ─ aunque no se debería confiar excesivamente en esto (e.g. cuando
40
-
esos dos números fueron almacenados en representaciones de punto flotante de diferente
41
-
tamaño, los errores de redondeo pueden no cancelarse entre ellos).
42
-
43
-
En otros casos como 0.1 + 0.3, el resultado no es _realmente_ 0.4, pero está lo suficientemente
44
-
cerca como para que 0.4 sea el número más corto que está más cerca del resultado que cualquier
45
-
otro número de punto flotante. La mayoría de lenguajes presentan ese número en vez de convertir
46
-
el resultado real a una fracción decimal.
47
-
48
-
Si quieres más información, puedes acudir a las [Referencias](/references/).
content/en.png
content/en.png
This is a binary file and will not be displayed.
-176
content/errors/NearlyEqualsTest.java
-176
content/errors/NearlyEqualsTest.java
···
1
-
import static org.junit.Assert.assertFalse;
2
-
import static org.junit.Assert.assertTrue;
3
-
4
-
import org.junit.Test;
5
-
6
-
/**
7
-
* Test suite to demonstrate a good method for comparing floating-point values
8
-
* using an epsilon. Run via JUnit 4.
9
-
*
10
-
* Note: this function attempts a "one size fits all" solution. There may be
11
-
* some edge cases for which it still produces unexpected results, and some of
12
-
* the tests it was developed to pass probably specify behaviour that is not
13
-
* appropriate for some applications. Before using it, make sure it's
14
-
* appropriate for your application!
15
-
*
16
-
* From http://floating-point-gui.de
17
-
*
18
-
* @author Michael Borgwardt
19
-
*/
20
-
public class NearlyEqualsTest {
21
-
public static boolean nearlyEqual(float a, float b, float epsilon) {
22
-
final float absA = Math.abs(a);
23
-
final float absB = Math.abs(b);
24
-
final float diff = Math.abs(a - b);
25
-
26
-
if (a == b) { // shortcut, handles infinities
27
-
return true;
28
-
} else if (a * b == 0) { // a or b or both are zero
29
-
// relative error is not meaningful here
30
-
return diff < (epsilon * epsilon);
31
-
} else { // use relative error
32
-
return diff / (absA + absB) < epsilon;
33
-
}
34
-
}
35
-
36
-
public static boolean nearlyEqual(float a, float b) {
37
-
return nearlyEqual(a, b, 0.000001f);
38
-
}
39
-
40
-
/** Regular large numbers - generally not problematic */
41
-
@Test
42
-
public void big() {
43
-
assertTrue(nearlyEqual(1000000f, 1000001f));
44
-
assertTrue(nearlyEqual(1000001f, 1000000f));
45
-
assertFalse(nearlyEqual(10000f, 10001f));
46
-
assertFalse(nearlyEqual(10001f, 10000f));
47
-
}
48
-
49
-
/** Negative large numbers */
50
-
@Test
51
-
public void bigNeg() {
52
-
assertTrue(nearlyEqual(-1000000f, -1000001f));
53
-
assertTrue(nearlyEqual(-1000001f, -1000000f));
54
-
assertFalse(nearlyEqual(-10000f, -10001f));
55
-
assertFalse(nearlyEqual(-10001f, -10000f));
56
-
}
57
-
58
-
/** Numbers around 1 */
59
-
@Test
60
-
public void mid() {
61
-
assertTrue(nearlyEqual(1.0000001f, 1.0000002f));
62
-
assertTrue(nearlyEqual(1.0000002f, 1.0000001f));
63
-
assertFalse(nearlyEqual(1.0002f, 1.0001f));
64
-
assertFalse(nearlyEqual(1.0001f, 1.0002f));
65
-
}
66
-
67
-
/** Numbers around -1 */
68
-
@Test
69
-
public void midNeg() {
70
-
assertTrue(nearlyEqual(-1.000001f, -1.000002f));
71
-
assertTrue(nearlyEqual(-1.000002f, -1.000001f));
72
-
assertFalse(nearlyEqual(-1.0001f, -1.0002f));
73
-
assertFalse(nearlyEqual(-1.0002f, -1.0001f));
74
-
}
75
-
76
-
/** Numbers between 1 and 0 */
77
-
@Test
78
-
public void small() {
79
-
assertTrue(nearlyEqual(0.000000001000001f, 0.000000001000002f));
80
-
assertTrue(nearlyEqual(0.000000001000002f, 0.000000001000001f));
81
-
assertFalse(nearlyEqual(0.000000000001002f, 0.000000000001001f));
82
-
assertFalse(nearlyEqual(0.000000000001001f, 0.000000000001002f));
83
-
}
84
-
85
-
/** Numbers between -1 and 0 */
86
-
@Test
87
-
public void smallNeg() {
88
-
assertTrue(nearlyEqual(-0.000000001000001f, -0.000000001000002f));
89
-
assertTrue(nearlyEqual(-0.000000001000002f, -0.000000001000001f));
90
-
assertFalse(nearlyEqual(-0.000000000001002f, -0.000000000001001f));
91
-
assertFalse(nearlyEqual(-0.000000000001001f, -0.000000000001002f));
92
-
}
93
-
94
-
/** Comparisons involving zero */
95
-
@Test
96
-
public void zero() {
97
-
assertTrue(nearlyEqual(0.0f, 0.0f));
98
-
assertTrue(nearlyEqual(0.0f, -0.0f));
99
-
assertTrue(nearlyEqual(-0.0f, -0.0f));
100
-
assertFalse(nearlyEqual(0.00000001f, 0.0f));
101
-
assertFalse(nearlyEqual(0.0f, 0.00000001f));
102
-
assertFalse(nearlyEqual(-0.00000001f, 0.0f));
103
-
assertFalse(nearlyEqual(0.0f, -0.00000001f));
104
-
105
-
assertTrue(nearlyEqual(0.0f, 0.00000001f, 0.01f));
106
-
assertTrue(nearlyEqual(0.00000001f, 0.0f, 0.01f));
107
-
assertFalse(nearlyEqual(0.00000001f, 0.0f, 0.000001f));
108
-
assertFalse(nearlyEqual(0.0f, 0.00000001f, 0.000001f));
109
-
110
-
assertTrue(nearlyEqual(0.0f, -0.00000001f, 0.1f));
111
-
assertTrue(nearlyEqual(-0.00000001f, 0.0f, 0.1f));
112
-
assertFalse(nearlyEqual(-0.00000001f, 0.0f, 0.00000001f));
113
-
assertFalse(nearlyEqual(0.0f, -0.00000001f, 0.00000001f));
114
-
}
115
-
116
-
/**
117
-
* Comparisons involving infinities
118
-
*/
119
-
@Test
120
-
public void infinities() {
121
-
assertTrue(nearlyEqual(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY));
122
-
assertTrue(nearlyEqual(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY));
123
-
assertFalse(nearlyEqual(Float.NEGATIVE_INFINITY,
124
-
Float.POSITIVE_INFINITY));
125
-
assertFalse(nearlyEqual(Float.POSITIVE_INFINITY, Float.MAX_VALUE));
126
-
assertFalse(nearlyEqual(Float.NEGATIVE_INFINITY, -Float.MAX_VALUE));
127
-
}
128
-
129
-
/**
130
-
* Comparisons involving NaN values
131
-
*/
132
-
@Test
133
-
public void nan() {
134
-
assertFalse(nearlyEqual(Float.NaN, Float.NaN));
135
-
}
136
-
137
-
/** Comparisons of numbers on opposite sides of 0 */
138
-
@Test
139
-
public void opposite() {
140
-
assertFalse(nearlyEqual(1.000000001f, -1.0f));
141
-
assertFalse(nearlyEqual(-1.0f, 1.000000001f));
142
-
assertFalse(nearlyEqual(-1.000000001f, 1.0f));
143
-
assertFalse(nearlyEqual(1.0f, -1.000000001f));
144
-
assertTrue(nearlyEqual(1e10f * Float.MIN_VALUE, -1e10f
145
-
* Float.MIN_VALUE));
146
-
}
147
-
148
-
/**
149
-
* The really tricky part - comparisons of numbers very close to zero.
150
-
*/
151
-
@Test
152
-
public void ulp() {
153
-
assertTrue(nearlyEqual(Float.MIN_VALUE, -Float.MIN_VALUE));
154
-
assertTrue(nearlyEqual(-Float.MIN_VALUE, Float.MIN_VALUE));
155
-
assertTrue(nearlyEqual(Float.MIN_VALUE, 0));
156
-
assertTrue(nearlyEqual(0, Float.MIN_VALUE));
157
-
assertTrue(nearlyEqual(-Float.MIN_VALUE, 0));
158
-
assertTrue(nearlyEqual(0, -Float.MIN_VALUE));
159
-
160
-
assertFalse(nearlyEqual(0.000000001f, -Float.MIN_VALUE));
161
-
assertFalse(nearlyEqual(0.000000001f, Float.MIN_VALUE));
162
-
assertFalse(nearlyEqual(Float.MIN_VALUE, 0.000000001f));
163
-
assertFalse(nearlyEqual(-Float.MIN_VALUE, 0.000000001f));
164
-
165
-
assertFalse(nearlyEqual(1e25f * Float.MIN_VALUE, 0.0f, 1e-12f));
166
-
assertFalse(nearlyEqual(0.0f, 1e25f * Float.MIN_VALUE, 1e-12f));
167
-
assertFalse(nearlyEqual(1e25f * Float.MIN_VALUE, -1e25f
168
-
* Float.MIN_VALUE, 1e-12f));
169
-
170
-
assertTrue(nearlyEqual(1e25f * Float.MIN_VALUE, 0.0f, 1e-5f));
171
-
assertTrue(nearlyEqual(0.0f, 1e25f * Float.MIN_VALUE, 1e-5f));
172
-
assertTrue(nearlyEqual(1e20f * Float.MIN_VALUE, -1e20f
173
-
* Float.MIN_VALUE, 1e-5f));
174
-
}
175
-
176
-
}
-95
content/errors/comparison.html
-95
content/errors/comparison.html
···
1
-
---
2
-
title: Comparación
3
-
description: Explicación de los diversos problemas al comparar números de punto flotante
4
-
---
5
-
6
-
Debido a los errores de redondeo, la mayoría de los números de [punto flotante](/formats/fp/)
7
-
terminan siendo ligeramente imprecisos. Mientras esta imprecisión se mantenga pequeña,
8
-
normalmente se puede ignorar. Sin embargo, esto significa también que números que se
9
-
espera que sean iguales (por ejemplo al calcular el mismo resultado utilizando distintos
10
-
métodos correctos) a veces difieren levemente, y una simple prueba de igualdad falla.
11
-
Por ejemplo:
12
-
13
-
float a = 0.15 + 0.15
14
-
float b = 0.1 + 0.2
15
-
if(a == b) // ¡Puede ser falso!
16
-
if(a >= b) // ¡También puede ser falso!
17
-
18
-
No usar márgenes de error absolutos
19
-
-----------------------------------
20
-
21
-
La solución es comprobar no si los números son exactamente iguales, sino si su
22
-
diferencia es muy pequeña. El margen de error frente al que se compara esta diferencia
23
-
normalmente se llama *epsilon*. En su forma más simple:
24
-
25
-
if(Math.abs(a-b) < 0.00001) // Mal ─ no hacer esto
26
-
27
-
Esto es una mala forma de hacerlo porque un epsilon fijo elegido porque «parece
28
-
pequeño» podría perfectamente ser demasiado grande cuando los números que se
29
-
comparan son también muy pequeños. La comparación devolvería «verdadero» para
30
-
números muy diferentes. Y cuando los números son muy grandes, el epsilon
31
-
puede acabar siendo más pequeño que el mínimo error de redondeo, por lo que
32
-
la comparación siempre devolvería «falso». Por tanto, es necesario ver si
33
-
el *error relativo* es menor que epsilon:
34
-
35
-
if(Math.abs((a-b)/b) < 0.00001) // ¡Todavía no es correcto!
36
-
37
-
Vigila los casos límite
38
-
-----------------------
39
-
40
-
Hay algunos casos especiales importantes para los que esto falla:
41
-
42
-
* Cuando tanto `a` como `b` son cero. `0.0/0.0` es NaN, lo que provoca una excepción en algunas plataformas o devuelve falso para todas las comparaciones.
43
-
* Cuando solo `b` es cero, la división devuelve infinito, lo que también puede causar una excepción, o es mayor que epsilon incluso cuando `a` es más pequeño.
44
-
* Devuelve «falso» cuando tanto `a` como `b` son muy pequeños pero a ambos lados del cero, incluso cuando son los números no nulos más pequeños.
45
-
46
-
Además, el resultado no es conmutativo (`nearlyEquals(a,b)` no es siempre lo mismo que
47
-
`nearlyEquals(b,a)`). Para solucionar estos problemas, el código tiene que ser mucho más
48
-
complejo, así que necesitamos meterlo en una función:
49
-
50
-
public static boolean nearlyEqual(float a, float b, float epsilon)
51
-
{
52
-
final float absA = Math.abs(a);
53
-
final float absB = Math.abs(b);
54
-
final float diff = Math.abs(a - b);
55
-
56
-
if (a == b) { // Atajo, maneja los infinitos
57
-
return true;
58
-
} else if (a * b == 0) { // a o b o ambos son cero
59
-
// El error relativo no es importante aquí
60
-
return diff < (epsilon * epsilon);
61
-
} else { // Usar el error relativo
62
-
return diff / (absA + absB) < epsilon;
63
-
}
64
-
}
65
-
66
-
Este método [pasa las pruebas](../NearlyEqualsTest.java) para muchos casos especiales
67
-
importantes, pero como puedes ver, utiliza cierta lógica no trivial. En particular,
68
-
tiene que utilizar una definición totalmente distinta del margen de error cuando
69
-
`a` o `b` son cero, porque la definición clásica del error relativo es inútil en
70
-
esos casos.
71
-
72
-
Hay algunos casos en los que el método de arriba todavía produce resultados inesperados
73
-
(concretamente, es mucho más estricto cuando un valor es casi cero que cuando es
74
-
exactamente cero), y algunas de esas pruebas para las que fue desarrollado probablemente
75
-
especifica un comportamiento que no es apropiado para algunas aplicaciones. Antes de
76
-
usarlo, ¡asegúrate de que es adecuado para tu aplicación!
77
-
78
-
Comparando valores de punto flotante como enteros
79
-
-------------------------------------------------
80
-
81
-
Hay una alternativa a aplicar toda esta complejidad conceptual a una tarea aparentemente
82
-
tan sencilla: en lugar de comparar `a` y `b` como [números
83
-
reales](http://es.wikipedia.org/wiki/N%C3%BAmero_real), podemos concebirlos como pasos
84
-
discretos y definir el margen de error como el número máximo de valores de punto flotante
85
-
posibles entre esos dos números.
86
-
87
-
Esto es conceptualmente muy evidente y fácil y tiene la ventaja de que escala
88
-
implícitamente el margen de error relativo con la magnitud de los valores.
89
-
Técnicamente es un poco más complejo, pero no mucho más de lo que puedas pensar,
90
-
porque los números de punto flotante del IEEE 754 están diseñados para mantener su orden cuando
91
-
sus secuencias de bits se interpretan como enteros.
92
-
93
-
Sin embargo, este método requiere que el lenguaje de programación soporte conversión
94
-
entre valores de punto flotante y secuencias de bits enteras. Lee el artículo en
95
-
inglés [Comparing floating-point numbers](/references/) para más detalles.
-25
content/errors/propagation.html
-25
content/errors/propagation.html
···
1
-
---
2
-
title: Propagación del error
3
-
description: Explicaciones sobre la propagación de errores en aritmética de punto flotante
4
-
---
5
-
6
-
Aunque los errores en [números de punto flotante](/formats/fp/) aislados son muy pequeños,
7
-
operaciones simples con ellos pueden tener problemas e incrementar el error del resultado
8
-
más de lo que se esperaría «sumando» los errores individuales.
9
-
10
-
En general:
11
-
12
-
* La multiplicación y la división son operaciones «seguras».
13
-
* La suma y la resta son peligrosas, porque cuando hay involucrados números de diferentes órdenes de magnitud, los dígitos del más pequeño se pierden.
14
-
* Esta pérdida de dígitos puede ser inevitable y benigna (cuando los dígitos perdidos son también insignificantes para el resultado final) o catastrófica (cuando la pérdida se amplifica y distorsiona el resultado fuertemente).
15
-
* Cuantas más operaciones se hagan (especialmente cuando forman parte de un algoritmo iterativo) más importante es considerar este problema.
16
-
* Un método de cálculo puede ser *estable* (tiende a reducir los errores de redondeo) o *inestable* (los errores de redondeo se amplifican). A menudo, hay soluciones estables e inestables a un problema.
17
-
18
-
Hay un área entera de las matemáticas (el [análisis
19
-
numérico](http://es.wikipedia.org/wiki/An%C3%A1lisis_num%C3%A9rico)) dedicada a estudiar la
20
-
estabilidad numérica de los algoritmos. Para hacer cálculos complejos utilizando números de punto
21
-
flotante, es absolutamente necesario tener ciertos conocimientos en esta materia.
22
-
23
-
Este artículo en inglés [What Every Computer Scientist Should Know About Floating-Point Arithmetic](/references/)
24
-
da una introducción detallada, y sirvió de inspiración para esta web, principalmente por el hecho
25
-
de que era demasiado minucioso y un poco intimidante para programadores sin una formación científica.
-62
content/errors/rounding.html
-62
content/errors/rounding.html
···
1
-
---
2
-
title: Errores de redondeo
3
-
description: Explicación de las razones de los errores de redondeo en aritmética de punto flotante, y de los métodos de redondeo
4
-
---
5
-
6
-
Como los [números de punto flotante](/formats/fp/) tienen un número de dígitos limitado,
7
-
no pueden representar todos los [números reales](http://es.wikipedia.org/wiki/N%C3%BAmero_real)
8
-
de forma precisa: cuando hay más dígitos de los que permite el formato, los que sobran se
9
-
omiten ─ el número se *redondea*. Hay tres razones por las que esto puede ser necesario:
10
-
11
-
* **Denominadores grandes**
12
-
En cualquier base, cuanto mayor es el denominador de una fracción (irreducible),
13
-
más dígitos se necesitan en notación posicional. Un denominador lo suficientemente
14
-
grande necesitará redondeo, no importa qué base o número de dígitos disponible
15
-
haya. Por ejemplo, 1/1000 no se puede representar de manera precisa en menos de
16
-
3 dígitos decimales, ni ningún múltiplo suyo (que no permita simplificar la
17
-
fracción).
18
-
* **Dígitos periódicos**
19
-
Cualquier fracción (irreducible) donde el denominador tenga un factor primo que
20
-
no esté en la base requiere un número infinito de dígitos que se repiten periódicamente
21
-
a partir de un cierto punto. Por ejemplo, en decimal 1/4, 3/5 y 8/20 son finitos, porque
22
-
2 y 5 son los factores primos de 10. Pero 1/3 no es finito, ni tampoco 2/3 o 1/7 o 5/6,
23
-
porque 3 y 7 no son factores primos de 10. Las fracciones con un factor primo de 5 en el
24
-
denominador pueden ser finitas en base 10, pero no en [base 2](/formats/binary/) ─ la
25
-
mayor fuente de confusión para los principiantes en los números de punto flotante.
26
-
* **Números no racionales**
27
-
Los números irracionales no se pueden representar como una fracción regular, y en notación
28
-
posicional (no importa en qué base) requieren un número infinito de dígitos no periódicos.
29
-
30
-
Métodos de redondeo
31
-
-------------------
32
-
33
-
Hay varias formas diferentes de redondear, y esto puede ser muy importante en programación,
34
-
porque el redondeo puede causar problemas en algunos contextos que se pueden solucionar
35
-
utilizando un método de redondeo distinto. Los más usuales son:
36
-
37
-
* **Redondeo hacia el cero** o **truncamiento** - simplemente se omiten los dígitos sobrantes. Es el
38
-
método más sencillo, pero introduce más error del necesario y un sesgo hacia el
39
-
cero cuando se manejan sobre todo números positivos o sobre todo negativos.
40
-
* **Redondeo al alza** - si la fracción truncada es mayor o igual que la mitad de la base,
41
-
se incrementa el último dígito. Este método es el que se enseña en el colegio normalmente
42
-
y es el que usa la mayoría de la gente. Minimiza el error, pero también introduce un sesgo
43
-
(lejos del cero).
44
-
* **Redondeo mitad al par** también conocido como el **redondeo del banquero** - si la
45
-
fracción truncada es mayor que la mitad de la base, se incrementa el último dígito.
46
-
Si es igual a la mitad de la base, se incrementa solamente si el resultado es par. Esto
47
-
minimiza el error y el sesgo, y por eso se prefiere en contabilidad. Es el método por
48
-
defecto en el estándar IEEE 754.
49
-
50
-
Ejemplos en base 10:
51
-
52
-
| | Hacia el cero | Al alza | La mitad al par |
53
-
|------|--------------|---------------------|--------------|
54
-
| 1.4 | 1 | 1 | 1 |
55
-
| 1.5 | 1 | 2 | 2 |
56
-
| -1.6 | -1 | -2 | -2 |
57
-
| 2.6 | 2 | 3 | 3 |
58
-
| 2.5 | 2 | 3 | 2 |
59
-
| -2.4 | -2 | -2 | -2 |
60
-
61
-
Se pueden encontrar más [métodos de redondeo (inglés)](http://en.wikipedia.org/wiki/Rounding)
62
-
en la Wikipedia inglesa.
content/favicon.ico
content/favicon.ico
This is a binary file and will not be displayed.
-96
content/formats/binary.html
-96
content/formats/binary.html
···
1
-
---
2
-
title: Fracciones binarias
3
-
description: Explicación detallada de cómo funcionan las fracciones binarias, qué problemas causan y por qué aun así se utilizan
4
-
---
5
-
6
-
Cómo funcionan
7
-
--------------
8
-
9
-
Como programador, deberías estar familiarizado con el conceptro de enteros binarios,
10
-
esto es, la representación de números enteros como series de bits:
11
-
12
-
<table>
13
-
<tr><th colspan="9">Decimal (<span class="num_base">base 10</span>)</th><th> </th><th colspan="17">Binario (<span class="num_base">base 2</span>)</th></tr>
14
-
<tr class="base_example">
15
-
<td class="digit">1</td><td>⋅</td><td class="num_base">10<sup>1</sup></td><td>+</td>
16
-
<td class="digit">3</td><td>⋅</td><td class="num_base">10<sup>0</sup></td><td>=</td>
17
-
<td class="digit">13<sub class="num_base">10</sub></td><td class="separator">=</td>
18
-
<td class="digit">1101<sub class="num_base">2</sub></td><td>=</td>
19
-
<td class="digit">1</td><td>⋅</td><td class="num_base">2<sup>3</sup></td><td>+</td>
20
-
<td class="digit">1</td><td>⋅</td><td class="num_base">2<sup>2</sup></td><td>+</td>
21
-
<td class="digit">0</td><td>⋅</td><td class="num_base">2<sup>1</sup></td><td>+</td>
22
-
<td class="digit">1</td><td>⋅</td><td class="num_base">2<sup>0</sup></td>
23
-
</tr><tr class="base_example">
24
-
<td class="digit">1</td><td>⋅</td><td>10</td><td>+</td>
25
-
<td class="digit">3</td><td>⋅</td><td>1 </td><td>=</td>
26
-
<td class="digit">13<sub class="num_base">10</sub></td><td class="separator">=</td>
27
-
<td class="digit">1101<sub class="num_base">2</sub></td><td>=</td>
28
-
<td class="digit">1</td><td>⋅</td><td>8</td><td>+</td>
29
-
<td class="digit">1</td><td>⋅</td><td>4</td><td>+</td>
30
-
<td class="digit">0</td><td>⋅</td><td>2</td><td>+</td>
31
-
<td class="digit">1</td><td>⋅</td><td>1</td>
32
-
</tr></table>
33
-
34
-
Así almacenan números internamente los ordenadores. Y para números racionales en [notación
35
-
posicional](http://es.wikipedia.org/wiki/Notaci%C3%B3n_posicional), hacen lo mismo:
36
-
37
-
<table>
38
-
<tr><th colspan="13">Decimal (<span class="num_base">base 10</span>)</th><th> </th><th colspan="13">Binario (<span class="num_base">base 2</span>)</th></tr>
39
-
<tr class="base_example">
40
-
<td class="digit">6</td><td>⋅</td><td class="num_base">10<sup>-1</sup></td><td>+</td>
41
-
<td class="digit">2</td><td>⋅</td><td class="num_base">10<sup>-2</sup></td><td>+</td>
42
-
<td class="digit">5</td><td>⋅</td><td class="num_base">10<sup>-3</sup></td><td>=</td>
43
-
<td class="digit">0.625<sub class="num_base">10</sub></td><td class="separator">=</td>
44
-
<td class="digit">0.101<sub class="num_base">2</sub></td><td>=</td>
45
-
<td class="digit">1</td><td>⋅</td><td class="num_base">2<sup>-1</sup></td><td>+</td>
46
-
<td class="digit">0</td><td>⋅</td><td class="num_base">2<sup>-2</sup></td><td>+</td>
47
-
<td class="digit">1</td><td>⋅</td><td class="num_base">2<sup>-3</sup></td>
48
-
</tr><tr class="base_example">
49
-
<td class="digit">6</td><td>⋅</td><td>1/10</td><td>+</td>
50
-
<td class="digit">2</td><td>⋅</td><td>1/100</td><td>+</td>
51
-
<td class="digit">5</td><td>⋅</td><td>1/1000</td><td>=</td>
52
-
<td class="digit">0.625<sub class="num_base">10</sub></td><td class="separator">=</td>
53
-
<td class="digit">0.101<sub class="num_base">2</sub></td><td>=</td>
54
-
<td class="digit">1</td><td>⋅</td><td>1/2</td><td>+</td>
55
-
<td class="digit">0</td><td>⋅</td><td>1/4</td><td>+</td>
56
-
<td class="digit">1</td><td>⋅</td><td>1/8</td>
57
-
</tr></table>
58
-
59
-
Problemas
60
-
---------
61
-
62
-
Aunque funcionan igual en principio, las fracciones binarias son diferentes a las fracciones decimales
63
-
en qué números que se pueden representar con precisión dado un número de dígitos, y por tanto también
64
-
en qué números resultan en [errores de redondeo](/errors/rounding/): concretamente, en binario solo
65
-
se pueden representar como una fracción finita aquellos números en los que el denominador es una
66
-
potencia de 2. Por desgracia, esto no incluye la mayoría de los números que pueden ser representados
67
-
como una fracción finita en base 10, como 0.1.
68
-
69
-
| Fracción | Base | Notación posicional | Redondeado a 4 dígitos | Valor redondeado como fracción | Error de redondeo |
70
-
|-|-|-|-|
71
-
| 1/10 | 10 | 0.1 | 0.1 | 1/10 | 0 |
72
-
| 1/3 | 10 | 0.<span class="over">3</span> | 0.3333 | 3333/10000 | 1/30000 |
73
-
| 1/2 | 2 | 0.1 | 0.1 | 1/2 | 0 |
74
-
| 1/10 | 2 | 0.0<span class="over">0011</span> | 0.0001 | 1/16 | 3/80 |
75
-
76
-
Y así es como *ya* obtienes un error de redondeo *con solamente escribir* un número como 0.1 y
77
-
pasarlo por tu intérprete o compilador. No es tan grande como 3/80 y puede ser invisible porque
78
-
los ordenadores cortan después de 23 o 52 dígitos binarios en vez de 4. Pero el error está ahí
79
-
y *causará* problemas eventualmente si simplemente lo ignoras.
80
-
81
-
82
-
¿Por qué usar binario?
83
-
----------------------
84
-
85
-
En el nivel más inferior, los ordenadores están basados en miles de millones de elementos eléctricos
86
-
que tienen dos estados (normalmente baja y alta tensión). Interpretándolos como 0 y 1, es muy fácil
87
-
construir circuitos para almacenar números binarios y hacer cálculos con ellos.
88
-
89
-
Mientras que es posible simular el comportamiento de los números decimales con circuitos binarios
90
-
también, es menos eficiente. Si los ordenadores usaran números decimales internamente, tendrían
91
-
menos memoria y serían más lentos con el mismo nivel de tecnología.
92
-
93
-
Puesto que la diferencia de comportamiento entre números binarios y decimales no es importante para
94
-
la mayor parte de las aplicaciones, la elección lógica es construir ordenadores basados en el sistema
95
-
binario y vivir con el hecho de que hay que poner un poco más de atención y esfuerzo para las aplicaciones
96
-
que tienen que funcionar [como un número decimal](/formats/exact/).
-59
content/formats/exact.html
-59
content/formats/exact.html
···
1
-
---
2
-
title: Tipos exactos
3
-
description: Descripción de varios tipos de datos que pueden ser más exactos que los números de punto flotante
4
-
---
5
-
6
-
Aunque los números de [punto flotante](/formats/fp/) [binarios](/formats/binary/)
7
-
son mejores para que los ordenadores trabajen con ellos, y lo bastante buenos para
8
-
los humanos, a veces simplemente no son apropiados. En ocasiones los números de
9
-
verdad tienen que sumarse bien hasta el último bit, y no hay excusas técnicas
10
-
aceptables ─ normalmente cuando los cálculos involucran dinero.
11
-
12
-
Desgraciadamente, no hay un estándar dominante equivalente al IEEE 754 para esto
13
-
(la versión del 2008 añadió tipos decimales, pero es demasiado reciente para
14
-
tener una adopción generalizada).
15
-
16
-
Cada lenguaje o plataforma tiene su propia solución, y a veces más de una. Para
17
-
más detalles, puedes ver las cheat sheets de los lenguajes.
18
-
19
-
Hay al menos tres clases diferentes de estos tipos de datos:
20
-
21
-
Decimal de precisión limitada
22
-
-----------------------------
23
-
24
-
Básicamente lo mismo que el punto flotante binario del IEEE 754, excepto porque
25
-
el exponente se interpreta en base 10. Como resultado, no hay [errores de
26
-
redondeo](/errors/rounding/) inesperados. Además, este tipo de formato es
27
-
relativamente compacto y rápido, pero normalmente más lento que los formatos binarios.
28
-
29
-
Decimal de precisión arbitraria
30
-
-------------------------------
31
-
32
-
A veces llamado «bignum», es similar a un tipo de precisión limitada, pero tiene
33
-
la habilidad de incrementar la longitud de la mantisa (a veces también la del exponente)
34
-
cuando es necesario. La contrapartida es que hay un coste (en memoria y velocidad)
35
-
por soportar esta flexibilidad, y además cuanto más larga es la mantisa más memoria
36
-
se necesita y más lentos se vuelven los cálculos.
37
-
38
-
Puede ser muy tentador decir «mi operación es importante, así que necesito toda la
39
-
precisión que sea posible», pero en la práctica la importancia real de la precisión
40
-
en la diezmilésima cifra decimal se desvanece en comparación con la penalización en
41
-
la eficiencia requerida para soportarlo.
42
-
43
-
Cálculo simbólico
44
-
-----------------
45
-
46
-
El «santo grial» de las operaciones exactas. Se consigue escribiendo un programa que
47
-
realmente conozca todas las reglas matemáticas y represente los datos como *símbolos*
48
-
en lugar de números redondeados e imprecisos. Por ejemplo:
49
-
50
-
* 1/3 es realmente la fracción «uno dividido entre tres».
51
-
* La raíz cuadrada de 2 es realmente el número que, multiplicado por sí mismo, da *exactamente* 2.
52
-
* Incluso los [números trascendentes](http://es.wikipedia.org/wiki/N%C3%BAmero_trascendente) como **e** y **π** son conocidos, junto con sus propiedades, de tal forma que e<sup>iπ</sup> es *exactamente* igual a -1.
53
-
54
-
Sin embargo, estos sistemas de cálculo simbólico son complejos, lentos y requieren
55
-
unos conocimientos matemáticos significativos para ser usados. Son herramientas
56
-
inestimables para los matemáticos, pero no son apropiadas para las tareas diarias en
57
-
programación. E incluso la mayoría de los matemáticas trabajan en problemas donde
58
-
soluciones numéricas imprecisas son mejores porque no se conoce solución en forma
59
-
cerrada.
-70
content/formats/fp.html
-70
content/formats/fp.html
···
1
-
---
2
-
title: Números de punto flotante
3
-
description: Explicación de cómo funcionan los números de punto flotante y para qué son útiles
4
-
---
5
-
6
-
Por qué son necesarios los números de punto flotante
7
-
----------------------------------------------------
8
-
9
-
Como la memoria de los ordenadores es limitada, no puedes almacenar números
10
-
con precisión infinita, no importa si usas [fracciones binarias](/formats/binary/) o
11
-
decimales: en algún momento tienes que cortar. Pero ¿cuánta precisión se necesita?
12
-
¿Y *dónde* se necesita? ¿Cuántos dígitos enteros y cuántos fraccionarios?
13
-
14
-
* Para un ingeniero construyendo una autopista, no importa si tiene 10 metros o 10.0001 metros de ancho ─ posiblemente ni siquiera sus mediciones eran así de precisas.
15
-
* Para alguien diseñando un microchip, 0.0001 metros (la décima parte de un milímetro) es una diferencia *enorme* ─ pero nunca tendrá que manejar distancias mayores de 0.1 metros.
16
-
* Un físico necesita usar la [velocidad de la luz](http://es.wikipedia.org/wiki/Velocidad_de_la_luz) (más o menos 300000000) y la [constante de gravitación universal](http://es.wikipedia.org/wiki/Constante_de_gravitaci%C3%B3n_universal) (más o menos 0.0000000000667) juntas en el mismo cálculo.
17
-
18
-
Para satisfacer al ingeniero y al diseñador de circuitos integrados, el formato
19
-
tiene que ser preciso para números de órdenes de magnitud muy diferentes. Sin
20
-
embargo, solo se necesita precisión *relativa*. Para satisfacer al físico, debe
21
-
ser posible hacer cálculos que involucren números de órdenes muy dispares.
22
-
23
-
Básicamente, tener un número fijo de dígitos enteros y fraccionarios no es útil ─ y la solución es un formato con un *punto flotante*.
24
-
25
-
Cómo funcionan los números de punto flotante
26
-
--------------------------------------------
27
-
28
-
La idea es descomponer el número en dos partes:
29
-
30
-
* Una **mantisa** (también llamada coeficiente o significando) que contiene los dígitos del número. Mantisas negativas representan números negativos.
31
-
* Un **exponente** que indica dónde se coloca el punto decimal (o binario) en relación al inicio de la mantisa. Exponentes negativos representan números menores que uno.
32
-
33
-
Este formato cumple todos los requisitos:
34
-
35
-
* Puede representar números de órdenes de magnitud enormemente dispares (limitado por la longitud del exponente).
36
-
* Proporciona la misma precisión relativa para todos los órdenes (limitado por la longitud de la mantisa).
37
-
* Permite cálculos entre magnitudes: multiplicar un número muy grande y uno muy pequeño conserva la precisión de ambos en el resultado.
38
-
39
-
Los números de coma flotante decimales normalmente se expresan en
40
-
[notación científica](http://es.wikipedia.org/wiki/Notaci%C3%B3n_cient%C3%ADfica) con un
41
-
punto explícito siempre entre el primer y el segundo dígitos. El exponente o bien
42
-
se escribe explícitamente incluyendo la base, o se usa una **e** para
43
-
separarlo de la mantisa.
44
-
45
-
| Mantisa | Exponente | Notación científica | Valor en punto fijo |
46
-
|---------|-----------|---------------------|---------------------|
47
-
| 1.5 | 4 | 1.5 ⋅ 10<sup>4</sup> | 15000 |
48
-
| -2.001 | 2 | -2.001 ⋅ 10<sup>2</sup> | -200.1 |
49
-
| 5 | -3 | 5 ⋅ 10<sup>-3</sup> | 0.005 |
50
-
| 6.667 | -11 | 6.667e-11 | 0.0000000000667 |
51
-
52
-
El estándar
53
-
-----------
54
-
55
-
Casi todo el hardware y lenguajes de programación utilizan números de punto flotante en los mismos
56
-
formatos binarios, que están definidos en el estándar [IEEE 754](http://es.wikipedia.org/wiki/IEEE_coma_flotante).
57
-
Los formatos más comunes son de 32 o 64 bits de longitud total:
58
-
59
-
| Formato | Bits totales | Bits significativos | Bits del exponente | Número más pequeño | Número más grande |
60
-
|---------|--------------|---------------------|--------------------|--------------------|-------------------|
61
-
| Precisión sencilla | 32 | 23 + 1 signo | 8 | ~1.2 ⋅ 10<sup>-38</sup> | ~3.4 ⋅ 10<sup>38</sup>|
62
-
| Precisión doble | 64 | 52 + 1 signo | 11 | ~5.0 ⋅ 10<sup>-324</sup> | ~1.8 ⋅ 10<sup>308</sup> |
63
-
64
-
Hay algunas pecularidades:
65
-
66
-
* La *secuencia de bits* es primero el bit del signo, seguido del exponente y finalmente los bits significativos.
67
-
* El exponente no tiene signo; en su lugar se le resta un **desplazamiento** (127 para sencilla y 1023 para doble precisión). Esto, junto con la secuencia de bits, permite que los números de punto flotante se puedan comparar y ordenar correctamente incluso cuando se interpretan como enteros.
68
-
* Se asume que el bit más significativo de la mantisa es 1 y se omite, excepto para casos especiales.
69
-
* Hay valores diferentes para **cero positivo y cero negativo**. Estos difieren en el bit del signo, mientras que todos los demás son 0. Deben ser considerados iguales aunque sus secuencias de bits sean diferentes.
70
-
* Hay valores especiales **no numéricos** (NaN, «not a number» en inglés) en los que el exponente es todo unos y la mantisa *no* es todo ceros. Estos valores representan el resultado de algunas operaciones indefinidas (como multiplicar 0 por infinito, operaciones que involucren NaN, o casos específicos). Incluso valores NaN con idéntica secuencia de bits *no* deben ser considerados iguales.
-20
content/formats/integer.html
-20
content/formats/integer.html
···
1
-
---
2
-
title: Sobre usar enteros
3
-
description: Explicación de por qué usar enteros para evitar los problemas del punto flotante para, por ejemplo, representar céntimos no es una buena solución
4
-
---
5
-
6
-
Mientras que los tipos enteros son normalmente binarios y por definición no soportan
7
-
fracciones, son exactos (no hay [errores de redondeo](/errors/rounding/) cuando se
8
-
convierten desde enteros decimales) y se pueden usar como una suerte de [tipo
9
-
decimal](/formats/exact/) «casero» eligiendo implícitamente un punto decimal fijo
10
-
de tal forma que la unidad más pequeña con la que estés trabajando se pueda representar
11
-
por el entero 1. En la práctica, esto normalmente se expresa como: **«Para manejar
12
-
dinero, almacena y calcula todo en céntimos y solo formatea el resultado»**.
13
-
14
-
Esto funciona, pero tiene algunas **desventajas importantes**:
15
-
16
-
* Supone más trabajo (y más oportunidades de introducir bugs) hacerlo bien, especialmente en lo que concierne a los [métodos de redondeo](/errors/rounding/).
17
-
* Los enteros tienen precisión completa, pero en un rango muy limitado, y cuando se desbordan, normalmente «dan la vuelta» silenciosamente: el mayor entero más 1 da cero (para enteros sin signo) o el valor negativo más grande en valor absoluto (para enteros con signo). Este es el peor comportamiento posible cuando se trabaja con dinero por razones obvias.
18
-
* El punto decimal implícito es difícil de cambiar y enormemente inflexible: si almacenas los dólares como céntimos, es simplemente imposible soportar el [dinar bareiní](http://es.wikipedia.org/wiki/Dinar_barein%C3%AD)(1 dinar = 1000 fils) al mismo tiempo. Tendrías que almacenar la posición del punto decimal con los datos ─ el primer paso para implementar tu propio formato de [punto flotante](/formats/fp/) decimal de precisión limitada (lleno de fallos y no estándar).
19
-
20
-
Resumen: **no se recomienda usar enteros**. Haz esto solamente si no hay otra [alternativa mejor](/formats/exact/).
-43
content/index.html
-43
content/index.html
···
1
-
---
2
-
title: Lo que todo programador debería saber sobre aritmética de punto flotante
3
-
description: Pretende dar respuestas cortas y sencillas a las preguntas recurrentes de programadores principiantes sobre números de punto flotante que «no se suman correctamente», e información más detallada sobre cómo funcionan los números decimales del IEEE 754, cuándo y cómo usarlos correctamente, y qué usar en su lugar cuando no son apropiados
4
-
verification: True
5
-
---
6
-
7
-
o
8
-
-
9
-
10
-
¿Por qué mis números no se suman bien?
11
-
======================================
12
-
13
-
O sea que has escrito algún código absurdamente simple, como por ejemplo:
14
-
15
-
0.1 + 0.2
16
-
17
-
y has obtenido un resultado totalmente inesperado:
18
-
19
-
0.30000000000000004
20
-
21
-
Tal vez pediste ayuda en algún foro y te mandaron a un [artículo largo con un montón de fórmulas](http://download.oracle.com/docs/cd/E19957-01/806-3568/ncg_goldberg.html) que no parecía ser de ayuda.
22
-
23
-
Bueno, este sitio está aquí para:
24
-
25
-
* Explicar de manera concisa por qué obtuviste ese resultado inesperado
26
-
* Decirte cómo lidiar con este problema
27
-
* Si te interesa, dar explicaciones detalladas de por qué los números de punto flotante tienen que funcionar así y qué otros problemas pueden surgir
28
-
29
-
Deberías ir a la sección de [Respuestas básicas](/basic/) primero ─ ¡pero no termines ahí!
30
-
31
-
### Sobre la notación y la nomenclatura
32
-
33
-
Aunque tanto el punto como la coma son válidas como marcas decimales según el
34
-
Sistema Internacional y la norma ISO<sup>1</sup>, las Academias de la Lengua recomiendan el
35
-
punto<sup>2</sup>. Esto facilita las cosas,
36
-
porque se converge así con la notación anglosajona que es la que se utiliza en la mayoría de
37
-
lenguajes de programación. En este sitio se ha optado por la denominación «punto
38
-
flotante» en lugar de «coma flotante», puesto que la Fundación del Español Urgente
39
-
(<a href="http://www.fundeu.es/">Fundéu BBVA</a>) especificó en una consulta
40
-
que debe haber correspondencia con el criterio adoptado para la marca decimal.
41
-
42
-
1. Bezos, Javier. *La marca decimal* <<a href="http://www.tex-tipografia.com/marca_decimal.html">http://www.tex-tipografia.com/marca_decimal.html</a>>
43
-
2. Bezos, Javier. *Las notaciones científicas en la Ortografía académica* <<a href="http://www.tex-tipografia.com/ortografia_notaciones.html">http://www.tex-tipografia.com/ortografia_notaciones.html</a>>
-38
content/languages/csharp.html
-38
content/languages/csharp.html
···
1
-
---
2
-
title: Cheat sheet de punto flotante para C#
3
-
description: Trucos para usar punto flotante y números decimales en C#
4
-
---
5
-
6
-
Tipos de punto flotante
7
-
-----------------------
8
-
9
-
C# tiene tipos de precisión sencilla y doble del [IEEE 754](/formats/fp/)
10
-
soportados por palabras clave:
11
-
12
-
float f = 0.1f; // punto flotante de 32 bits, nótese el sufijo f
13
-
double d = 0.1d; // punto flotante de 64 bits, sufijo opcional
14
-
15
-
Tipos decimales
16
-
---------------
17
-
18
-
C# tiene un tipo decimal de 128 bit de [precisión limitada](/formats/exact/)
19
-
denotado con la palabra clave `decimal`:
20
-
21
-
decimal myMoney = 300.1m; // Nótese el sufijo m en el literal
22
-
23
-
Cómo redondear
24
-
--------------
25
-
26
-
El método `Math.Round()` funciona con los tipos `double` y `decimal`,
27
-
y permite especificar el [método de redondeo](/errors/rounding/):
28
-
29
-
Math.Round(1.25m, 1, MidpointRounding.AwayFromZero); // Devuelve 1.3
30
-
31
-
Recursos
32
-
--------
33
-
34
-
* [C# Reference](http://msdn.microsoft.com/en-us/library/618ayhy6%28v=VS.80%29.aspx)
35
-
* [float type](http://msdn.microsoft.com/en-us/library/b1e65aza%28v=VS.80%29.aspx)
36
-
* [double type](http://msdn.microsoft.com/en-us/library/678hzkk9%28v=VS.80%29.aspx)
37
-
* [decimal type](http://msdn.microsoft.com/en-us/library/364x0z75%28v=VS.80%29.aspx)
38
-
* [Math.Round()](http://msdn.microsoft.com/en-US/library/system.math.round%28v=VS.80%29.aspx)
-62
content/languages/java.html
-62
content/languages/java.html
···
1
-
---
2
-
title: Cheat sheet de punto flotante para Java
3
-
description: Trucos para usar punto flotante y números decimales en Java
4
-
---
5
-
6
-
Tipos de punto flotante
7
-
-----------------------
8
-
9
-
Java tiene tipos de precisión sencilla y doble del [IEEE 754](/formats/fp/) soportados
10
-
por palabras clave:
11
-
12
-
float f = 0.1f; // punto flotante de 32 bits, nótese el sufijo f
13
-
double d = 0.1d; // punto flotante de 64 bits, sufijo opcional
14
-
15
-
La palabra clave `strictfp` en las clases, interfaces y métodos fuerza también
16
-
a que todos los resultados intermedios de cálculos en punto flotante sean
17
-
valores IEEE 754, garantizando resultados idénticos en todas las plataformas.
18
-
Sin esa palabra clave, las implementaciones pueden usar un rango extendido para
19
-
el exponente, llevando a resultados más precisos y ejecuciones más rápidas
20
-
en bastantes CPUs.
21
-
22
-
Tipos decimales
23
-
---------------
24
-
25
-
Java tiene un tipo decimal de [precisión arbitraria](/formats/exact/) llamado
26
-
`java.math.BigDecimal`, que también permite elegir el [método de redondeo](/errors/rounding/).
27
-
28
-
BigDecimal a = new BigDecimal("0.1");
29
-
BigDecimal b = new BigDecimal("0.2");
30
-
BigDecimal c = a.add(b); // Devuelve un BigDecimal que representa exactamente 0.3
31
-
32
-
Cómo redondear
33
-
--------------
34
-
35
-
Para obtener una cadena:
36
-
37
-
String.format("%.2f", 1.2399) // Devuelve "1.24"
38
-
String.format("%.3f", 1.2399) // Devuelve "1.240"
39
-
String.format("%.2f", 1.2) // Devuelve "1.20"
40
-
41
-
Para imprimir por la salida estándar (o cualquier `PrintStream`):
42
-
43
-
System.out.printf("%.2f", 1.2399) // Misma sintaxis que String.format()
44
-
45
-
Si no quieres ceros a la derecha:
46
-
47
-
new DecimalFormat("0.00").format(1.2)// Devuelve "1.20"
48
-
new DecimalFormat("0.##").format(1.2)// Devuelve "1.2"
49
-
50
-
Si necesitas un [método de redondeo](/errors/rounding/) específico:
51
-
52
-
new BigDecimal("1.25").setScale(1, RoundingMode.HALF_EVEN); // Devuelve 1.2
53
-
54
-
Recursos
55
-
--------
56
-
57
-
* [Java Language Specification](http://java.sun.com/docs/books/jls/third_edition/html/j3TOC.html)
58
-
* [Floating-Point Types, Formats, and Values](http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3)
59
-
* [Java Standard API](http://java.sun.com/javase/6/docs/api/)
60
-
* [BigDecimal](http://download.oracle.com/javase/6/docs/api/java/math/BigDecimal.html)
61
-
* [DecimalFormat](http://download.oracle.com/javase/6/docs/api/java/text/DecimalFormat.html)
62
-
* [String.format()](http://download.oracle.com/javase/6/docs/api/java/lang/String.html#format(java.lang.String,%20java.lang.Object...))
-44
content/languages/javascript.html
-44
content/languages/javascript.html
···
1
-
---
2
-
title: Cheat sheet de punto flotante para JavaScript
3
-
description: Trucos para usar punto flotante y números decimales en JavaScript
4
-
---
5
-
6
-
Tipos de punto flotante
7
-
-----------------------
8
-
9
-
JavaScript tiene tipado dinámico y a veces convertirá implícitamente entre cadenas
10
-
y números de punto flotante (que son valores IEEE de 64 bits). Para forzar una variable
11
-
a punto flotante, utiliza la función `parseFloat()`.
12
-
13
-
var num = parseFloat("3.5");
14
-
15
-
Tipos decimales
16
-
---------------
17
-
18
-
El mejor tipo decimal para JavaScript parece ser una migración de la clase de
19
-
[Java](/languages/java/) `BigDecimal`, que también soporta [métodos de redondeo](/errors/rounding/):
20
-
21
-
var a = new BigDecimal("0.01");
22
-
var b = new BigDecimal("0.02");
23
-
var c = a.add(b); // 0.03
24
-
var d = c.setScale(1, BigDecimal.prototype.ROUND_HALF_UP);
25
-
26
-
Cómo redondear
27
-
--------------
28
-
29
-
var num = 5.123456;
30
-
num.toPrecision(1) //Devuelve 5 como una cadena
31
-
num.toPrecision(2) //Devuelve 5.1 como una cadena
32
-
num.toPrecision(4) //Devuelve 5.123 como una cadena
33
-
34
-
Utilizando un método de redondeo específico:
35
-
36
-
new BigDecimal("1.25").setScale(1, BigDecimal.prototype.ROUND_HALF_UP);
37
-
38
-
Recursos
39
-
--------
40
-
41
-
* [BigDecimal for JavaScript](https://github.com/dtrebbien/BigDecimal.js)
42
-
* [Core JavaScript Reference](https://developer.mozilla.org/en/JavaScript/Reference)
43
-
* [parseFloat()](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/parseFloat)
44
-
* [toPrecision()](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Number/toPrecision)
-72
content/languages/perl.html
-72
content/languages/perl.html
···
1
-
---
2
-
title: Cheat sheet de punto flotante para Perl
3
-
description: Trucos para usar punto flotante y números decimales en Perl
4
-
---
5
-
6
-
Tipos de punto flotante
7
-
-----------------------
8
-
9
-
Perl soporta números de punto flotante nativos de la plataforma como valores
10
-
escalares; en la práctica esto significa precisión doble del [IEEE 754](/formats/fp/).
11
-
12
-
Tipos exactos
13
-
-------------
14
-
15
-
Perl también puede almacenar números decimales como cadenas, pero los operadores
16
-
aritméticos integrados los convertirán a enteros o a valores de punto flotante
17
-
para realizar la operación.
18
-
19
-
La extensión `Math::BigFloat` proporciona un [tipo decimal](/formats/exact/) de
20
-
precisión arbitraria:
21
-
22
-
use Math::BigFloat ':constant'
23
-
my $f = 0.1 + 0.2; # Devuelve exactamente 0.3
24
-
25
-
La extensión `Number::Fraction` proporciona un tipo de datos fraccionario que
26
-
sobrecarga los operadores con aritmética [simbólica](/formats/exact/) para fracciones:
27
-
28
-
use Number::Fraction ':constants';
29
-
my $f = '1/2' - '1/3'; # Devuelve 1/6
30
-
31
-
La extensión `Math::BigRat` proporciona funcionalidad similar. Su ventaja es
32
-
compatibilidad con las extensiones `Math::BigInt` y `Math::BigFloat`, pero
33
-
no parece soportar literales fraccionarios.
34
-
35
-
Cómo redondear
36
-
--------------
37
-
38
-
Para obtener una cadena:
39
-
40
-
$result = sprintf("%.2f", 1.2345); # Devuelve 1.23
41
-
42
-
Para formatear la salida:
43
-
44
-
printf("%.2f", 1.2); # Imprime 1.20
45
-
46
-
Ten en cuenta que esto utiliza implícitamente [mitad al par](/errors/rounding/).
47
-
La variable `$#` contiene el formato por defecto para imprimir números, pero
48
-
su uso se considera obsoleto.
49
-
50
-
La extensión `Math::Round` proporciona varias funciones para redondear valores
51
-
de punto flotante:
52
-
53
-
use Math::Round qw(:all);
54
-
$result = nearest(.1, 4.567) # Imprime 4.6
55
-
$result = nearest(.01, 4.567) # Imprime 4.57
56
-
57
-
La extensión `Math::BigFloat` también soporta varios [métodos de redondeo](/errors/rounding/):
58
-
59
-
use Math::BigFloat;
60
-
my $n = Math::BigFloat->new(123.455);
61
-
my $f1 = $n->round('','-2','common'); # Devuelve 123.46
62
-
my $f2 = $n->round('','-2','zero'); # Devuelve 123.45
63
-
64
-
Recursos
65
-
--------
66
-
67
-
* [Semantics of numbers and numeric operations in Perl](http://perldoc.perl.org/perlnumber.html)
68
-
* [sprintf function](http://perldoc.perl.org/functions/sprintf.html)
69
-
* [Math::Round extension](http://search.cpan.org/dist/Math-Round/Round.pm)
70
-
* [Number::Fraction extension](http://search.cpan.org/~davecross/Number-Fraction-1.13/lib/Number/Fraction.pm)
71
-
* [Math::BigRat extension](http://search.cpan.org/~flora/Math-BigRat-0.26/lib/Math/BigRat.pm)
72
-
* [Math::BigFloat extension](http://search.cpan.org/~flora/Math-BigInt-1.95/lib/Math/BigFloat.pm)
-40
content/languages/php.html
-40
content/languages/php.html
···
1
-
---
2
-
title: Cheat sheet de punto flotante para PHP
3
-
description: Trucos para usar punto flotante y números decimales en PHP
4
-
---
5
-
6
-
Tipos de punto flotante
7
-
-----------------------
8
-
9
-
PHP tiene tipado dinámico y a veces convertirá implícitamente entre cadenas y
10
-
números de punto flotante (que son dependientes de la plataforma, pero normalmente
11
-
valores IEEE de 64 bits). Para forzar un valor a punto flotante, evalúalo en un
12
-
contexto numérico:
13
-
14
-
$foo = 0 + "10.5";
15
-
16
-
Tipos decimales
17
-
---------------
18
-
19
-
La extensión BCMath (Binary Calculator) implementa aritmética de [precisión
20
-
arbitraria](/formats/exact/) decimal:
21
-
22
-
$a = '0.1';
23
-
$b = '0.2';
24
-
echo bcadd($a, $b); // Imprime 0.3
25
-
26
-
Cómo redondear
27
-
--------------
28
-
29
-
Redondear se puede hacer con la función `number_format()`:
30
-
31
-
$number = 4.123;
32
-
echo number_format($number, 2); // Imprime 4.12
33
-
34
-
Recursos
35
-
--------
36
-
37
-
* [PHP manual](http://www.php.net/manual/en/index.php)
38
-
* [Floating point types](http://www.php.net/manual/en/language.types.float.php)
39
-
* [BC Math extension](http://de3.php.net/manual/en/ref.bc.php)
40
-
* [number_format()](http://de3.php.net/manual/en/function.number-format.php)
-53
content/languages/python.html
-53
content/languages/python.html
···
1
-
---
2
-
title: Cheat sheet de punto flotante para Python
3
-
description: Trucos para usar punto flotante y números decimales en Python
4
-
---
5
-
6
-
Tipos de punto flotante
7
-
-----------------------
8
-
9
-
Casi todas las plataformas asocian los `float` de Python a números de punto
10
-
flotante de doble precisión del [IEEE 754](/formats/fp/).
11
-
12
-
f = 0.1
13
-
14
-
Tipos decimales
15
-
---------------
16
-
17
-
Python tiene un tipo de [precisión arbitraria](/formats/exact/) decimal llamado
18
-
`Decimal` en el módulo `decimal`, que también permite elegir el [método de
19
-
redondeo](/errors/rounding/).
20
-
21
-
a = Decimal('0.1')
22
-
b = Decimal('0.2')
23
-
c = a + b # Devuelve un Decimal que representa exactamente 0.3
24
-
25
-
Cómo redondear
26
-
--------------
27
-
28
-
Para obtener una cadena:
29
-
30
-
"{:.2f}".format(1.2399) # Devuelve "1.24"
31
-
"{:.3f}".format(1.2399) # Devuelve "1.240"
32
-
"{:.2f}".format(1.2) # Devuelve "1.20"
33
-
34
-
Para imprimir por la salida estándar (Python 2.x):
35
-
36
-
print "{:.2f}".format(1.2399)
37
-
38
-
y en Python 3.x:
39
-
40
-
print("{:.2f}".format(1.2399))
41
-
42
-
[Métodos de redondeo](/errors/rounding/) específicos y otros parámetros se pueden
43
-
definir en un objeto `Context`:
44
-
45
-
getcontext().prec = 7
46
-
47
-
Recursos
48
-
--------
49
-
50
-
* [Floating Point Arithmetic: Issues and Limitations](http://docs.python.org/tutorial/floatingpoint.html)
51
-
* [The decimal module](http://docs.python.org/library/decimal.html)
52
-
* [Context objects](http://docs.python.org/library/decimal.html#context-objects)
53
-
* [String formatting in Python](http://docs.python.org/library/stdtypes.html#string-formatting-operations)
-46
content/languages/sql.html
-46
content/languages/sql.html
···
1
-
---
2
-
title: Cheat sheet de punto flotante para SQL
3
-
description: Trucos para usar punto flotante y números decimales en SQL
4
-
---
5
-
6
-
Tipos de punto flotante
7
-
-----------------------
8
-
9
-
El estándar SQL define tres tipos de punto flotante binarios:
10
-
11
-
* `REAL` tiene precisión dependiente de la implementación (normalmente se asocia a un tipo a nivel de hardware como precisión sencilla o doble del IEEE 754).
12
-
* `DOUBLE PRECISION` tiene precisión dependiente de la implementación que es mayor que la de `REAL` (normalmente se asocia al precisión doble del IEEE 754).
13
-
* `FLOAT(N)` tiene al menos `N` dígitos binarios de precisión, con un máximo para `N` que depende de la implementación.
14
-
15
-
El rango del exponente para los tres tipos también depende de la implementación.
16
-
17
-
Tipos decimales
18
-
---------------
19
-
20
-
El estándar define dos tipos decimales de punto fijo:
21
-
22
-
* `NUMERIC(M,N)` tiene exactamente `M` dígitos en total, `N` de los cuales después del punto decimal.
23
-
* `DECIMAL(M,N)` es lo mismo que `NUMERIC(M,N)`, excepto porque permite tener más de `M` dígitos totales.
24
-
25
-
Los valores máximos de `M` y `N` dependen de la implementación. Los proveedores
26
-
normalmente implementan los dos tipos de manera idéntica.
27
-
28
-
Cómo redondear
29
-
--------------
30
-
31
-
El estándar SQL no define explícitamente el redondeo, pero la mayoría de los
32
-
proveedores proporciona una función `ROUND()` o `TRUNC()`.
33
-
34
-
Sin embargo, normalmente no tiene mucho sentido redondear dentro de la base de
35
-
datos, puesto que su función es *almacenar* los datos, mientras que redondear
36
-
es un aspecto de la *representación* de los datos, y debe por tanto hacerse
37
-
en el código de la capa de presentación.
38
-
39
-
Recursos
40
-
--------
41
-
42
-
* [Official ISO SQL 2008 standard (non-free)](http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=38640)
43
-
* [SQL 92 draft (free)](http://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt)
44
-
* [MySQL numeric types](http://dev.mysql.com/doc/refman/5.0/en/numeric-types.html)
45
-
* [PostgreSQL data types](http://www.postgresql.org/docs/8.1/static/datatype.html)
46
-
* [MS SQL Server data types](http://msdn.microsoft.com/en-US/library/ms187752%28v=SQL.90%29.aspx)
content/logo.png
content/logo.png
This is a binary file and will not be displayed.
-13
content/references.html
-13
content/references.html
···
1
-
---
2
-
title: Referencias
3
-
description: Documentos con más información detallada sobre aritmética de punto flotante
4
-
---
5
-
6
-
Documentos que contienen más información detallada sobre los temas tratados en este sitio:
7
-
8
-
* [Página del estándar IEEE 754](http://grouper.ieee.org/groups/754/)
9
-
* [What Every Computer Scientist Should Know About Floating-Point Arithmetic](http://download.oracle.com/docs/cd/E19957-01/806-3568/ncg_goldberg.html)
10
-
* [Página de William Kahan](http://www.cs.berkeley.edu/~wkahan/) (arquitecto del estándar IEEE 754, muchos enlaces interesantes)
11
-
* [Decimal Arithmetic FAQ ](http://speleotrove.com/decimal/decifaq.html)
12
-
* [Comparing floating point numbers, 2012 edition](http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/)
13
-
* [Herramienta para convertir números entre bases, incluyendo fracciones](http://www.easysurf.cc/cnver17.htm)
-133
content/style.css
-133
content/style.css
···
1
-
* {
2
-
font-family: Helvetica, Arial, sans-serif;
3
-
}
4
-
5
-
pre, code, tt {
6
-
font-family: Courier, monospace;
7
-
}
8
-
9
-
body {
10
-
background: #ffffee;
11
-
}
12
-
13
-
table {
14
-
border: 1px solid black;
15
-
border-collapse: collapse;
16
-
}
17
-
td{
18
-
border: 1px solid black;
19
-
padding: 5px;
20
-
}
21
-
tr.base_example td{
22
-
font-weight:bold;
23
-
border-left:none;
24
-
border-right:none;
25
-
border-top: 1px solid black;
26
-
border-bottom: 1px solid black;
27
-
padding: 2px;
28
-
vertical-align:bottom;
29
-
}
30
-
tr.base_example td.separator{
31
-
background: #fff0f0;
32
-
border: 1px solid black;
33
-
padding: 5px;
34
-
}
35
-
tr.base_example td.digit{
36
-
color: #ff0000
37
-
}
38
-
th {
39
-
border: 1px solid black;
40
-
padding: 5px;
41
-
background: #fff0f0;
42
-
text-align: left;
43
-
}
44
-
45
-
.num_base{
46
-
color: #0000ff
47
-
}
48
-
49
-
.num_base sup{
50
-
color: #000000
51
-
}
52
-
span.over {
53
-
text-decoration: overline;
54
-
}
55
-
56
-
a img {
57
-
border: none;
58
-
}
59
-
60
-
#main {
61
-
position: absolute;
62
-
63
-
top: 10px;
64
-
left: 280px;
65
-
margin-right:100px;
66
-
}
67
-
68
-
#main h1 {
69
-
font-size: 30px;
70
-
line-height: 30px;
71
-
}
72
-
73
-
#main p {
74
-
margin: 20px 0;
75
-
76
-
font-size: 15px;
77
-
78
-
line-height: 20px;
79
-
}
80
-
81
-
#main li {
82
-
83
-
font-size: 15px;
84
-
85
-
line-height: 20px;
86
-
}
87
-
88
-
#main ul li {
89
-
list-style-type: square;
90
-
}
91
-
92
-
#main ol li {
93
-
list-style-type: decimal;
94
-
}
95
-
96
-
#sidebar {
97
-
position: absolute;
98
-
99
-
top: 10px;
100
-
left: 20px;
101
-
width: 200px;
102
-
103
-
padding: 20px 20px 0 0;
104
-
105
-
border-right: 1px solid #ccc;
106
-
107
-
text-align: right;
108
-
}
109
-
110
-
#sidebar h2 {
111
-
text-transform: uppercase;
112
-
font-size: 13px;
113
-
color: #333;
114
-
letter-spacing: 1px;
115
-
line-height: 20px;
116
-
margin-top: 30px;
117
-
margin-bottom: 5px;
118
-
}
119
-
120
-
#sidebar ul {
121
-
list-style-type: none;
122
-
margin-top: 0px;
123
-
}
124
-
125
-
#sidebar li {
126
-
font-size: 14px;
127
-
line-height: 20px;
128
-
}
129
-
#license p {
130
-
margin-top: 30px;
131
-
font-size: 10px;
132
-
text-align:center;
133
-
}
-14
content/xkcd.html
-14
content/xkcd.html
···
1
-
---
2
-
title: xkcd
3
-
description: Cómo fastidiar a la gente que ha aprendido a *esperar* errores de redondeo en aritmética de punto flotante
4
-
---
5
-
6
-
o
7
-
-
8
-
9
-
<%= @item[:description] %>
10
-
====================
11
-
12
-
13
-
14
-
De [xkcd](http://www.xkcd.com/217/)
en.png
en.png
This is a binary file and will not be displayed.
+176
errors/NearlyEqualsTest.java
+176
errors/NearlyEqualsTest.java
···
1
+
import static org.junit.Assert.assertFalse;
2
+
import static org.junit.Assert.assertTrue;
3
+
4
+
import org.junit.Test;
5
+
6
+
/**
7
+
* Test suite to demonstrate a good method for comparing floating-point values
8
+
* using an epsilon. Run via JUnit 4.
9
+
*
10
+
* Note: this function attempts a "one size fits all" solution. There may be
11
+
* some edge cases for which it still produces unexpected results, and some of
12
+
* the tests it was developed to pass probably specify behaviour that is not
13
+
* appropriate for some applications. Before using it, make sure it's
14
+
* appropriate for your application!
15
+
*
16
+
* From http://floating-point-gui.de
17
+
*
18
+
* @author Michael Borgwardt
19
+
*/
20
+
public class NearlyEqualsTest {
21
+
public static boolean nearlyEqual(float a, float b, float epsilon) {
22
+
final float absA = Math.abs(a);
23
+
final float absB = Math.abs(b);
24
+
final float diff = Math.abs(a - b);
25
+
26
+
if (a == b) { // shortcut, handles infinities
27
+
return true;
28
+
} else if (a * b == 0) { // a or b or both are zero
29
+
// relative error is not meaningful here
30
+
return diff < (epsilon * epsilon);
31
+
} else { // use relative error
32
+
return diff / (absA + absB) < epsilon;
33
+
}
34
+
}
35
+
36
+
public static boolean nearlyEqual(float a, float b) {
37
+
return nearlyEqual(a, b, 0.000001f);
38
+
}
39
+
40
+
/** Regular large numbers - generally not problematic */
41
+
@Test
42
+
public void big() {
43
+
assertTrue(nearlyEqual(1000000f, 1000001f));
44
+
assertTrue(nearlyEqual(1000001f, 1000000f));
45
+
assertFalse(nearlyEqual(10000f, 10001f));
46
+
assertFalse(nearlyEqual(10001f, 10000f));
47
+
}
48
+
49
+
/** Negative large numbers */
50
+
@Test
51
+
public void bigNeg() {
52
+
assertTrue(nearlyEqual(-1000000f, -1000001f));
53
+
assertTrue(nearlyEqual(-1000001f, -1000000f));
54
+
assertFalse(nearlyEqual(-10000f, -10001f));
55
+
assertFalse(nearlyEqual(-10001f, -10000f));
56
+
}
57
+
58
+
/** Numbers around 1 */
59
+
@Test
60
+
public void mid() {
61
+
assertTrue(nearlyEqual(1.0000001f, 1.0000002f));
62
+
assertTrue(nearlyEqual(1.0000002f, 1.0000001f));
63
+
assertFalse(nearlyEqual(1.0002f, 1.0001f));
64
+
assertFalse(nearlyEqual(1.0001f, 1.0002f));
65
+
}
66
+
67
+
/** Numbers around -1 */
68
+
@Test
69
+
public void midNeg() {
70
+
assertTrue(nearlyEqual(-1.000001f, -1.000002f));
71
+
assertTrue(nearlyEqual(-1.000002f, -1.000001f));
72
+
assertFalse(nearlyEqual(-1.0001f, -1.0002f));
73
+
assertFalse(nearlyEqual(-1.0002f, -1.0001f));
74
+
}
75
+
76
+
/** Numbers between 1 and 0 */
77
+
@Test
78
+
public void small() {
79
+
assertTrue(nearlyEqual(0.000000001000001f, 0.000000001000002f));
80
+
assertTrue(nearlyEqual(0.000000001000002f, 0.000000001000001f));
81
+
assertFalse(nearlyEqual(0.000000000001002f, 0.000000000001001f));
82
+
assertFalse(nearlyEqual(0.000000000001001f, 0.000000000001002f));
83
+
}
84
+
85
+
/** Numbers between -1 and 0 */
86
+
@Test
87
+
public void smallNeg() {
88
+
assertTrue(nearlyEqual(-0.000000001000001f, -0.000000001000002f));
89
+
assertTrue(nearlyEqual(-0.000000001000002f, -0.000000001000001f));
90
+
assertFalse(nearlyEqual(-0.000000000001002f, -0.000000000001001f));
91
+
assertFalse(nearlyEqual(-0.000000000001001f, -0.000000000001002f));
92
+
}
93
+
94
+
/** Comparisons involving zero */
95
+
@Test
96
+
public void zero() {
97
+
assertTrue(nearlyEqual(0.0f, 0.0f));
98
+
assertTrue(nearlyEqual(0.0f, -0.0f));
99
+
assertTrue(nearlyEqual(-0.0f, -0.0f));
100
+
assertFalse(nearlyEqual(0.00000001f, 0.0f));
101
+
assertFalse(nearlyEqual(0.0f, 0.00000001f));
102
+
assertFalse(nearlyEqual(-0.00000001f, 0.0f));
103
+
assertFalse(nearlyEqual(0.0f, -0.00000001f));
104
+
105
+
assertTrue(nearlyEqual(0.0f, 0.00000001f, 0.01f));
106
+
assertTrue(nearlyEqual(0.00000001f, 0.0f, 0.01f));
107
+
assertFalse(nearlyEqual(0.00000001f, 0.0f, 0.000001f));
108
+
assertFalse(nearlyEqual(0.0f, 0.00000001f, 0.000001f));
109
+
110
+
assertTrue(nearlyEqual(0.0f, -0.00000001f, 0.1f));
111
+
assertTrue(nearlyEqual(-0.00000001f, 0.0f, 0.1f));
112
+
assertFalse(nearlyEqual(-0.00000001f, 0.0f, 0.00000001f));
113
+
assertFalse(nearlyEqual(0.0f, -0.00000001f, 0.00000001f));
114
+
}
115
+
116
+
/**
117
+
* Comparisons involving infinities
118
+
*/
119
+
@Test
120
+
public void infinities() {
121
+
assertTrue(nearlyEqual(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY));
122
+
assertTrue(nearlyEqual(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY));
123
+
assertFalse(nearlyEqual(Float.NEGATIVE_INFINITY,
124
+
Float.POSITIVE_INFINITY));
125
+
assertFalse(nearlyEqual(Float.POSITIVE_INFINITY, Float.MAX_VALUE));
126
+
assertFalse(nearlyEqual(Float.NEGATIVE_INFINITY, -Float.MAX_VALUE));
127
+
}
128
+
129
+
/**
130
+
* Comparisons involving NaN values
131
+
*/
132
+
@Test
133
+
public void nan() {
134
+
assertFalse(nearlyEqual(Float.NaN, Float.NaN));
135
+
}
136
+
137
+
/** Comparisons of numbers on opposite sides of 0 */
138
+
@Test
139
+
public void opposite() {
140
+
assertFalse(nearlyEqual(1.000000001f, -1.0f));
141
+
assertFalse(nearlyEqual(-1.0f, 1.000000001f));
142
+
assertFalse(nearlyEqual(-1.000000001f, 1.0f));
143
+
assertFalse(nearlyEqual(1.0f, -1.000000001f));
144
+
assertTrue(nearlyEqual(1e10f * Float.MIN_VALUE, -1e10f
145
+
* Float.MIN_VALUE));
146
+
}
147
+
148
+
/**
149
+
* The really tricky part - comparisons of numbers very close to zero.
150
+
*/
151
+
@Test
152
+
public void ulp() {
153
+
assertTrue(nearlyEqual(Float.MIN_VALUE, -Float.MIN_VALUE));
154
+
assertTrue(nearlyEqual(-Float.MIN_VALUE, Float.MIN_VALUE));
155
+
assertTrue(nearlyEqual(Float.MIN_VALUE, 0));
156
+
assertTrue(nearlyEqual(0, Float.MIN_VALUE));
157
+
assertTrue(nearlyEqual(-Float.MIN_VALUE, 0));
158
+
assertTrue(nearlyEqual(0, -Float.MIN_VALUE));
159
+
160
+
assertFalse(nearlyEqual(0.000000001f, -Float.MIN_VALUE));
161
+
assertFalse(nearlyEqual(0.000000001f, Float.MIN_VALUE));
162
+
assertFalse(nearlyEqual(Float.MIN_VALUE, 0.000000001f));
163
+
assertFalse(nearlyEqual(-Float.MIN_VALUE, 0.000000001f));
164
+
165
+
assertFalse(nearlyEqual(1e25f * Float.MIN_VALUE, 0.0f, 1e-12f));
166
+
assertFalse(nearlyEqual(0.0f, 1e25f * Float.MIN_VALUE, 1e-12f));
167
+
assertFalse(nearlyEqual(1e25f * Float.MIN_VALUE, -1e25f
168
+
* Float.MIN_VALUE, 1e-12f));
169
+
170
+
assertTrue(nearlyEqual(1e25f * Float.MIN_VALUE, 0.0f, 1e-5f));
171
+
assertTrue(nearlyEqual(0.0f, 1e25f * Float.MIN_VALUE, 1e-5f));
172
+
assertTrue(nearlyEqual(1e20f * Float.MIN_VALUE, -1e20f
173
+
* Float.MIN_VALUE, 1e-5f));
174
+
}
175
+
176
+
}
+160
errors/comparison/index.html
+160
errors/comparison/index.html
···
1
+
<!DOCTYPE HTML>
2
+
<html lang="es">
3
+
<head>
4
+
<meta charset="utf-8">
5
+
<title>La Guía del Punto Flotante - Comparación</title>
6
+
7
+
<meta name="generator" content="nanoc 3.1.2">
8
+
9
+
<meta name="Description" content="Explicación de los diversos problemas al comparar números de punto flotante">
10
+
11
+
<link rel="stylesheet" type="text/css" href="/style.css" media="screen">
12
+
<link rel="shortcut icon" href="/favicon.ico" type="image/vnd.microsoft.icon">
13
+
<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
14
+
</head>
15
+
<body>
16
+
<div id="main">
17
+
<h1>Comparación</h1>
18
+
<p>Debido a los errores de redondeo, la mayoría de los números de <a href="/formats/fp/">punto flotante</a>
19
+
terminan siendo ligeramente imprecisos. Mientras esta imprecisión se mantenga pequeña,
20
+
normalmente se puede ignorar. Sin embargo, esto significa también que números que se
21
+
espera que sean iguales (por ejemplo al calcular el mismo resultado utilizando distintos
22
+
métodos correctos) a veces difieren levemente, y una simple prueba de igualdad falla.
23
+
Por ejemplo:</p>
24
+
25
+
<pre><code> float a = 0.15 + 0.15
26
+
float b = 0.1 + 0.2
27
+
if(a == b) // ¡Puede ser falso!
28
+
if(a >= b) // ¡También puede ser falso!
29
+
</code></pre>
30
+
31
+
<h2 id="no-usar-mrgenes-de-error-absolutos">No usar márgenes de error absolutos</h2>
32
+
33
+
<p>La solución es comprobar no si los números son exactamente iguales, sino si su
34
+
diferencia es muy pequeña. El margen de error frente al que se compara esta diferencia
35
+
normalmente se llama <em>epsilon</em>. En su forma más simple:</p>
36
+
37
+
<pre><code> if(Math.abs(a-b) < 0.00001) // Mal ─ no hacer esto
38
+
</code></pre>
39
+
40
+
<p>Esto es una mala forma de hacerlo porque un epsilon fijo elegido porque «parece
41
+
pequeño» podría perfectamente ser demasiado grande cuando los números que se
42
+
comparan son también muy pequeños. La comparación devolvería «verdadero» para
43
+
números muy diferentes. Y cuando los números son muy grandes, el epsilon
44
+
puede acabar siendo más pequeño que el mínimo error de redondeo, por lo que
45
+
la comparación siempre devolvería «falso». Por tanto, es necesario ver si
46
+
el <em>error relativo</em> es menor que epsilon:</p>
47
+
48
+
<pre><code> if(Math.abs((a-b)/b) < 0.00001) // ¡Todavía no es correcto!
49
+
</code></pre>
50
+
51
+
<h2 id="vigila-los-casos-lmite">Vigila los casos límite</h2>
52
+
53
+
<p>Hay algunos casos especiales importantes para los que esto falla:</p>
54
+
55
+
<ul>
56
+
<li>Cuando tanto <code>a</code> como <code>b</code> son cero. <code>0.0/0.0</code> es NaN, lo que provoca una excepción en algunas plataformas o devuelve falso para todas las comparaciones.</li>
57
+
<li>Cuando solo <code>b</code> es cero, la división devuelve infinito, lo que también puede causar una excepción, o es mayor que epsilon incluso cuando <code>a</code> es más pequeño.</li>
58
+
<li>Devuelve «falso» cuando tanto <code>a</code> como <code>b</code> son muy pequeños pero a ambos lados del cero, incluso cuando son los números no nulos más pequeños.</li>
59
+
</ul>
60
+
61
+
<p>Además, el resultado no es conmutativo (<code>nearlyEquals(a,b)</code> no es siempre lo mismo que
62
+
<code>nearlyEquals(b,a)</code>). Para solucionar estos problemas, el código tiene que ser mucho más
63
+
complejo, así que necesitamos meterlo en una función:</p>
64
+
65
+
<pre><code> public static boolean nearlyEqual(float a, float b, float epsilon)
66
+
{
67
+
final float absA = Math.abs(a);
68
+
final float absB = Math.abs(b);
69
+
final float diff = Math.abs(a - b);
70
+
71
+
if (a == b) { // Atajo, maneja los infinitos
72
+
return true;
73
+
} else if (a * b == 0) { // a o b o ambos son cero
74
+
// El error relativo no es importante aquí
75
+
return diff < (epsilon * epsilon);
76
+
} else { // Usar el error relativo
77
+
return diff / (absA + absB) < epsilon;
78
+
}
79
+
}
80
+
</code></pre>
81
+
82
+
<p>Este método <a href="../NearlyEqualsTest.java">pasa las pruebas</a> para muchos casos especiales
83
+
importantes, pero como puedes ver, utiliza cierta lógica no trivial. En particular,
84
+
tiene que utilizar una definición totalmente distinta del margen de error cuando
85
+
<code>a</code> o <code>b</code> son cero, porque la definición clásica del error relativo es inútil en
86
+
esos casos.</p>
87
+
88
+
<p>Hay algunos casos en los que el método de arriba todavía produce resultados inesperados
89
+
(concretamente, es mucho más estricto cuando un valor es casi cero que cuando es
90
+
exactamente cero), y algunas de esas pruebas para las que fue desarrollado probablemente
91
+
especifica un comportamiento que no es apropiado para algunas aplicaciones. Antes de
92
+
usarlo, ¡asegúrate de que es adecuado para tu aplicación!</p>
93
+
94
+
<h2 id="comparando-valores-de-punto-flotante-como-enteros">Comparando valores de punto flotante como enteros</h2>
95
+
96
+
<p>Hay una alternativa a aplicar toda esta complejidad conceptual a una tarea aparentemente
97
+
tan sencilla: en lugar de comparar <code>a</code> y <code>b</code> como <a href="http://es.wikipedia.org/wiki/N%C3%BAmero_real">números
98
+
reales</a>, podemos concebirlos como pasos
99
+
discretos y definir el margen de error como el número máximo de valores de punto flotante
100
+
posibles entre esos dos números.</p>
101
+
102
+
<p>Esto es conceptualmente muy evidente y fácil y tiene la ventaja de que escala
103
+
implícitamente el margen de error relativo con la magnitud de los valores.
104
+
Técnicamente es un poco más complejo, pero no mucho más de lo que puedas pensar,
105
+
porque los números de punto flotante del IEEE 754 están diseñados para mantener su orden cuando
106
+
sus secuencias de bits se interpretan como enteros.</p>
107
+
108
+
<p>Sin embargo, este método requiere que el lenguaje de programación soporte conversión
109
+
entre valores de punto flotante y secuencias de bits enteras. Lee el artículo en
110
+
inglés <a href="/references/">Comparing floating-point numbers</a> para más detalles.</p>
111
+
112
+
<g:plusone href="http://puntoflotante.org/"></g:plusone>
113
+
<div id="license">
114
+
<p>© Publicado en <a href="http://puntoflotante.org/">http://puntoflotante.org/</a> bajo una licencia
115
+
<a href="http://creativecommons.org/licenses/by/3.0/deed.es">Creative Commons Atribución Unported (BY)</a>.
116
+
Original en inglés por Michael Borgwardt en
117
+
<a href="http://floating-point-gui.de/">http://floating-point-gui.de/</a>.</p>
118
+
</div>
119
+
</div>
120
+
<div id="sidebar">
121
+
<a href="/"><img src="/logo.png"></a>
122
+
<h2>La Guía del Punto Flotante</h2>
123
+
<ul>
124
+
<li><a href="http://floating-point-gui.de/" alt="in English"><img src="/en.png"></a></li>
125
+
<li><a href="/">Inicio</a></li>
126
+
<li><a href="/basic/">Respuestas básicas</a></li>
127
+
<li><a href="/references/">Referencias</a></li>
128
+
<li><a href="/xkcd/">xkcd</a></li>
129
+
</ul>
130
+
131
+
<h2>Formatos Numéricos</h2>
132
+
<ul>
133
+
<li><a href="/formats/binary/">Fracciones binarias</a></li>
134
+
<li><a href="/formats/fp/">Punto flotante</a></li>
135
+
<li><a href="/formats/exact/">Tipos exactos</a></li>
136
+
<li><a href="/formats/integer/">Sobre usar enteros</a></li>
137
+
</ul>
138
+
139
+
<h2>Errores</h2>
140
+
<ul>
141
+
<li><a href="/errors/rounding/">Redondeo</a></li>
142
+
<li><a href="/errors/comparison/">Comparación</a></li>
143
+
<li><a href="/errors/propagation/">Propagación</a></li>
144
+
</ul>
145
+
146
+
<h2>Cheat sheets</h2>
147
+
<ul>
148
+
<li><a href="/languages/csharp/">C#</a></li>
149
+
<li><a href="/languages/java/">Java</a></li>
150
+
<li><a href="/languages/javascript/">JavaScript</a></li>
151
+
<li><a href="/languages/perl/">Perl</a></li>
152
+
<li><a href="/languages/php/">PHP</a></li>
153
+
<li><a href="/languages/python/">Python</a></li>
154
+
<li><a href="/languages/sql/">SQL</a></li>
155
+
</ul>
156
+
</div>
157
+
<a href="http://github.com/Pybonacci/puntoflotante.org"><img style="position: absolute; top: 0; right: 0; border: 0;" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" alt="Fork me on GitHub" /></a>
158
+
159
+
</body>
160
+
</html>
+89
errors/propagation/index.html
+89
errors/propagation/index.html
···
1
+
<!DOCTYPE HTML>
2
+
<html lang="es">
3
+
<head>
4
+
<meta charset="utf-8">
5
+
<title>La Guía del Punto Flotante - Propagación del error</title>
6
+
7
+
<meta name="generator" content="nanoc 3.1.2">
8
+
9
+
<meta name="Description" content="Explicaciones sobre la propagación de errores en aritmética de punto flotante">
10
+
11
+
<link rel="stylesheet" type="text/css" href="/style.css" media="screen">
12
+
<link rel="shortcut icon" href="/favicon.ico" type="image/vnd.microsoft.icon">
13
+
<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
14
+
</head>
15
+
<body>
16
+
<div id="main">
17
+
<h1>Propagación del error</h1>
18
+
<p>Aunque los errores en <a href="/formats/fp/">números de punto flotante</a> aislados son muy pequeños,
19
+
operaciones simples con ellos pueden tener problemas e incrementar el error del resultado
20
+
más de lo que se esperaría «sumando» los errores individuales.</p>
21
+
22
+
<p>En general:</p>
23
+
24
+
<ul>
25
+
<li>La multiplicación y la división son operaciones «seguras».</li>
26
+
<li>La suma y la resta son peligrosas, porque cuando hay involucrados números de diferentes órdenes de magnitud, los dígitos del más pequeño se pierden.</li>
27
+
<li>Esta pérdida de dígitos puede ser inevitable y benigna (cuando los dígitos perdidos son también insignificantes para el resultado final) o catastrófica (cuando la pérdida se amplifica y distorsiona el resultado fuertemente).</li>
28
+
<li>Cuantas más operaciones se hagan (especialmente cuando forman parte de un algoritmo iterativo) más importante es considerar este problema.</li>
29
+
<li>Un método de cálculo puede ser <em>estable</em> (tiende a reducir los errores de redondeo) o <em>inestable</em> (los errores de redondeo se amplifican). A menudo, hay soluciones estables e inestables a un problema.</li>
30
+
</ul>
31
+
32
+
<p>Hay un área entera de las matemáticas (el <a href="http://es.wikipedia.org/wiki/An%C3%A1lisis_num%C3%A9rico">análisis
33
+
numérico</a>) dedicada a estudiar la
34
+
estabilidad numérica de los algoritmos. Para hacer cálculos complejos utilizando números de punto
35
+
flotante, es absolutamente necesario tener ciertos conocimientos en esta materia.</p>
36
+
37
+
<p>Este artículo en inglés <a href="/references/">What Every Computer Scientist Should Know About Floating-Point Arithmetic</a>
38
+
da una introducción detallada, y sirvió de inspiración para esta web, principalmente por el hecho
39
+
de que era demasiado minucioso y un poco intimidante para programadores sin una formación científica.</p>
40
+
41
+
<g:plusone href="http://puntoflotante.org/"></g:plusone>
42
+
<div id="license">
43
+
<p>© Publicado en <a href="http://puntoflotante.org/">http://puntoflotante.org/</a> bajo una licencia
44
+
<a href="http://creativecommons.org/licenses/by/3.0/deed.es">Creative Commons Atribución Unported (BY)</a>.
45
+
Original en inglés por Michael Borgwardt en
46
+
<a href="http://floating-point-gui.de/">http://floating-point-gui.de/</a>.</p>
47
+
</div>
48
+
</div>
49
+
<div id="sidebar">
50
+
<a href="/"><img src="/logo.png"></a>
51
+
<h2>La Guía del Punto Flotante</h2>
52
+
<ul>
53
+
<li><a href="http://floating-point-gui.de/" alt="in English"><img src="/en.png"></a></li>
54
+
<li><a href="/">Inicio</a></li>
55
+
<li><a href="/basic/">Respuestas básicas</a></li>
56
+
<li><a href="/references/">Referencias</a></li>
57
+
<li><a href="/xkcd/">xkcd</a></li>
58
+
</ul>
59
+
60
+
<h2>Formatos Numéricos</h2>
61
+
<ul>
62
+
<li><a href="/formats/binary/">Fracciones binarias</a></li>
63
+
<li><a href="/formats/fp/">Punto flotante</a></li>
64
+
<li><a href="/formats/exact/">Tipos exactos</a></li>
65
+
<li><a href="/formats/integer/">Sobre usar enteros</a></li>
66
+
</ul>
67
+
68
+
<h2>Errores</h2>
69
+
<ul>
70
+
<li><a href="/errors/rounding/">Redondeo</a></li>
71
+
<li><a href="/errors/comparison/">Comparación</a></li>
72
+
<li><a href="/errors/propagation/">Propagación</a></li>
73
+
</ul>
74
+
75
+
<h2>Cheat sheets</h2>
76
+
<ul>
77
+
<li><a href="/languages/csharp/">C#</a></li>
78
+
<li><a href="/languages/java/">Java</a></li>
79
+
<li><a href="/languages/javascript/">JavaScript</a></li>
80
+
<li><a href="/languages/perl/">Perl</a></li>
81
+
<li><a href="/languages/php/">PHP</a></li>
82
+
<li><a href="/languages/python/">Python</a></li>
83
+
<li><a href="/languages/sql/">SQL</a></li>
84
+
</ul>
85
+
</div>
86
+
<a href="http://github.com/Pybonacci/puntoflotante.org"><img style="position: absolute; top: 0; right: 0; border: 0;" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" alt="Fork me on GitHub" /></a>
87
+
88
+
</body>
89
+
</html>
+167
errors/rounding/index.html
+167
errors/rounding/index.html
···
1
+
<!DOCTYPE HTML>
2
+
<html lang="es">
3
+
<head>
4
+
<meta charset="utf-8">
5
+
<title>La Guía del Punto Flotante - Errores de redondeo</title>
6
+
7
+
<meta name="generator" content="nanoc 3.1.2">
8
+
9
+
<meta name="Description" content="Explicación de las razones de los errores de redondeo en aritmética de punto flotante, y de los métodos de redondeo">
10
+
11
+
<link rel="stylesheet" type="text/css" href="/style.css" media="screen">
12
+
<link rel="shortcut icon" href="/favicon.ico" type="image/vnd.microsoft.icon">
13
+
<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
14
+
</head>
15
+
<body>
16
+
<div id="main">
17
+
<h1>Errores de redondeo</h1>
18
+
<p>Como los <a href="/formats/fp/">números de punto flotante</a> tienen un número de dígitos limitado,
19
+
no pueden representar todos los <a href="http://es.wikipedia.org/wiki/N%C3%BAmero_real">números reales</a>
20
+
de forma precisa: cuando hay más dígitos de los que permite el formato, los que sobran se
21
+
omiten ─ el número se <em>redondea</em>. Hay tres razones por las que esto puede ser necesario:</p>
22
+
23
+
<ul>
24
+
<li><strong>Denominadores grandes</strong>
25
+
En cualquier base, cuanto mayor es el denominador de una fracción (irreducible),
26
+
más dígitos se necesitan en notación posicional. Un denominador lo suficientemente
27
+
grande necesitará redondeo, no importa qué base o número de dígitos disponible
28
+
haya. Por ejemplo, 1/1000 no se puede representar de manera precisa en menos de
29
+
3 dígitos decimales, ni ningún múltiplo suyo (que no permita simplificar la
30
+
fracción).</li>
31
+
<li><strong>Dígitos periódicos</strong>
32
+
Cualquier fracción (irreducible) donde el denominador tenga un factor primo que
33
+
no esté en la base requiere un número infinito de dígitos que se repiten periódicamente
34
+
a partir de un cierto punto. Por ejemplo, en decimal 1/4, 3/5 y 8/20 son finitos, porque
35
+
2 y 5 son los factores primos de 10. Pero 1/3 no es finito, ni tampoco 2/3 o 1/7 o 5/6,
36
+
porque 3 y 7 no son factores primos de 10. Las fracciones con un factor primo de 5 en el
37
+
denominador pueden ser finitas en base 10, pero no en <a href="/formats/binary/">base 2</a> ─ la
38
+
mayor fuente de confusión para los principiantes en los números de punto flotante.</li>
39
+
<li><strong>Números no racionales</strong>
40
+
Los números irracionales no se pueden representar como una fracción regular, y en notación
41
+
posicional (no importa en qué base) requieren un número infinito de dígitos no periódicos.</li>
42
+
</ul>
43
+
44
+
<h2 id="mtodos-de-redondeo">Métodos de redondeo</h2>
45
+
46
+
<p>Hay varias formas diferentes de redondear, y esto puede ser muy importante en programación,
47
+
porque el redondeo puede causar problemas en algunos contextos que se pueden solucionar
48
+
utilizando un método de redondeo distinto. Los más usuales son:</p>
49
+
50
+
<ul>
51
+
<li><strong>Redondeo hacia el cero</strong> o <strong>truncamiento</strong> - simplemente se omiten los dígitos sobrantes. Es el
52
+
método más sencillo, pero introduce más error del necesario y un sesgo hacia el
53
+
cero cuando se manejan sobre todo números positivos o sobre todo negativos.</li>
54
+
<li><strong>Redondeo al alza</strong> - si la fracción truncada es mayor o igual que la mitad de la base,
55
+
se incrementa el último dígito. Este método es el que se enseña en el colegio normalmente
56
+
y es el que usa la mayoría de la gente. Minimiza el error, pero también introduce un sesgo
57
+
(lejos del cero).</li>
58
+
<li><strong>Redondeo mitad al par</strong> también conocido como el <strong>redondeo del banquero</strong> - si la
59
+
fracción truncada es mayor que la mitad de la base, se incrementa el último dígito.
60
+
Si es igual a la mitad de la base, se incrementa solamente si el resultado es par. Esto
61
+
minimiza el error y el sesgo, y por eso se prefiere en contabilidad. Es el método por
62
+
defecto en el estándar IEEE 754.</li>
63
+
</ul>
64
+
65
+
<p>Ejemplos en base 10:</p>
66
+
67
+
<table>
68
+
<thead>
69
+
<tr>
70
+
<th> </th>
71
+
<th>Hacia el cero</th>
72
+
<th>Al alza</th>
73
+
<th>La mitad al par</th>
74
+
</tr>
75
+
</thead>
76
+
<tbody>
77
+
<tr>
78
+
<td>1.4</td>
79
+
<td>1</td>
80
+
<td>1</td>
81
+
<td>1</td>
82
+
</tr>
83
+
<tr>
84
+
<td>1.5</td>
85
+
<td>1</td>
86
+
<td>2</td>
87
+
<td>2</td>
88
+
</tr>
89
+
<tr>
90
+
<td>-1.6</td>
91
+
<td>-1</td>
92
+
<td>-2</td>
93
+
<td>-2</td>
94
+
</tr>
95
+
<tr>
96
+
<td>2.6</td>
97
+
<td>2</td>
98
+
<td>3</td>
99
+
<td>3</td>
100
+
</tr>
101
+
<tr>
102
+
<td>2.5</td>
103
+
<td>2</td>
104
+
<td>3</td>
105
+
<td>2</td>
106
+
</tr>
107
+
<tr>
108
+
<td>-2.4</td>
109
+
<td>-2</td>
110
+
<td>-2</td>
111
+
<td>-2</td>
112
+
</tr>
113
+
</tbody>
114
+
</table>
115
+
116
+
<p>Se pueden encontrar más <a href="http://en.wikipedia.org/wiki/Rounding">métodos de redondeo (inglés)</a>
117
+
en la Wikipedia inglesa.</p>
118
+
119
+
<g:plusone href="http://puntoflotante.org/"></g:plusone>
120
+
<div id="license">
121
+
<p>© Publicado en <a href="http://puntoflotante.org/">http://puntoflotante.org/</a> bajo una licencia
122
+
<a href="http://creativecommons.org/licenses/by/3.0/deed.es">Creative Commons Atribución Unported (BY)</a>.
123
+
Original en inglés por Michael Borgwardt en
124
+
<a href="http://floating-point-gui.de/">http://floating-point-gui.de/</a>.</p>
125
+
</div>
126
+
</div>
127
+
<div id="sidebar">
128
+
<a href="/"><img src="/logo.png"></a>
129
+
<h2>La Guía del Punto Flotante</h2>
130
+
<ul>
131
+
<li><a href="http://floating-point-gui.de/" alt="in English"><img src="/en.png"></a></li>
132
+
<li><a href="/">Inicio</a></li>
133
+
<li><a href="/basic/">Respuestas básicas</a></li>
134
+
<li><a href="/references/">Referencias</a></li>
135
+
<li><a href="/xkcd/">xkcd</a></li>
136
+
</ul>
137
+
138
+
<h2>Formatos Numéricos</h2>
139
+
<ul>
140
+
<li><a href="/formats/binary/">Fracciones binarias</a></li>
141
+
<li><a href="/formats/fp/">Punto flotante</a></li>
142
+
<li><a href="/formats/exact/">Tipos exactos</a></li>
143
+
<li><a href="/formats/integer/">Sobre usar enteros</a></li>
144
+
</ul>
145
+
146
+
<h2>Errores</h2>
147
+
<ul>
148
+
<li><a href="/errors/rounding/">Redondeo</a></li>
149
+
<li><a href="/errors/comparison/">Comparación</a></li>
150
+
<li><a href="/errors/propagation/">Propagación</a></li>
151
+
</ul>
152
+
153
+
<h2>Cheat sheets</h2>
154
+
<ul>
155
+
<li><a href="/languages/csharp/">C#</a></li>
156
+
<li><a href="/languages/java/">Java</a></li>
157
+
<li><a href="/languages/javascript/">JavaScript</a></li>
158
+
<li><a href="/languages/perl/">Perl</a></li>
159
+
<li><a href="/languages/php/">PHP</a></li>
160
+
<li><a href="/languages/python/">Python</a></li>
161
+
<li><a href="/languages/sql/">SQL</a></li>
162
+
</ul>
163
+
</div>
164
+
<a href="http://github.com/Pybonacci/puntoflotante.org"><img style="position: absolute; top: 0; right: 0; border: 0;" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" alt="Fork me on GitHub" /></a>
165
+
166
+
</body>
167
+
</html>
favicon.ico
favicon.ico
This is a binary file and will not be displayed.
+194
formats/binary/index.html
+194
formats/binary/index.html
···
1
+
<!DOCTYPE HTML>
2
+
<html lang="es">
3
+
<head>
4
+
<meta charset="utf-8">
5
+
<title>La Guía del Punto Flotante - Fracciones binarias</title>
6
+
7
+
<meta name="generator" content="nanoc 3.1.2">
8
+
9
+
<meta name="Description" content="Explicación detallada de cómo funcionan las fracciones binarias, qué problemas causan y por qué aun así se utilizan">
10
+
11
+
<link rel="stylesheet" type="text/css" href="/style.css" media="screen">
12
+
<link rel="shortcut icon" href="/favicon.ico" type="image/vnd.microsoft.icon">
13
+
<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
14
+
</head>
15
+
<body>
16
+
<div id="main">
17
+
<h1>Fracciones binarias</h1>
18
+
<h2 id="cmo-funcionan">Cómo funcionan</h2>
19
+
20
+
<p>Como programador, deberías estar familiarizado con el conceptro de enteros binarios,
21
+
esto es, la representación de números enteros como series de bits:</p>
22
+
23
+
<table>
24
+
<tr><th colspan="9">Decimal (<span class="num_base">base 10</span>)</th><th> </th><th colspan="17">Binario (<span class="num_base">base 2</span>)</th></tr>
25
+
<tr class="base_example">
26
+
<td class="digit">1</td><td>⋅</td><td class="num_base">10<sup>1</sup></td><td>+</td>
27
+
<td class="digit">3</td><td>⋅</td><td class="num_base">10<sup>0</sup></td><td>=</td>
28
+
<td class="digit">13<sub class="num_base">10</sub></td><td class="separator">=</td>
29
+
<td class="digit">1101<sub class="num_base">2</sub></td><td>=</td>
30
+
<td class="digit">1</td><td>⋅</td><td class="num_base">2<sup>3</sup></td><td>+</td>
31
+
<td class="digit">1</td><td>⋅</td><td class="num_base">2<sup>2</sup></td><td>+</td>
32
+
<td class="digit">0</td><td>⋅</td><td class="num_base">2<sup>1</sup></td><td>+</td>
33
+
<td class="digit">1</td><td>⋅</td><td class="num_base">2<sup>0</sup></td>
34
+
</tr><tr class="base_example">
35
+
<td class="digit">1</td><td>⋅</td><td>10</td><td>+</td>
36
+
<td class="digit">3</td><td>⋅</td><td>1 </td><td>=</td>
37
+
<td class="digit">13<sub class="num_base">10</sub></td><td class="separator">=</td>
38
+
<td class="digit">1101<sub class="num_base">2</sub></td><td>=</td>
39
+
<td class="digit">1</td><td>⋅</td><td>8</td><td>+</td>
40
+
<td class="digit">1</td><td>⋅</td><td>4</td><td>+</td>
41
+
<td class="digit">0</td><td>⋅</td><td>2</td><td>+</td>
42
+
<td class="digit">1</td><td>⋅</td><td>1</td>
43
+
</tr></table>
44
+
45
+
<p>Así almacenan números internamente los ordenadores. Y para números racionales en <a href="http://es.wikipedia.org/wiki/Notaci%C3%B3n_posicional">notación
46
+
posicional</a>, hacen lo mismo:</p>
47
+
48
+
<table>
49
+
<tr><th colspan="13">Decimal (<span class="num_base">base 10</span>)</th><th> </th><th colspan="13">Binario (<span class="num_base">base 2</span>)</th></tr>
50
+
<tr class="base_example">
51
+
<td class="digit">6</td><td>⋅</td><td class="num_base">10<sup>-1</sup></td><td>+</td>
52
+
<td class="digit">2</td><td>⋅</td><td class="num_base">10<sup>-2</sup></td><td>+</td>
53
+
<td class="digit">5</td><td>⋅</td><td class="num_base">10<sup>-3</sup></td><td>=</td>
54
+
<td class="digit">0.625<sub class="num_base">10</sub></td><td class="separator">=</td>
55
+
<td class="digit">0.101<sub class="num_base">2</sub></td><td>=</td>
56
+
<td class="digit">1</td><td>⋅</td><td class="num_base">2<sup>-1</sup></td><td>+</td>
57
+
<td class="digit">0</td><td>⋅</td><td class="num_base">2<sup>-2</sup></td><td>+</td>
58
+
<td class="digit">1</td><td>⋅</td><td class="num_base">2<sup>-3</sup></td>
59
+
</tr><tr class="base_example">
60
+
<td class="digit">6</td><td>⋅</td><td>1/10</td><td>+</td>
61
+
<td class="digit">2</td><td>⋅</td><td>1/100</td><td>+</td>
62
+
<td class="digit">5</td><td>⋅</td><td>1/1000</td><td>=</td>
63
+
<td class="digit">0.625<sub class="num_base">10</sub></td><td class="separator">=</td>
64
+
<td class="digit">0.101<sub class="num_base">2</sub></td><td>=</td>
65
+
<td class="digit">1</td><td>⋅</td><td>1/2</td><td>+</td>
66
+
<td class="digit">0</td><td>⋅</td><td>1/4</td><td>+</td>
67
+
<td class="digit">1</td><td>⋅</td><td>1/8</td>
68
+
</tr></table>
69
+
70
+
<h2 id="problemas">Problemas</h2>
71
+
72
+
<p>Aunque funcionan igual en principio, las fracciones binarias son diferentes a las fracciones decimales
73
+
en qué números que se pueden representar con precisión dado un número de dígitos, y por tanto también
74
+
en qué números resultan en <a href="/errors/rounding/">errores de redondeo</a>: concretamente, en binario solo
75
+
se pueden representar como una fracción finita aquellos números en los que el denominador es una
76
+
potencia de 2. Por desgracia, esto no incluye la mayoría de los números que pueden ser representados
77
+
como una fracción finita en base 10, como 0.1.</p>
78
+
79
+
<table>
80
+
<thead>
81
+
<tr>
82
+
<th>Fracción</th>
83
+
<th>Base</th>
84
+
<th>Notación posicional</th>
85
+
<th>Redondeado a 4 dígitos</th>
86
+
<th>Valor redondeado como fracción</th>
87
+
<th>Error de redondeo</th>
88
+
</tr>
89
+
</thead>
90
+
<tbody>
91
+
<tr>
92
+
<td>1/10</td>
93
+
<td>10</td>
94
+
<td>0.1</td>
95
+
<td>0.1</td>
96
+
<td>1/10</td>
97
+
<td>0</td>
98
+
</tr>
99
+
<tr>
100
+
<td>1/3</td>
101
+
<td>10</td>
102
+
<td>0.<span class="over">3</span></td>
103
+
<td>0.3333</td>
104
+
<td>3333/10000</td>
105
+
<td>1/30000</td>
106
+
</tr>
107
+
<tr>
108
+
<td>1/2</td>
109
+
<td>2</td>
110
+
<td>0.1</td>
111
+
<td>0.1</td>
112
+
<td>1/2</td>
113
+
<td>0</td>
114
+
</tr>
115
+
<tr>
116
+
<td>1/10</td>
117
+
<td>2</td>
118
+
<td>0.0<span class="over">0011</span></td>
119
+
<td>0.0001</td>
120
+
<td>1/16</td>
121
+
<td>3/80</td>
122
+
</tr>
123
+
</tbody>
124
+
</table>
125
+
126
+
<p>Y así es como <em>ya</em> obtienes un error de redondeo <em>con solamente escribir</em> un número como 0.1 y
127
+
pasarlo por tu intérprete o compilador. No es tan grande como 3/80 y puede ser invisible porque
128
+
los ordenadores cortan después de 23 o 52 dígitos binarios en vez de 4. Pero el error está ahí
129
+
y <em>causará</em> problemas eventualmente si simplemente lo ignoras.</p>
130
+
131
+
<h2 id="por-qu-usar-binario">¿Por qué usar binario?</h2>
132
+
133
+
<p>En el nivel más inferior, los ordenadores están basados en miles de millones de elementos eléctricos
134
+
que tienen dos estados (normalmente baja y alta tensión). Interpretándolos como 0 y 1, es muy fácil
135
+
construir circuitos para almacenar números binarios y hacer cálculos con ellos.</p>
136
+
137
+
<p>Mientras que es posible simular el comportamiento de los números decimales con circuitos binarios
138
+
también, es menos eficiente. Si los ordenadores usaran números decimales internamente, tendrían
139
+
menos memoria y serían más lentos con el mismo nivel de tecnología.</p>
140
+
141
+
<p>Puesto que la diferencia de comportamiento entre números binarios y decimales no es importante para
142
+
la mayor parte de las aplicaciones, la elección lógica es construir ordenadores basados en el sistema
143
+
binario y vivir con el hecho de que hay que poner un poco más de atención y esfuerzo para las aplicaciones
144
+
que tienen que funcionar <a href="/formats/exact/">como un número decimal</a>.</p>
145
+
146
+
<g:plusone href="http://puntoflotante.org/"></g:plusone>
147
+
<div id="license">
148
+
<p>© Publicado en <a href="http://puntoflotante.org/">http://puntoflotante.org/</a> bajo una licencia
149
+
<a href="http://creativecommons.org/licenses/by/3.0/deed.es">Creative Commons Atribución Unported (BY)</a>.
150
+
Original en inglés por Michael Borgwardt en
151
+
<a href="http://floating-point-gui.de/">http://floating-point-gui.de/</a>.</p>
152
+
</div>
153
+
</div>
154
+
<div id="sidebar">
155
+
<a href="/"><img src="/logo.png"></a>
156
+
<h2>La Guía del Punto Flotante</h2>
157
+
<ul>
158
+
<li><a href="http://floating-point-gui.de/" alt="in English"><img src="/en.png"></a></li>
159
+
<li><a href="/">Inicio</a></li>
160
+
<li><a href="/basic/">Respuestas básicas</a></li>
161
+
<li><a href="/references/">Referencias</a></li>
162
+
<li><a href="/xkcd/">xkcd</a></li>
163
+
</ul>
164
+
165
+
<h2>Formatos Numéricos</h2>
166
+
<ul>
167
+
<li><a href="/formats/binary/">Fracciones binarias</a></li>
168
+
<li><a href="/formats/fp/">Punto flotante</a></li>
169
+
<li><a href="/formats/exact/">Tipos exactos</a></li>
170
+
<li><a href="/formats/integer/">Sobre usar enteros</a></li>
171
+
</ul>
172
+
173
+
<h2>Errores</h2>
174
+
<ul>
175
+
<li><a href="/errors/rounding/">Redondeo</a></li>
176
+
<li><a href="/errors/comparison/">Comparación</a></li>
177
+
<li><a href="/errors/propagation/">Propagación</a></li>
178
+
</ul>
179
+
180
+
<h2>Cheat sheets</h2>
181
+
<ul>
182
+
<li><a href="/languages/csharp/">C#</a></li>
183
+
<li><a href="/languages/java/">Java</a></li>
184
+
<li><a href="/languages/javascript/">JavaScript</a></li>
185
+
<li><a href="/languages/perl/">Perl</a></li>
186
+
<li><a href="/languages/php/">PHP</a></li>
187
+
<li><a href="/languages/python/">Python</a></li>
188
+
<li><a href="/languages/sql/">SQL</a></li>
189
+
</ul>
190
+
</div>
191
+
<a href="http://github.com/Pybonacci/puntoflotante.org"><img style="position: absolute; top: 0; right: 0; border: 0;" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" alt="Fork me on GitHub" /></a>
192
+
193
+
</body>
194
+
</html>
+120
formats/exact/index.html
+120
formats/exact/index.html
···
1
+
<!DOCTYPE HTML>
2
+
<html lang="es">
3
+
<head>
4
+
<meta charset="utf-8">
5
+
<title>La Guía del Punto Flotante - Tipos exactos</title>
6
+
7
+
<meta name="generator" content="nanoc 3.1.2">
8
+
9
+
<meta name="Description" content="Descripción de varios tipos de datos que pueden ser más exactos que los números de punto flotante">
10
+
11
+
<link rel="stylesheet" type="text/css" href="/style.css" media="screen">
12
+
<link rel="shortcut icon" href="/favicon.ico" type="image/vnd.microsoft.icon">
13
+
<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
14
+
</head>
15
+
<body>
16
+
<div id="main">
17
+
<h1>Tipos exactos</h1>
18
+
<p>Aunque los números de <a href="/formats/fp/">punto flotante</a> <a href="/formats/binary/">binarios</a>
19
+
son mejores para que los ordenadores trabajen con ellos, y lo bastante buenos para
20
+
los humanos, a veces simplemente no son apropiados. En ocasiones los números de
21
+
verdad tienen que sumarse bien hasta el último bit, y no hay excusas técnicas
22
+
aceptables ─ normalmente cuando los cálculos involucran dinero.</p>
23
+
24
+
<p>Desgraciadamente, no hay un estándar dominante equivalente al IEEE 754 para esto
25
+
(la versión del 2008 añadió tipos decimales, pero es demasiado reciente para
26
+
tener una adopción generalizada).</p>
27
+
28
+
<p>Cada lenguaje o plataforma tiene su propia solución, y a veces más de una. Para
29
+
más detalles, puedes ver las cheat sheets de los lenguajes.</p>
30
+
31
+
<p>Hay al menos tres clases diferentes de estos tipos de datos:</p>
32
+
33
+
<h2 id="decimal-de-precisin-limitada">Decimal de precisión limitada</h2>
34
+
35
+
<p>Básicamente lo mismo que el punto flotante binario del IEEE 754, excepto porque
36
+
el exponente se interpreta en base 10. Como resultado, no hay <a href="/errors/rounding/">errores de
37
+
redondeo</a> inesperados. Además, este tipo de formato es
38
+
relativamente compacto y rápido, pero normalmente más lento que los formatos binarios.</p>
39
+
40
+
<h2 id="decimal-de-precisin-arbitraria">Decimal de precisión arbitraria</h2>
41
+
42
+
<p>A veces llamado «bignum», es similar a un tipo de precisión limitada, pero tiene
43
+
la habilidad de incrementar la longitud de la mantisa (a veces también la del exponente)
44
+
cuando es necesario. La contrapartida es que hay un coste (en memoria y velocidad)
45
+
por soportar esta flexibilidad, y además cuanto más larga es la mantisa más memoria
46
+
se necesita y más lentos se vuelven los cálculos.</p>
47
+
48
+
<p>Puede ser muy tentador decir «mi operación es importante, así que necesito toda la
49
+
precisión que sea posible», pero en la práctica la importancia real de la precisión
50
+
en la diezmilésima cifra decimal se desvanece en comparación con la penalización en
51
+
la eficiencia requerida para soportarlo.</p>
52
+
53
+
<h2 id="clculo-simblico">Cálculo simbólico</h2>
54
+
55
+
<p>El «santo grial» de las operaciones exactas. Se consigue escribiendo un programa que
56
+
realmente conozca todas las reglas matemáticas y represente los datos como <em>símbolos</em>
57
+
en lugar de números redondeados e imprecisos. Por ejemplo:</p>
58
+
59
+
<ul>
60
+
<li>1/3 es realmente la fracción «uno dividido entre tres».</li>
61
+
<li>La raíz cuadrada de 2 es realmente el número que, multiplicado por sí mismo, da <em>exactamente</em> 2.</li>
62
+
<li>Incluso los <a href="http://es.wikipedia.org/wiki/N%C3%BAmero_trascendente">números trascendentes</a> como <strong>e</strong> y <strong>π</strong> son conocidos, junto con sus propiedades, de tal forma que e<sup>iπ</sup> es <em>exactamente</em> igual a -1.</li>
63
+
</ul>
64
+
65
+
<p>Sin embargo, estos sistemas de cálculo simbólico son complejos, lentos y requieren
66
+
unos conocimientos matemáticos significativos para ser usados. Son herramientas
67
+
inestimables para los matemáticos, pero no son apropiadas para las tareas diarias en
68
+
programación. E incluso la mayoría de los matemáticas trabajan en problemas donde
69
+
soluciones numéricas imprecisas son mejores porque no se conoce solución en forma
70
+
cerrada.</p>
71
+
72
+
<g:plusone href="http://puntoflotante.org/"></g:plusone>
73
+
<div id="license">
74
+
<p>© Publicado en <a href="http://puntoflotante.org/">http://puntoflotante.org/</a> bajo una licencia
75
+
<a href="http://creativecommons.org/licenses/by/3.0/deed.es">Creative Commons Atribución Unported (BY)</a>.
76
+
Original en inglés por Michael Borgwardt en
77
+
<a href="http://floating-point-gui.de/">http://floating-point-gui.de/</a>.</p>
78
+
</div>
79
+
</div>
80
+
<div id="sidebar">
81
+
<a href="/"><img src="/logo.png"></a>
82
+
<h2>La Guía del Punto Flotante</h2>
83
+
<ul>
84
+
<li><a href="http://floating-point-gui.de/" alt="in English"><img src="/en.png"></a></li>
85
+
<li><a href="/">Inicio</a></li>
86
+
<li><a href="/basic/">Respuestas básicas</a></li>
87
+
<li><a href="/references/">Referencias</a></li>
88
+
<li><a href="/xkcd/">xkcd</a></li>
89
+
</ul>
90
+
91
+
<h2>Formatos Numéricos</h2>
92
+
<ul>
93
+
<li><a href="/formats/binary/">Fracciones binarias</a></li>
94
+
<li><a href="/formats/fp/">Punto flotante</a></li>
95
+
<li><a href="/formats/exact/">Tipos exactos</a></li>
96
+
<li><a href="/formats/integer/">Sobre usar enteros</a></li>
97
+
</ul>
98
+
99
+
<h2>Errores</h2>
100
+
<ul>
101
+
<li><a href="/errors/rounding/">Redondeo</a></li>
102
+
<li><a href="/errors/comparison/">Comparación</a></li>
103
+
<li><a href="/errors/propagation/">Propagación</a></li>
104
+
</ul>
105
+
106
+
<h2>Cheat sheets</h2>
107
+
<ul>
108
+
<li><a href="/languages/csharp/">C#</a></li>
109
+
<li><a href="/languages/java/">Java</a></li>
110
+
<li><a href="/languages/javascript/">JavaScript</a></li>
111
+
<li><a href="/languages/perl/">Perl</a></li>
112
+
<li><a href="/languages/php/">PHP</a></li>
113
+
<li><a href="/languages/python/">Python</a></li>
114
+
<li><a href="/languages/sql/">SQL</a></li>
115
+
</ul>
116
+
</div>
117
+
<a href="http://github.com/Pybonacci/puntoflotante.org"><img style="position: absolute; top: 0; right: 0; border: 0;" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" alt="Fork me on GitHub" /></a>
118
+
119
+
</body>
120
+
</html>
+193
formats/fp/index.html
+193
formats/fp/index.html
···
1
+
<!DOCTYPE HTML>
2
+
<html lang="es">
3
+
<head>
4
+
<meta charset="utf-8">
5
+
<title>La Guía del Punto Flotante - Números de punto flotante</title>
6
+
7
+
<meta name="generator" content="nanoc 3.1.2">
8
+
9
+
<meta name="Description" content="Explicación de cómo funcionan los números de punto flotante y para qué son útiles">
10
+
11
+
<link rel="stylesheet" type="text/css" href="/style.css" media="screen">
12
+
<link rel="shortcut icon" href="/favicon.ico" type="image/vnd.microsoft.icon">
13
+
<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
14
+
</head>
15
+
<body>
16
+
<div id="main">
17
+
<h1>Números de punto flotante</h1>
18
+
<h2 id="por-qu-son-necesarios-los-nmeros-de-punto-flotante">Por qué son necesarios los números de punto flotante</h2>
19
+
20
+
<p>Como la memoria de los ordenadores es limitada, no puedes almacenar números
21
+
con precisión infinita, no importa si usas <a href="/formats/binary/">fracciones binarias</a> o
22
+
decimales: en algún momento tienes que cortar. Pero ¿cuánta precisión se necesita?
23
+
¿Y <em>dónde</em> se necesita? ¿Cuántos dígitos enteros y cuántos fraccionarios?</p>
24
+
25
+
<ul>
26
+
<li>Para un ingeniero construyendo una autopista, no importa si tiene 10 metros o 10.0001 metros de ancho ─ posiblemente ni siquiera sus mediciones eran así de precisas.</li>
27
+
<li>Para alguien diseñando un microchip, 0.0001 metros (la décima parte de un milímetro) es una diferencia <em>enorme</em> ─ pero nunca tendrá que manejar distancias mayores de 0.1 metros.</li>
28
+
<li>Un físico necesita usar la <a href="http://es.wikipedia.org/wiki/Velocidad_de_la_luz">velocidad de la luz</a> (más o menos 300000000) y la <a href="http://es.wikipedia.org/wiki/Constante_de_gravitaci%C3%B3n_universal">constante de gravitación universal</a> (más o menos 0.0000000000667) juntas en el mismo cálculo.</li>
29
+
</ul>
30
+
31
+
<p>Para satisfacer al ingeniero y al diseñador de circuitos integrados, el formato
32
+
tiene que ser preciso para números de órdenes de magnitud muy diferentes. Sin
33
+
embargo, solo se necesita precisión <em>relativa</em>. Para satisfacer al físico, debe
34
+
ser posible hacer cálculos que involucren números de órdenes muy dispares.</p>
35
+
36
+
<p>Básicamente, tener un número fijo de dígitos enteros y fraccionarios no es útil ─ y la solución es un formato con un <em>punto flotante</em>.</p>
37
+
38
+
<h2 id="cmo-funcionan-los-nmeros-de-punto-flotante">Cómo funcionan los números de punto flotante</h2>
39
+
40
+
<p>La idea es descomponer el número en dos partes:</p>
41
+
42
+
<ul>
43
+
<li>Una <strong>mantisa</strong> (también llamada coeficiente o significando) que contiene los dígitos del número. Mantisas negativas representan números negativos.</li>
44
+
<li>Un <strong>exponente</strong> que indica dónde se coloca el punto decimal (o binario) en relación al inicio de la mantisa. Exponentes negativos representan números menores que uno.</li>
45
+
</ul>
46
+
47
+
<p>Este formato cumple todos los requisitos:</p>
48
+
49
+
<ul>
50
+
<li>Puede representar números de órdenes de magnitud enormemente dispares (limitado por la longitud del exponente).</li>
51
+
<li>Proporciona la misma precisión relativa para todos los órdenes (limitado por la longitud de la mantisa).</li>
52
+
<li>Permite cálculos entre magnitudes: multiplicar un número muy grande y uno muy pequeño conserva la precisión de ambos en el resultado.</li>
53
+
</ul>
54
+
55
+
<p>Los números de coma flotante decimales normalmente se expresan en
56
+
<a href="http://es.wikipedia.org/wiki/Notaci%C3%B3n_cient%C3%ADfica">notación científica</a> con un
57
+
punto explícito siempre entre el primer y el segundo dígitos. El exponente o bien
58
+
se escribe explícitamente incluyendo la base, o se usa una <strong>e</strong> para
59
+
separarlo de la mantisa.</p>
60
+
61
+
<table>
62
+
<thead>
63
+
<tr>
64
+
<th>Mantisa</th>
65
+
<th>Exponente</th>
66
+
<th>Notación científica</th>
67
+
<th>Valor en punto fijo</th>
68
+
</tr>
69
+
</thead>
70
+
<tbody>
71
+
<tr>
72
+
<td>1.5</td>
73
+
<td>4</td>
74
+
<td>1.5 ⋅ 10<sup>4</sup></td>
75
+
<td>15000</td>
76
+
</tr>
77
+
<tr>
78
+
<td>-2.001</td>
79
+
<td>2</td>
80
+
<td>-2.001 ⋅ 10<sup>2</sup></td>
81
+
<td>-200.1</td>
82
+
</tr>
83
+
<tr>
84
+
<td>5</td>
85
+
<td>-3</td>
86
+
<td>5 ⋅ 10<sup>-3</sup></td>
87
+
<td>0.005</td>
88
+
</tr>
89
+
<tr>
90
+
<td>6.667</td>
91
+
<td>-11</td>
92
+
<td>6.667e-11</td>
93
+
<td>0.0000000000667</td>
94
+
</tr>
95
+
</tbody>
96
+
</table>
97
+
98
+
<h2 id="el-estndar">El estándar</h2>
99
+
100
+
<p>Casi todo el hardware y lenguajes de programación utilizan números de punto flotante en los mismos
101
+
formatos binarios, que están definidos en el estándar <a href="http://es.wikipedia.org/wiki/IEEE_coma_flotante">IEEE 754</a>.
102
+
Los formatos más comunes son de 32 o 64 bits de longitud total:</p>
103
+
104
+
<table>
105
+
<thead>
106
+
<tr>
107
+
<th>Formato</th>
108
+
<th>Bits totales</th>
109
+
<th>Bits significativos</th>
110
+
<th>Bits del exponente</th>
111
+
<th>Número más pequeño</th>
112
+
<th>Número más grande</th>
113
+
</tr>
114
+
</thead>
115
+
<tbody>
116
+
<tr>
117
+
<td>Precisión sencilla</td>
118
+
<td>32</td>
119
+
<td>23 + 1 signo</td>
120
+
<td>8</td>
121
+
<td>~1.2 ⋅ 10<sup>-38</sup></td>
122
+
<td>~3.4 ⋅ 10<sup>38</sup></td>
123
+
</tr>
124
+
<tr>
125
+
<td>Precisión doble</td>
126
+
<td>64</td>
127
+
<td>52 + 1 signo</td>
128
+
<td>11</td>
129
+
<td>~5.0 ⋅ 10<sup>-324</sup></td>
130
+
<td>~1.8 ⋅ 10<sup>308</sup></td>
131
+
</tr>
132
+
</tbody>
133
+
</table>
134
+
135
+
<p>Hay algunas pecularidades:</p>
136
+
137
+
<ul>
138
+
<li>La <em>secuencia de bits</em> es primero el bit del signo, seguido del exponente y finalmente los bits significativos.</li>
139
+
<li>El exponente no tiene signo; en su lugar se le resta un <strong>desplazamiento</strong> (127 para sencilla y 1023 para doble precisión). Esto, junto con la secuencia de bits, permite que los números de punto flotante se puedan comparar y ordenar correctamente incluso cuando se interpretan como enteros.</li>
140
+
<li>Se asume que el bit más significativo de la mantisa es 1 y se omite, excepto para casos especiales.</li>
141
+
<li>Hay valores diferentes para <strong>cero positivo y cero negativo</strong>. Estos difieren en el bit del signo, mientras que todos los demás son 0. Deben ser considerados iguales aunque sus secuencias de bits sean diferentes.</li>
142
+
<li>Hay valores especiales <strong>no numéricos</strong> (NaN, «not a number» en inglés) en los que el exponente es todo unos y la mantisa <em>no</em> es todo ceros. Estos valores representan el resultado de algunas operaciones indefinidas (como multiplicar 0 por infinito, operaciones que involucren NaN, o casos específicos). Incluso valores NaN con idéntica secuencia de bits <em>no</em> deben ser considerados iguales.</li>
143
+
</ul>
144
+
145
+
<g:plusone href="http://puntoflotante.org/"></g:plusone>
146
+
<div id="license">
147
+
<p>© Publicado en <a href="http://puntoflotante.org/">http://puntoflotante.org/</a> bajo una licencia
148
+
<a href="http://creativecommons.org/licenses/by/3.0/deed.es">Creative Commons Atribución Unported (BY)</a>.
149
+
Original en inglés por Michael Borgwardt en
150
+
<a href="http://floating-point-gui.de/">http://floating-point-gui.de/</a>.</p>
151
+
</div>
152
+
</div>
153
+
<div id="sidebar">
154
+
<a href="/"><img src="/logo.png"></a>
155
+
<h2>La Guía del Punto Flotante</h2>
156
+
<ul>
157
+
<li><a href="http://floating-point-gui.de/" alt="in English"><img src="/en.png"></a></li>
158
+
<li><a href="/">Inicio</a></li>
159
+
<li><a href="/basic/">Respuestas básicas</a></li>
160
+
<li><a href="/references/">Referencias</a></li>
161
+
<li><a href="/xkcd/">xkcd</a></li>
162
+
</ul>
163
+
164
+
<h2>Formatos Numéricos</h2>
165
+
<ul>
166
+
<li><a href="/formats/binary/">Fracciones binarias</a></li>
167
+
<li><a href="/formats/fp/">Punto flotante</a></li>
168
+
<li><a href="/formats/exact/">Tipos exactos</a></li>
169
+
<li><a href="/formats/integer/">Sobre usar enteros</a></li>
170
+
</ul>
171
+
172
+
<h2>Errores</h2>
173
+
<ul>
174
+
<li><a href="/errors/rounding/">Redondeo</a></li>
175
+
<li><a href="/errors/comparison/">Comparación</a></li>
176
+
<li><a href="/errors/propagation/">Propagación</a></li>
177
+
</ul>
178
+
179
+
<h2>Cheat sheets</h2>
180
+
<ul>
181
+
<li><a href="/languages/csharp/">C#</a></li>
182
+
<li><a href="/languages/java/">Java</a></li>
183
+
<li><a href="/languages/javascript/">JavaScript</a></li>
184
+
<li><a href="/languages/perl/">Perl</a></li>
185
+
<li><a href="/languages/php/">PHP</a></li>
186
+
<li><a href="/languages/python/">Python</a></li>
187
+
<li><a href="/languages/sql/">SQL</a></li>
188
+
</ul>
189
+
</div>
190
+
<a href="http://github.com/Pybonacci/puntoflotante.org"><img style="position: absolute; top: 0; right: 0; border: 0;" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" alt="Fork me on GitHub" /></a>
191
+
192
+
</body>
193
+
</html>
+84
formats/integer/index.html
+84
formats/integer/index.html
···
1
+
<!DOCTYPE HTML>
2
+
<html lang="es">
3
+
<head>
4
+
<meta charset="utf-8">
5
+
<title>La Guía del Punto Flotante - Sobre usar enteros</title>
6
+
7
+
<meta name="generator" content="nanoc 3.1.2">
8
+
9
+
<meta name="Description" content="Explicación de por qué usar enteros para evitar los problemas del punto flotante para, por ejemplo, representar céntimos no es una buena solución">
10
+
11
+
<link rel="stylesheet" type="text/css" href="/style.css" media="screen">
12
+
<link rel="shortcut icon" href="/favicon.ico" type="image/vnd.microsoft.icon">
13
+
<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
14
+
</head>
15
+
<body>
16
+
<div id="main">
17
+
<h1>Sobre usar enteros</h1>
18
+
<p>Mientras que los tipos enteros son normalmente binarios y por definición no soportan
19
+
fracciones, son exactos (no hay <a href="/errors/rounding/">errores de redondeo</a> cuando se
20
+
convierten desde enteros decimales) y se pueden usar como una suerte de <a href="/formats/exact/">tipo
21
+
decimal</a> «casero» eligiendo implícitamente un punto decimal fijo
22
+
de tal forma que la unidad más pequeña con la que estés trabajando se pueda representar
23
+
por el entero 1. En la práctica, esto normalmente se expresa como: <strong>«Para manejar
24
+
dinero, almacena y calcula todo en céntimos y solo formatea el resultado»</strong>.</p>
25
+
26
+
<p>Esto funciona, pero tiene algunas <strong>desventajas importantes</strong>:</p>
27
+
28
+
<ul>
29
+
<li>Supone más trabajo (y más oportunidades de introducir bugs) hacerlo bien, especialmente en lo que concierne a los <a href="/errors/rounding/">métodos de redondeo</a>.</li>
30
+
<li>Los enteros tienen precisión completa, pero en un rango muy limitado, y cuando se desbordan, normalmente «dan la vuelta» silenciosamente: el mayor entero más 1 da cero (para enteros sin signo) o el valor negativo más grande en valor absoluto (para enteros con signo). Este es el peor comportamiento posible cuando se trabaja con dinero por razones obvias.</li>
31
+
<li>El punto decimal implícito es difícil de cambiar y enormemente inflexible: si almacenas los dólares como céntimos, es simplemente imposible soportar el <a href="http://es.wikipedia.org/wiki/Dinar_barein%C3%AD">dinar bareiní</a>(1 dinar = 1000 fils) al mismo tiempo. Tendrías que almacenar la posición del punto decimal con los datos ─ el primer paso para implementar tu propio formato de <a href="/formats/fp/">punto flotante</a> decimal de precisión limitada (lleno de fallos y no estándar).</li>
32
+
</ul>
33
+
34
+
<p>Resumen: <strong>no se recomienda usar enteros</strong>. Haz esto solamente si no hay otra <a href="/formats/exact/">alternativa mejor</a>.</p>
35
+
36
+
<g:plusone href="http://puntoflotante.org/"></g:plusone>
37
+
<div id="license">
38
+
<p>© Publicado en <a href="http://puntoflotante.org/">http://puntoflotante.org/</a> bajo una licencia
39
+
<a href="http://creativecommons.org/licenses/by/3.0/deed.es">Creative Commons Atribución Unported (BY)</a>.
40
+
Original en inglés por Michael Borgwardt en
41
+
<a href="http://floating-point-gui.de/">http://floating-point-gui.de/</a>.</p>
42
+
</div>
43
+
</div>
44
+
<div id="sidebar">
45
+
<a href="/"><img src="/logo.png"></a>
46
+
<h2>La Guía del Punto Flotante</h2>
47
+
<ul>
48
+
<li><a href="http://floating-point-gui.de/" alt="in English"><img src="/en.png"></a></li>
49
+
<li><a href="/">Inicio</a></li>
50
+
<li><a href="/basic/">Respuestas básicas</a></li>
51
+
<li><a href="/references/">Referencias</a></li>
52
+
<li><a href="/xkcd/">xkcd</a></li>
53
+
</ul>
54
+
55
+
<h2>Formatos Numéricos</h2>
56
+
<ul>
57
+
<li><a href="/formats/binary/">Fracciones binarias</a></li>
58
+
<li><a href="/formats/fp/">Punto flotante</a></li>
59
+
<li><a href="/formats/exact/">Tipos exactos</a></li>
60
+
<li><a href="/formats/integer/">Sobre usar enteros</a></li>
61
+
</ul>
62
+
63
+
<h2>Errores</h2>
64
+
<ul>
65
+
<li><a href="/errors/rounding/">Redondeo</a></li>
66
+
<li><a href="/errors/comparison/">Comparación</a></li>
67
+
<li><a href="/errors/propagation/">Propagación</a></li>
68
+
</ul>
69
+
70
+
<h2>Cheat sheets</h2>
71
+
<ul>
72
+
<li><a href="/languages/csharp/">C#</a></li>
73
+
<li><a href="/languages/java/">Java</a></li>
74
+
<li><a href="/languages/javascript/">JavaScript</a></li>
75
+
<li><a href="/languages/perl/">Perl</a></li>
76
+
<li><a href="/languages/php/">PHP</a></li>
77
+
<li><a href="/languages/python/">Python</a></li>
78
+
<li><a href="/languages/sql/">SQL</a></li>
79
+
</ul>
80
+
</div>
81
+
<a href="http://github.com/Pybonacci/puntoflotante.org"><img style="position: absolute; top: 0; right: 0; border: 0;" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" alt="Fork me on GitHub" /></a>
82
+
83
+
</body>
84
+
</html>
+110
index.html
+110
index.html
···
1
+
<!DOCTYPE HTML>
2
+
<html lang="es">
3
+
<head>
4
+
<meta charset="utf-8">
5
+
<title>La Guía del Punto Flotante - Lo que todo programador debería saber sobre aritmética de punto flotante</title>
6
+
7
+
<meta name="google-site-verification" content="5yrVDy61XOxulQRv7qIErl1GX_Y9M4LmRWg47olpdIM" />
8
+
9
+
<meta name="generator" content="nanoc 3.1.2">
10
+
11
+
<meta name="Description" content="Pretende dar respuestas cortas y sencillas a las preguntas recurrentes de programadores principiantes sobre números de punto flotante que «no se suman correctamente», e información más detallada sobre cómo funcionan los números decimales del IEEE 754, cuándo y cómo usarlos correctamente, y qué usar en su lugar cuando no son apropiados">
12
+
13
+
<link rel="stylesheet" type="text/css" href="/style.css" media="screen">
14
+
<link rel="shortcut icon" href="/favicon.ico" type="image/vnd.microsoft.icon">
15
+
<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
16
+
</head>
17
+
<body>
18
+
<div id="main">
19
+
<h1>Lo que todo programador debería saber sobre aritmética de punto flotante</h1>
20
+
<h2 id="o">o</h2>
21
+
22
+
<h1 id="por-qu-mis-nmeros-no-se-suman-bien">¿Por qué mis números no se suman bien?</h1>
23
+
24
+
<p>O sea que has escrito algún código absurdamente simple, como por ejemplo:</p>
25
+
26
+
<pre><code> 0.1 + 0.2
27
+
</code></pre>
28
+
29
+
<p>y has obtenido un resultado totalmente inesperado:</p>
30
+
31
+
<pre><code> 0.30000000000000004
32
+
</code></pre>
33
+
34
+
<p>Tal vez pediste ayuda en algún foro y te mandaron a un <a href="http://download.oracle.com/docs/cd/E19957-01/806-3568/ncg_goldberg.html">artículo largo con un montón de fórmulas</a> que no parecía ser de ayuda.</p>
35
+
36
+
<p>Bueno, este sitio está aquí para:</p>
37
+
38
+
<ul>
39
+
<li>Explicar de manera concisa por qué obtuviste ese resultado inesperado</li>
40
+
<li>Decirte cómo lidiar con este problema</li>
41
+
<li>Si te interesa, dar explicaciones detalladas de por qué los números de punto flotante tienen que funcionar así y qué otros problemas pueden surgir</li>
42
+
</ul>
43
+
44
+
<p>Deberías ir a la sección de <a href="/basic/">Respuestas básicas</a> primero ─ ¡pero no termines ahí!</p>
45
+
46
+
<h3 id="sobre-la-notacin-y-la-nomenclatura">Sobre la notación y la nomenclatura</h3>
47
+
48
+
<p>Aunque tanto el punto como la coma son válidas como marcas decimales según el
49
+
Sistema Internacional y la norma ISO<sup>1</sup>, las Academias de la Lengua recomiendan el
50
+
punto<sup>2</sup>. Esto facilita las cosas,
51
+
porque se converge así con la notación anglosajona que es la que se utiliza en la mayoría de
52
+
lenguajes de programación. En este sitio se ha optado por la denominación «punto
53
+
flotante» en lugar de «coma flotante», puesto que la Fundación del Español Urgente
54
+
(<a href="http://www.fundeu.es/">Fundéu BBVA</a>) especificó en una consulta
55
+
que debe haber correspondencia con el criterio adoptado para la marca decimal. </p>
56
+
57
+
<ol>
58
+
<li>Bezos, Javier. <em>La marca decimal</em> <<a href="http://www.tex-tipografia.com/marca_decimal.html">http://www.tex-tipografia.com/marca_decimal.html</a>></li>
59
+
<li>Bezos, Javier. <em>Las notaciones científicas en la Ortografía académica</em> <<a href="http://www.tex-tipografia.com/ortografia_notaciones.html">http://www.tex-tipografia.com/ortografia_notaciones.html</a>></li>
60
+
</ol>
61
+
62
+
<g:plusone href="http://puntoflotante.org/"></g:plusone>
63
+
<div id="license">
64
+
<p>© Publicado en <a href="http://puntoflotante.org/">http://puntoflotante.org/</a> bajo una licencia
65
+
<a href="http://creativecommons.org/licenses/by/3.0/deed.es">Creative Commons Atribución Unported (BY)</a>.
66
+
Original en inglés por Michael Borgwardt en
67
+
<a href="http://floating-point-gui.de/">http://floating-point-gui.de/</a>.</p>
68
+
</div>
69
+
</div>
70
+
<div id="sidebar">
71
+
<a href="/"><img src="/logo.png"></a>
72
+
<h2>La Guía del Punto Flotante</h2>
73
+
<ul>
74
+
<li><a href="http://floating-point-gui.de/" alt="in English"><img src="/en.png"></a></li>
75
+
<li><a href="/">Inicio</a></li>
76
+
<li><a href="/basic/">Respuestas básicas</a></li>
77
+
<li><a href="/references/">Referencias</a></li>
78
+
<li><a href="/xkcd/">xkcd</a></li>
79
+
</ul>
80
+
81
+
<h2>Formatos Numéricos</h2>
82
+
<ul>
83
+
<li><a href="/formats/binary/">Fracciones binarias</a></li>
84
+
<li><a href="/formats/fp/">Punto flotante</a></li>
85
+
<li><a href="/formats/exact/">Tipos exactos</a></li>
86
+
<li><a href="/formats/integer/">Sobre usar enteros</a></li>
87
+
</ul>
88
+
89
+
<h2>Errores</h2>
90
+
<ul>
91
+
<li><a href="/errors/rounding/">Redondeo</a></li>
92
+
<li><a href="/errors/comparison/">Comparación</a></li>
93
+
<li><a href="/errors/propagation/">Propagación</a></li>
94
+
</ul>
95
+
96
+
<h2>Cheat sheets</h2>
97
+
<ul>
98
+
<li><a href="/languages/csharp/">C#</a></li>
99
+
<li><a href="/languages/java/">Java</a></li>
100
+
<li><a href="/languages/javascript/">JavaScript</a></li>
101
+
<li><a href="/languages/perl/">Perl</a></li>
102
+
<li><a href="/languages/php/">PHP</a></li>
103
+
<li><a href="/languages/python/">Python</a></li>
104
+
<li><a href="/languages/sql/">SQL</a></li>
105
+
</ul>
106
+
</div>
107
+
<a href="http://github.com/Pybonacci/puntoflotante.org"><img style="position: absolute; top: 0; right: 0; border: 0;" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" alt="Fork me on GitHub" /></a>
108
+
109
+
</body>
110
+
</html>
+104
languages/csharp/index.html
+104
languages/csharp/index.html
···
1
+
<!DOCTYPE HTML>
2
+
<html lang="es">
3
+
<head>
4
+
<meta charset="utf-8">
5
+
<title>La Guía del Punto Flotante - Cheat sheet de punto flotante para C#</title>
6
+
7
+
<meta name="generator" content="nanoc 3.1.2">
8
+
9
+
<meta name="Description" content="Trucos para usar punto flotante y números decimales en C#">
10
+
11
+
<link rel="stylesheet" type="text/css" href="/style.css" media="screen">
12
+
<link rel="shortcut icon" href="/favicon.ico" type="image/vnd.microsoft.icon">
13
+
<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
14
+
</head>
15
+
<body>
16
+
<div id="main">
17
+
<h1>Cheat sheet de punto flotante para C#</h1>
18
+
<h2 id="tipos-de-punto-flotante">Tipos de punto flotante</h2>
19
+
20
+
<p>C# tiene tipos de precisión sencilla y doble del <a href="/formats/fp/">IEEE 754</a>
21
+
soportados por palabras clave:</p>
22
+
23
+
<pre><code> float f = 0.1f; // punto flotante de 32 bits, nótese el sufijo f
24
+
double d = 0.1d; // punto flotante de 64 bits, sufijo opcional
25
+
</code></pre>
26
+
27
+
<h2 id="tipos-decimales">Tipos decimales</h2>
28
+
29
+
<p>C# tiene un tipo decimal de 128 bit de <a href="/formats/exact/">precisión limitada</a>
30
+
denotado con la palabra clave <code>decimal</code>:</p>
31
+
32
+
<pre><code> decimal myMoney = 300.1m; // Nótese el sufijo m en el literal
33
+
</code></pre>
34
+
35
+
<h2 id="cmo-redondear">Cómo redondear</h2>
36
+
37
+
<p>El método <code>Math.Round()</code> funciona con los tipos <code>double</code> y <code>decimal</code>,
38
+
y permite especificar el <a href="/errors/rounding/">método de redondeo</a>:</p>
39
+
40
+
<pre><code> Math.Round(1.25m, 1, MidpointRounding.AwayFromZero); // Devuelve 1.3
41
+
</code></pre>
42
+
43
+
<h2 id="recursos">Recursos</h2>
44
+
45
+
<ul>
46
+
<li><a href="http://msdn.microsoft.com/en-us/library/618ayhy6%28v=VS.80%29.aspx">C# Reference</a>
47
+
<ul>
48
+
<li><a href="http://msdn.microsoft.com/en-us/library/b1e65aza%28v=VS.80%29.aspx">float type</a> </li>
49
+
<li><a href="http://msdn.microsoft.com/en-us/library/678hzkk9%28v=VS.80%29.aspx">double type</a> </li>
50
+
<li><a href="http://msdn.microsoft.com/en-us/library/364x0z75%28v=VS.80%29.aspx">decimal type</a> </li>
51
+
<li><a href="http://msdn.microsoft.com/en-US/library/system.math.round%28v=VS.80%29.aspx">Math.Round()</a></li>
52
+
</ul>
53
+
</li>
54
+
</ul>
55
+
56
+
<g:plusone href="http://puntoflotante.org/"></g:plusone>
57
+
<div id="license">
58
+
<p>© Publicado en <a href="http://puntoflotante.org/">http://puntoflotante.org/</a> bajo una licencia
59
+
<a href="http://creativecommons.org/licenses/by/3.0/deed.es">Creative Commons Atribución Unported (BY)</a>.
60
+
Original en inglés por Michael Borgwardt en
61
+
<a href="http://floating-point-gui.de/">http://floating-point-gui.de/</a>.</p>
62
+
</div>
63
+
</div>
64
+
<div id="sidebar">
65
+
<a href="/"><img src="/logo.png"></a>
66
+
<h2>La Guía del Punto Flotante</h2>
67
+
<ul>
68
+
<li><a href="http://floating-point-gui.de/" alt="in English"><img src="/en.png"></a></li>
69
+
<li><a href="/">Inicio</a></li>
70
+
<li><a href="/basic/">Respuestas básicas</a></li>
71
+
<li><a href="/references/">Referencias</a></li>
72
+
<li><a href="/xkcd/">xkcd</a></li>
73
+
</ul>
74
+
75
+
<h2>Formatos Numéricos</h2>
76
+
<ul>
77
+
<li><a href="/formats/binary/">Fracciones binarias</a></li>
78
+
<li><a href="/formats/fp/">Punto flotante</a></li>
79
+
<li><a href="/formats/exact/">Tipos exactos</a></li>
80
+
<li><a href="/formats/integer/">Sobre usar enteros</a></li>
81
+
</ul>
82
+
83
+
<h2>Errores</h2>
84
+
<ul>
85
+
<li><a href="/errors/rounding/">Redondeo</a></li>
86
+
<li><a href="/errors/comparison/">Comparación</a></li>
87
+
<li><a href="/errors/propagation/">Propagación</a></li>
88
+
</ul>
89
+
90
+
<h2>Cheat sheets</h2>
91
+
<ul>
92
+
<li><a href="/languages/csharp/">C#</a></li>
93
+
<li><a href="/languages/java/">Java</a></li>
94
+
<li><a href="/languages/javascript/">JavaScript</a></li>
95
+
<li><a href="/languages/perl/">Perl</a></li>
96
+
<li><a href="/languages/php/">PHP</a></li>
97
+
<li><a href="/languages/python/">Python</a></li>
98
+
<li><a href="/languages/sql/">SQL</a></li>
99
+
</ul>
100
+
</div>
101
+
<a href="http://github.com/Pybonacci/puntoflotante.org"><img style="position: absolute; top: 0; right: 0; border: 0;" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" alt="Fork me on GitHub" /></a>
102
+
103
+
</body>
104
+
</html>
+134
languages/java/index.html
+134
languages/java/index.html
···
1
+
<!DOCTYPE HTML>
2
+
<html lang="es">
3
+
<head>
4
+
<meta charset="utf-8">
5
+
<title>La Guía del Punto Flotante - Cheat sheet de punto flotante para Java</title>
6
+
7
+
<meta name="generator" content="nanoc 3.1.2">
8
+
9
+
<meta name="Description" content="Trucos para usar punto flotante y números decimales en Java">
10
+
11
+
<link rel="stylesheet" type="text/css" href="/style.css" media="screen">
12
+
<link rel="shortcut icon" href="/favicon.ico" type="image/vnd.microsoft.icon">
13
+
<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
14
+
</head>
15
+
<body>
16
+
<div id="main">
17
+
<h1>Cheat sheet de punto flotante para Java</h1>
18
+
<h2 id="tipos-de-punto-flotante">Tipos de punto flotante</h2>
19
+
20
+
<p>Java tiene tipos de precisión sencilla y doble del <a href="/formats/fp/">IEEE 754</a> soportados
21
+
por palabras clave:</p>
22
+
23
+
<pre><code> float f = 0.1f; // punto flotante de 32 bits, nótese el sufijo f
24
+
double d = 0.1d; // punto flotante de 64 bits, sufijo opcional
25
+
</code></pre>
26
+
27
+
<p>La palabra clave <code>strictfp</code> en las clases, interfaces y métodos fuerza también
28
+
a que todos los resultados intermedios de cálculos en punto flotante sean
29
+
valores IEEE 754, garantizando resultados idénticos en todas las plataformas.
30
+
Sin esa palabra clave, las implementaciones pueden usar un rango extendido para
31
+
el exponente, llevando a resultados más precisos y ejecuciones más rápidas
32
+
en bastantes CPUs.</p>
33
+
34
+
<h2 id="tipos-decimales">Tipos decimales</h2>
35
+
36
+
<p>Java tiene un tipo decimal de <a href="/formats/exact/">precisión arbitraria</a> llamado
37
+
<code>java.math.BigDecimal</code>, que también permite elegir el <a href="/errors/rounding/">método de redondeo</a>.</p>
38
+
39
+
<pre><code> BigDecimal a = new BigDecimal("0.1");
40
+
BigDecimal b = new BigDecimal("0.2");
41
+
BigDecimal c = a.add(b); // Devuelve un BigDecimal que representa exactamente 0.3
42
+
</code></pre>
43
+
44
+
<h2 id="cmo-redondear">Cómo redondear</h2>
45
+
46
+
<p>Para obtener una cadena:</p>
47
+
48
+
<pre><code> String.format("%.2f", 1.2399) // Devuelve "1.24"
49
+
String.format("%.3f", 1.2399) // Devuelve "1.240"
50
+
String.format("%.2f", 1.2) // Devuelve "1.20"
51
+
</code></pre>
52
+
53
+
<p>Para imprimir por la salida estándar (o cualquier <code>PrintStream</code>):</p>
54
+
55
+
<pre><code> System.out.printf("%.2f", 1.2399) // Misma sintaxis que String.format()
56
+
</code></pre>
57
+
58
+
<p>Si no quieres ceros a la derecha:</p>
59
+
60
+
<pre><code> new DecimalFormat("0.00").format(1.2)// Devuelve "1.20"
61
+
new DecimalFormat("0.##").format(1.2)// Devuelve "1.2"
62
+
</code></pre>
63
+
64
+
<p>Si necesitas un <a href="/errors/rounding/">método de redondeo</a> específico:</p>
65
+
66
+
<pre><code> new BigDecimal("1.25").setScale(1, RoundingMode.HALF_EVEN); // Devuelve 1.2
67
+
</code></pre>
68
+
69
+
<h2 id="recursos">Recursos</h2>
70
+
71
+
<ul>
72
+
<li><a href="http://java.sun.com/docs/books/jls/third_edition/html/j3TOC.html">Java Language Specification</a><br />
73
+
<ul>
74
+
<li><a href="http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3">Floating-Point Types, Formats, and Values</a></li>
75
+
</ul>
76
+
</li>
77
+
<li><a href="http://java.sun.com/javase/6/docs/api/">Java Standard API</a>
78
+
<ul>
79
+
<li><a href="http://download.oracle.com/javase/6/docs/api/java/math/BigDecimal.html">BigDecimal</a></li>
80
+
<li><a href="http://download.oracle.com/javase/6/docs/api/java/text/DecimalFormat.html">DecimalFormat</a></li>
81
+
<li><a href="http://download.oracle.com/javase/6/docs/api/java/lang/String.html#format(java.lang.String,%20java.lang.Object...)">String.format()</a></li>
82
+
</ul>
83
+
</li>
84
+
</ul>
85
+
86
+
<g:plusone href="http://puntoflotante.org/"></g:plusone>
87
+
<div id="license">
88
+
<p>© Publicado en <a href="http://puntoflotante.org/">http://puntoflotante.org/</a> bajo una licencia
89
+
<a href="http://creativecommons.org/licenses/by/3.0/deed.es">Creative Commons Atribución Unported (BY)</a>.
90
+
Original en inglés por Michael Borgwardt en
91
+
<a href="http://floating-point-gui.de/">http://floating-point-gui.de/</a>.</p>
92
+
</div>
93
+
</div>
94
+
<div id="sidebar">
95
+
<a href="/"><img src="/logo.png"></a>
96
+
<h2>La Guía del Punto Flotante</h2>
97
+
<ul>
98
+
<li><a href="http://floating-point-gui.de/" alt="in English"><img src="/en.png"></a></li>
99
+
<li><a href="/">Inicio</a></li>
100
+
<li><a href="/basic/">Respuestas básicas</a></li>
101
+
<li><a href="/references/">Referencias</a></li>
102
+
<li><a href="/xkcd/">xkcd</a></li>
103
+
</ul>
104
+
105
+
<h2>Formatos Numéricos</h2>
106
+
<ul>
107
+
<li><a href="/formats/binary/">Fracciones binarias</a></li>
108
+
<li><a href="/formats/fp/">Punto flotante</a></li>
109
+
<li><a href="/formats/exact/">Tipos exactos</a></li>
110
+
<li><a href="/formats/integer/">Sobre usar enteros</a></li>
111
+
</ul>
112
+
113
+
<h2>Errores</h2>
114
+
<ul>
115
+
<li><a href="/errors/rounding/">Redondeo</a></li>
116
+
<li><a href="/errors/comparison/">Comparación</a></li>
117
+
<li><a href="/errors/propagation/">Propagación</a></li>
118
+
</ul>
119
+
120
+
<h2>Cheat sheets</h2>
121
+
<ul>
122
+
<li><a href="/languages/csharp/">C#</a></li>
123
+
<li><a href="/languages/java/">Java</a></li>
124
+
<li><a href="/languages/javascript/">JavaScript</a></li>
125
+
<li><a href="/languages/perl/">Perl</a></li>
126
+
<li><a href="/languages/php/">PHP</a></li>
127
+
<li><a href="/languages/python/">Python</a></li>
128
+
<li><a href="/languages/sql/">SQL</a></li>
129
+
</ul>
130
+
</div>
131
+
<a href="http://github.com/Pybonacci/puntoflotante.org"><img style="position: absolute; top: 0; right: 0; border: 0;" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" alt="Fork me on GitHub" /></a>
132
+
133
+
</body>
134
+
</html>
+111
languages/javascript/index.html
+111
languages/javascript/index.html
···
1
+
<!DOCTYPE HTML>
2
+
<html lang="es">
3
+
<head>
4
+
<meta charset="utf-8">
5
+
<title>La Guía del Punto Flotante - Cheat sheet de punto flotante para JavaScript</title>
6
+
7
+
<meta name="generator" content="nanoc 3.1.2">
8
+
9
+
<meta name="Description" content="Trucos para usar punto flotante y números decimales en JavaScript">
10
+
11
+
<link rel="stylesheet" type="text/css" href="/style.css" media="screen">
12
+
<link rel="shortcut icon" href="/favicon.ico" type="image/vnd.microsoft.icon">
13
+
<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
14
+
</head>
15
+
<body>
16
+
<div id="main">
17
+
<h1>Cheat sheet de punto flotante para JavaScript</h1>
18
+
<h2 id="tipos-de-punto-flotante">Tipos de punto flotante</h2>
19
+
20
+
<p>JavaScript tiene tipado dinámico y a veces convertirá implícitamente entre cadenas
21
+
y números de punto flotante (que son valores IEEE de 64 bits). Para forzar una variable
22
+
a punto flotante, utiliza la función <code>parseFloat()</code>.</p>
23
+
24
+
<pre><code> var num = parseFloat("3.5");
25
+
</code></pre>
26
+
27
+
<h2 id="tipos-decimales">Tipos decimales</h2>
28
+
29
+
<p>El mejor tipo decimal para JavaScript parece ser una migración de la clase de
30
+
<a href="/languages/java/">Java</a> <code>BigDecimal</code>, que también soporta <a href="/errors/rounding/">métodos de redondeo</a>:</p>
31
+
32
+
<pre><code> var a = new BigDecimal("0.01");
33
+
var b = new BigDecimal("0.02");
34
+
var c = a.add(b); // 0.03
35
+
var d = c.setScale(1, BigDecimal.prototype.ROUND_HALF_UP);
36
+
</code></pre>
37
+
38
+
<h2 id="cmo-redondear">Cómo redondear</h2>
39
+
40
+
<pre><code> var num = 5.123456;
41
+
num.toPrecision(1) //Devuelve 5 como una cadena
42
+
num.toPrecision(2) //Devuelve 5.1 como una cadena
43
+
num.toPrecision(4) //Devuelve 5.123 como una cadena
44
+
</code></pre>
45
+
46
+
<p>Utilizando un método de redondeo específico:</p>
47
+
48
+
<pre><code> new BigDecimal("1.25").setScale(1, BigDecimal.prototype.ROUND_HALF_UP);
49
+
</code></pre>
50
+
51
+
<h2 id="recursos">Recursos</h2>
52
+
53
+
<ul>
54
+
<li><a href="https://github.com/dtrebbien/BigDecimal.js">BigDecimal for JavaScript</a></li>
55
+
<li><a href="https://developer.mozilla.org/en/JavaScript/Reference">Core JavaScript Reference</a><br />
56
+
<ul>
57
+
<li><a href="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/parseFloat">parseFloat()</a></li>
58
+
<li><a href="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Number/toPrecision">toPrecision()</a></li>
59
+
</ul>
60
+
</li>
61
+
</ul>
62
+
63
+
<g:plusone href="http://puntoflotante.org/"></g:plusone>
64
+
<div id="license">
65
+
<p>© Publicado en <a href="http://puntoflotante.org/">http://puntoflotante.org/</a> bajo una licencia
66
+
<a href="http://creativecommons.org/licenses/by/3.0/deed.es">Creative Commons Atribución Unported (BY)</a>.
67
+
Original en inglés por Michael Borgwardt en
68
+
<a href="http://floating-point-gui.de/">http://floating-point-gui.de/</a>.</p>
69
+
</div>
70
+
</div>
71
+
<div id="sidebar">
72
+
<a href="/"><img src="/logo.png"></a>
73
+
<h2>La Guía del Punto Flotante</h2>
74
+
<ul>
75
+
<li><a href="http://floating-point-gui.de/" alt="in English"><img src="/en.png"></a></li>
76
+
<li><a href="/">Inicio</a></li>
77
+
<li><a href="/basic/">Respuestas básicas</a></li>
78
+
<li><a href="/references/">Referencias</a></li>
79
+
<li><a href="/xkcd/">xkcd</a></li>
80
+
</ul>
81
+
82
+
<h2>Formatos Numéricos</h2>
83
+
<ul>
84
+
<li><a href="/formats/binary/">Fracciones binarias</a></li>
85
+
<li><a href="/formats/fp/">Punto flotante</a></li>
86
+
<li><a href="/formats/exact/">Tipos exactos</a></li>
87
+
<li><a href="/formats/integer/">Sobre usar enteros</a></li>
88
+
</ul>
89
+
90
+
<h2>Errores</h2>
91
+
<ul>
92
+
<li><a href="/errors/rounding/">Redondeo</a></li>
93
+
<li><a href="/errors/comparison/">Comparación</a></li>
94
+
<li><a href="/errors/propagation/">Propagación</a></li>
95
+
</ul>
96
+
97
+
<h2>Cheat sheets</h2>
98
+
<ul>
99
+
<li><a href="/languages/csharp/">C#</a></li>
100
+
<li><a href="/languages/java/">Java</a></li>
101
+
<li><a href="/languages/javascript/">JavaScript</a></li>
102
+
<li><a href="/languages/perl/">Perl</a></li>
103
+
<li><a href="/languages/php/">PHP</a></li>
104
+
<li><a href="/languages/python/">Python</a></li>
105
+
<li><a href="/languages/sql/">SQL</a></li>
106
+
</ul>
107
+
</div>
108
+
<a href="http://github.com/Pybonacci/puntoflotante.org"><img style="position: absolute; top: 0; right: 0; border: 0;" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" alt="Fork me on GitHub" /></a>
109
+
110
+
</body>
111
+
</html>
+138
languages/perl/index.html
+138
languages/perl/index.html
···
1
+
<!DOCTYPE HTML>
2
+
<html lang="es">
3
+
<head>
4
+
<meta charset="utf-8">
5
+
<title>La Guía del Punto Flotante - Cheat sheet de punto flotante para Perl</title>
6
+
7
+
<meta name="generator" content="nanoc 3.1.2">
8
+
9
+
<meta name="Description" content="Trucos para usar punto flotante y números decimales en Perl">
10
+
11
+
<link rel="stylesheet" type="text/css" href="/style.css" media="screen">
12
+
<link rel="shortcut icon" href="/favicon.ico" type="image/vnd.microsoft.icon">
13
+
<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
14
+
</head>
15
+
<body>
16
+
<div id="main">
17
+
<h1>Cheat sheet de punto flotante para Perl</h1>
18
+
<h2 id="tipos-de-punto-flotante">Tipos de punto flotante</h2>
19
+
20
+
<p>Perl soporta números de punto flotante nativos de la plataforma como valores
21
+
escalares; en la práctica esto significa precisión doble del <a href="/formats/fp/">IEEE 754</a>.</p>
22
+
23
+
<h2 id="tipos-exactos">Tipos exactos</h2>
24
+
25
+
<p>Perl también puede almacenar números decimales como cadenas, pero los operadores
26
+
aritméticos integrados los convertirán a enteros o a valores de punto flotante
27
+
para realizar la operación.</p>
28
+
29
+
<p>La extensión <code>Math::BigFloat</code> proporciona un <a href="/formats/exact/">tipo decimal</a> de
30
+
precisión arbitraria:</p>
31
+
32
+
<pre><code> use Math::BigFloat ':constant'
33
+
my $f = 0.1 + 0.2; # Devuelve exactamente 0.3
34
+
</code></pre>
35
+
36
+
<p>La extensión <code>Number::Fraction</code> proporciona un tipo de datos fraccionario que
37
+
sobrecarga los operadores con aritmética <a href="/formats/exact/">simbólica</a> para fracciones:</p>
38
+
39
+
<pre><code> use Number::Fraction ':constants';
40
+
my $f = '1/2' - '1/3'; # Devuelve 1/6
41
+
</code></pre>
42
+
43
+
<p>La extensión <code>Math::BigRat</code> proporciona funcionalidad similar. Su ventaja es
44
+
compatibilidad con las extensiones <code>Math::BigInt</code> y <code>Math::BigFloat</code>, pero
45
+
no parece soportar literales fraccionarios.</p>
46
+
47
+
<h2 id="cmo-redondear">Cómo redondear</h2>
48
+
49
+
<p>Para obtener una cadena:</p>
50
+
51
+
<pre><code> $result = sprintf("%.2f", 1.2345); # Devuelve 1.23
52
+
</code></pre>
53
+
54
+
<p>Para formatear la salida:</p>
55
+
56
+
<pre><code> printf("%.2f", 1.2); # Imprime 1.20
57
+
</code></pre>
58
+
59
+
<p>Ten en cuenta que esto utiliza implícitamente <a href="/errors/rounding/">mitad al par</a>.
60
+
La variable <code>$#</code> contiene el formato por defecto para imprimir números, pero
61
+
su uso se considera obsoleto.</p>
62
+
63
+
<p>La extensión <code>Math::Round</code> proporciona varias funciones para redondear valores
64
+
de punto flotante:</p>
65
+
66
+
<pre><code> use Math::Round qw(:all);
67
+
$result = nearest(.1, 4.567) # Imprime 4.6
68
+
$result = nearest(.01, 4.567) # Imprime 4.57
69
+
</code></pre>
70
+
71
+
<p>La extensión <code>Math::BigFloat</code> también soporta varios <a href="/errors/rounding/">métodos de redondeo</a>:</p>
72
+
73
+
<pre><code> use Math::BigFloat;
74
+
my $n = Math::BigFloat->new(123.455);
75
+
my $f1 = $n->round('','-2','common'); # Devuelve 123.46
76
+
my $f2 = $n->round('','-2','zero'); # Devuelve 123.45
77
+
</code></pre>
78
+
79
+
<h2 id="recursos">Recursos</h2>
80
+
81
+
<ul>
82
+
<li><a href="http://perldoc.perl.org/perlnumber.html">Semantics of numbers and numeric operations in Perl</a></li>
83
+
<li><a href="http://perldoc.perl.org/functions/sprintf.html">sprintf function</a></li>
84
+
<li><a href="http://search.cpan.org/dist/Math-Round/Round.pm">Math::Round extension</a></li>
85
+
<li><a href="http://search.cpan.org/~davecross/Number-Fraction-1.13/lib/Number/Fraction.pm">Number::Fraction extension</a></li>
86
+
<li><a href="http://search.cpan.org/~flora/Math-BigRat-0.26/lib/Math/BigRat.pm">Math::BigRat extension</a></li>
87
+
<li><a href="http://search.cpan.org/~flora/Math-BigInt-1.95/lib/Math/BigFloat.pm">Math::BigFloat extension</a></li>
88
+
</ul>
89
+
90
+
<g:plusone href="http://puntoflotante.org/"></g:plusone>
91
+
<div id="license">
92
+
<p>© Publicado en <a href="http://puntoflotante.org/">http://puntoflotante.org/</a> bajo una licencia
93
+
<a href="http://creativecommons.org/licenses/by/3.0/deed.es">Creative Commons Atribución Unported (BY)</a>.
94
+
Original en inglés por Michael Borgwardt en
95
+
<a href="http://floating-point-gui.de/">http://floating-point-gui.de/</a>.</p>
96
+
</div>
97
+
</div>
98
+
<div id="sidebar">
99
+
<a href="/"><img src="/logo.png"></a>
100
+
<h2>La Guía del Punto Flotante</h2>
101
+
<ul>
102
+
<li><a href="http://floating-point-gui.de/" alt="in English"><img src="/en.png"></a></li>
103
+
<li><a href="/">Inicio</a></li>
104
+
<li><a href="/basic/">Respuestas básicas</a></li>
105
+
<li><a href="/references/">Referencias</a></li>
106
+
<li><a href="/xkcd/">xkcd</a></li>
107
+
</ul>
108
+
109
+
<h2>Formatos Numéricos</h2>
110
+
<ul>
111
+
<li><a href="/formats/binary/">Fracciones binarias</a></li>
112
+
<li><a href="/formats/fp/">Punto flotante</a></li>
113
+
<li><a href="/formats/exact/">Tipos exactos</a></li>
114
+
<li><a href="/formats/integer/">Sobre usar enteros</a></li>
115
+
</ul>
116
+
117
+
<h2>Errores</h2>
118
+
<ul>
119
+
<li><a href="/errors/rounding/">Redondeo</a></li>
120
+
<li><a href="/errors/comparison/">Comparación</a></li>
121
+
<li><a href="/errors/propagation/">Propagación</a></li>
122
+
</ul>
123
+
124
+
<h2>Cheat sheets</h2>
125
+
<ul>
126
+
<li><a href="/languages/csharp/">C#</a></li>
127
+
<li><a href="/languages/java/">Java</a></li>
128
+
<li><a href="/languages/javascript/">JavaScript</a></li>
129
+
<li><a href="/languages/perl/">Perl</a></li>
130
+
<li><a href="/languages/php/">PHP</a></li>
131
+
<li><a href="/languages/python/">Python</a></li>
132
+
<li><a href="/languages/sql/">SQL</a></li>
133
+
</ul>
134
+
</div>
135
+
<a href="http://github.com/Pybonacci/puntoflotante.org"><img style="position: absolute; top: 0; right: 0; border: 0;" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" alt="Fork me on GitHub" /></a>
136
+
137
+
</body>
138
+
</html>
+106
languages/php/index.html
+106
languages/php/index.html
···
1
+
<!DOCTYPE HTML>
2
+
<html lang="es">
3
+
<head>
4
+
<meta charset="utf-8">
5
+
<title>La Guía del Punto Flotante - Cheat sheet de punto flotante para PHP</title>
6
+
7
+
<meta name="generator" content="nanoc 3.1.2">
8
+
9
+
<meta name="Description" content="Trucos para usar punto flotante y números decimales en PHP">
10
+
11
+
<link rel="stylesheet" type="text/css" href="/style.css" media="screen">
12
+
<link rel="shortcut icon" href="/favicon.ico" type="image/vnd.microsoft.icon">
13
+
<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
14
+
</head>
15
+
<body>
16
+
<div id="main">
17
+
<h1>Cheat sheet de punto flotante para PHP</h1>
18
+
<h2 id="tipos-de-punto-flotante">Tipos de punto flotante</h2>
19
+
20
+
<p>PHP tiene tipado dinámico y a veces convertirá implícitamente entre cadenas y
21
+
números de punto flotante (que son dependientes de la plataforma, pero normalmente
22
+
valores IEEE de 64 bits). Para forzar un valor a punto flotante, evalúalo en un
23
+
contexto numérico: </p>
24
+
25
+
<pre><code> $foo = 0 + "10.5";
26
+
</code></pre>
27
+
28
+
<h2 id="tipos-decimales">Tipos decimales</h2>
29
+
30
+
<p>La extensión BCMath (Binary Calculator) implementa aritmética de <a href="/formats/exact/">precisión
31
+
arbitraria</a> decimal:</p>
32
+
33
+
<pre><code> $a = '0.1';
34
+
$b = '0.2';
35
+
echo bcadd($a, $b); // Imprime 0.3
36
+
</code></pre>
37
+
38
+
<h2 id="cmo-redondear">Cómo redondear</h2>
39
+
40
+
<p>Redondear se puede hacer con la función <code>number_format()</code>:</p>
41
+
42
+
<pre><code> $number = 4.123;
43
+
echo number_format($number, 2); // Imprime 4.12
44
+
</code></pre>
45
+
46
+
<h2 id="recursos">Recursos</h2>
47
+
48
+
<ul>
49
+
<li><a href="http://www.php.net/manual/en/index.php">PHP manual</a>
50
+
<ul>
51
+
<li><a href="http://www.php.net/manual/en/language.types.float.php">Floating point types</a></li>
52
+
<li><a href="http://de3.php.net/manual/en/ref.bc.php">BC Math extension</a></li>
53
+
<li><a href="http://de3.php.net/manual/en/function.number-format.php">number_format()</a></li>
54
+
</ul>
55
+
</li>
56
+
</ul>
57
+
58
+
<g:plusone href="http://puntoflotante.org/"></g:plusone>
59
+
<div id="license">
60
+
<p>© Publicado en <a href="http://puntoflotante.org/">http://puntoflotante.org/</a> bajo una licencia
61
+
<a href="http://creativecommons.org/licenses/by/3.0/deed.es">Creative Commons Atribución Unported (BY)</a>.
62
+
Original en inglés por Michael Borgwardt en
63
+
<a href="http://floating-point-gui.de/">http://floating-point-gui.de/</a>.</p>
64
+
</div>
65
+
</div>
66
+
<div id="sidebar">
67
+
<a href="/"><img src="/logo.png"></a>
68
+
<h2>La Guía del Punto Flotante</h2>
69
+
<ul>
70
+
<li><a href="http://floating-point-gui.de/" alt="in English"><img src="/en.png"></a></li>
71
+
<li><a href="/">Inicio</a></li>
72
+
<li><a href="/basic/">Respuestas básicas</a></li>
73
+
<li><a href="/references/">Referencias</a></li>
74
+
<li><a href="/xkcd/">xkcd</a></li>
75
+
</ul>
76
+
77
+
<h2>Formatos Numéricos</h2>
78
+
<ul>
79
+
<li><a href="/formats/binary/">Fracciones binarias</a></li>
80
+
<li><a href="/formats/fp/">Punto flotante</a></li>
81
+
<li><a href="/formats/exact/">Tipos exactos</a></li>
82
+
<li><a href="/formats/integer/">Sobre usar enteros</a></li>
83
+
</ul>
84
+
85
+
<h2>Errores</h2>
86
+
<ul>
87
+
<li><a href="/errors/rounding/">Redondeo</a></li>
88
+
<li><a href="/errors/comparison/">Comparación</a></li>
89
+
<li><a href="/errors/propagation/">Propagación</a></li>
90
+
</ul>
91
+
92
+
<h2>Cheat sheets</h2>
93
+
<ul>
94
+
<li><a href="/languages/csharp/">C#</a></li>
95
+
<li><a href="/languages/java/">Java</a></li>
96
+
<li><a href="/languages/javascript/">JavaScript</a></li>
97
+
<li><a href="/languages/perl/">Perl</a></li>
98
+
<li><a href="/languages/php/">PHP</a></li>
99
+
<li><a href="/languages/python/">Python</a></li>
100
+
<li><a href="/languages/sql/">SQL</a></li>
101
+
</ul>
102
+
</div>
103
+
<a href="http://github.com/Pybonacci/puntoflotante.org"><img style="position: absolute; top: 0; right: 0; border: 0;" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" alt="Fork me on GitHub" /></a>
104
+
105
+
</body>
106
+
</html>
+122
languages/python/index.html
+122
languages/python/index.html
···
1
+
<!DOCTYPE HTML>
2
+
<html lang="es">
3
+
<head>
4
+
<meta charset="utf-8">
5
+
<title>La Guía del Punto Flotante - Cheat sheet de punto flotante para Python</title>
6
+
7
+
<meta name="generator" content="nanoc 3.1.2">
8
+
9
+
<meta name="Description" content="Trucos para usar punto flotante y números decimales en Python">
10
+
11
+
<link rel="stylesheet" type="text/css" href="/style.css" media="screen">
12
+
<link rel="shortcut icon" href="/favicon.ico" type="image/vnd.microsoft.icon">
13
+
<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
14
+
</head>
15
+
<body>
16
+
<div id="main">
17
+
<h1>Cheat sheet de punto flotante para Python</h1>
18
+
<h2 id="tipos-de-punto-flotante">Tipos de punto flotante</h2>
19
+
20
+
<p>Casi todas las plataformas asocian los <code>float</code> de Python a números de punto
21
+
flotante de doble precisión del <a href="/formats/fp/">IEEE 754</a>.</p>
22
+
23
+
<pre><code> f = 0.1
24
+
</code></pre>
25
+
26
+
<h2 id="tipos-decimales">Tipos decimales</h2>
27
+
28
+
<p>Python tiene un tipo de <a href="/formats/exact/">precisión arbitraria</a> decimal llamado
29
+
<code>Decimal</code> en el módulo <code>decimal</code>, que también permite elegir el <a href="/errors/rounding/">método de
30
+
redondeo</a>.</p>
31
+
32
+
<pre><code> a = Decimal('0.1')
33
+
b = Decimal('0.2')
34
+
c = a + b # Devuelve un Decimal que representa exactamente 0.3
35
+
</code></pre>
36
+
37
+
<h2 id="cmo-redondear">Cómo redondear</h2>
38
+
39
+
<p>Para obtener una cadena:</p>
40
+
41
+
<pre><code> "{:.2f}".format(1.2399) # Devuelve "1.24"
42
+
"{:.3f}".format(1.2399) # Devuelve "1.240"
43
+
"{:.2f}".format(1.2) # Devuelve "1.20"
44
+
</code></pre>
45
+
46
+
<p>Para imprimir por la salida estándar (Python 2.x):</p>
47
+
48
+
<pre><code> print "{:.2f}".format(1.2399)
49
+
</code></pre>
50
+
51
+
<p>y en Python 3.x:</p>
52
+
53
+
<pre><code> print("{:.2f}".format(1.2399))
54
+
</code></pre>
55
+
56
+
<p><a href="/errors/rounding/">Métodos de redondeo</a> específicos y otros parámetros se pueden
57
+
definir en un objeto <code>Context</code>:</p>
58
+
59
+
<pre><code> getcontext().prec = 7
60
+
</code></pre>
61
+
62
+
<h2 id="recursos">Recursos</h2>
63
+
64
+
<ul>
65
+
<li><a href="http://docs.python.org/tutorial/floatingpoint.html">Floating Point Arithmetic: Issues and Limitations</a></li>
66
+
<li><a href="http://docs.python.org/library/decimal.html">The decimal module</a>
67
+
<ul>
68
+
<li><a href="http://docs.python.org/library/decimal.html#context-objects">Context objects</a></li>
69
+
</ul>
70
+
</li>
71
+
<li><a href="http://docs.python.org/library/stdtypes.html#string-formatting-operations">String formatting in Python</a></li>
72
+
</ul>
73
+
74
+
<g:plusone href="http://puntoflotante.org/"></g:plusone>
75
+
<div id="license">
76
+
<p>© Publicado en <a href="http://puntoflotante.org/">http://puntoflotante.org/</a> bajo una licencia
77
+
<a href="http://creativecommons.org/licenses/by/3.0/deed.es">Creative Commons Atribución Unported (BY)</a>.
78
+
Original en inglés por Michael Borgwardt en
79
+
<a href="http://floating-point-gui.de/">http://floating-point-gui.de/</a>.</p>
80
+
</div>
81
+
</div>
82
+
<div id="sidebar">
83
+
<a href="/"><img src="/logo.png"></a>
84
+
<h2>La Guía del Punto Flotante</h2>
85
+
<ul>
86
+
<li><a href="http://floating-point-gui.de/" alt="in English"><img src="/en.png"></a></li>
87
+
<li><a href="/">Inicio</a></li>
88
+
<li><a href="/basic/">Respuestas básicas</a></li>
89
+
<li><a href="/references/">Referencias</a></li>
90
+
<li><a href="/xkcd/">xkcd</a></li>
91
+
</ul>
92
+
93
+
<h2>Formatos Numéricos</h2>
94
+
<ul>
95
+
<li><a href="/formats/binary/">Fracciones binarias</a></li>
96
+
<li><a href="/formats/fp/">Punto flotante</a></li>
97
+
<li><a href="/formats/exact/">Tipos exactos</a></li>
98
+
<li><a href="/formats/integer/">Sobre usar enteros</a></li>
99
+
</ul>
100
+
101
+
<h2>Errores</h2>
102
+
<ul>
103
+
<li><a href="/errors/rounding/">Redondeo</a></li>
104
+
<li><a href="/errors/comparison/">Comparación</a></li>
105
+
<li><a href="/errors/propagation/">Propagación</a></li>
106
+
</ul>
107
+
108
+
<h2>Cheat sheets</h2>
109
+
<ul>
110
+
<li><a href="/languages/csharp/">C#</a></li>
111
+
<li><a href="/languages/java/">Java</a></li>
112
+
<li><a href="/languages/javascript/">JavaScript</a></li>
113
+
<li><a href="/languages/perl/">Perl</a></li>
114
+
<li><a href="/languages/php/">PHP</a></li>
115
+
<li><a href="/languages/python/">Python</a></li>
116
+
<li><a href="/languages/sql/">SQL</a></li>
117
+
</ul>
118
+
</div>
119
+
<a href="http://github.com/Pybonacci/puntoflotante.org"><img style="position: absolute; top: 0; right: 0; border: 0;" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" alt="Fork me on GitHub" /></a>
120
+
121
+
</body>
122
+
</html>
+110
languages/sql/index.html
+110
languages/sql/index.html
···
1
+
<!DOCTYPE HTML>
2
+
<html lang="es">
3
+
<head>
4
+
<meta charset="utf-8">
5
+
<title>La Guía del Punto Flotante - Cheat sheet de punto flotante para SQL</title>
6
+
7
+
<meta name="generator" content="nanoc 3.1.2">
8
+
9
+
<meta name="Description" content="Trucos para usar punto flotante y números decimales en SQL">
10
+
11
+
<link rel="stylesheet" type="text/css" href="/style.css" media="screen">
12
+
<link rel="shortcut icon" href="/favicon.ico" type="image/vnd.microsoft.icon">
13
+
<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
14
+
</head>
15
+
<body>
16
+
<div id="main">
17
+
<h1>Cheat sheet de punto flotante para SQL</h1>
18
+
<h2 id="tipos-de-punto-flotante">Tipos de punto flotante</h2>
19
+
20
+
<p>El estándar SQL define tres tipos de punto flotante binarios:</p>
21
+
22
+
<ul>
23
+
<li><code>REAL</code> tiene precisión dependiente de la implementación (normalmente se asocia a un tipo a nivel de hardware como precisión sencilla o doble del IEEE 754).</li>
24
+
<li><code>DOUBLE PRECISION</code> tiene precisión dependiente de la implementación que es mayor que la de <code>REAL</code> (normalmente se asocia al precisión doble del IEEE 754).</li>
25
+
<li><code>FLOAT(N)</code> tiene al menos <code>N</code> dígitos binarios de precisión, con un máximo para <code>N</code> que depende de la implementación.</li>
26
+
</ul>
27
+
28
+
<p>El rango del exponente para los tres tipos también depende de la implementación.</p>
29
+
30
+
<h2 id="tipos-decimales">Tipos decimales</h2>
31
+
32
+
<p>El estándar define dos tipos decimales de punto fijo:</p>
33
+
34
+
<ul>
35
+
<li><code>NUMERIC(M,N)</code> tiene exactamente <code>M</code> dígitos en total, <code>N</code> de los cuales después del punto decimal.</li>
36
+
<li><code>DECIMAL(M,N)</code> es lo mismo que <code>NUMERIC(M,N)</code>, excepto porque permite tener más de <code>M</code> dígitos totales.</li>
37
+
</ul>
38
+
39
+
<p>Los valores máximos de <code>M</code> y <code>N</code> dependen de la implementación. Los proveedores
40
+
normalmente implementan los dos tipos de manera idéntica.</p>
41
+
42
+
<h2 id="cmo-redondear">Cómo redondear</h2>
43
+
44
+
<p>El estándar SQL no define explícitamente el redondeo, pero la mayoría de los
45
+
proveedores proporciona una función <code>ROUND()</code> o <code>TRUNC()</code>.</p>
46
+
47
+
<p>Sin embargo, normalmente no tiene mucho sentido redondear dentro de la base de
48
+
datos, puesto que su función es <em>almacenar</em> los datos, mientras que redondear
49
+
es un aspecto de la <em>representación</em> de los datos, y debe por tanto hacerse
50
+
en el código de la capa de presentación.</p>
51
+
52
+
<h2 id="recursos">Recursos</h2>
53
+
54
+
<ul>
55
+
<li><a href="http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=38640">Official ISO SQL 2008 standard (non-free)</a> </li>
56
+
<li><a href="http://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt">SQL 92 draft (free)</a></li>
57
+
<li><a href="http://dev.mysql.com/doc/refman/5.0/en/numeric-types.html">MySQL numeric types</a></li>
58
+
<li><a href="http://www.postgresql.org/docs/8.1/static/datatype.html">PostgreSQL data types</a></li>
59
+
<li><a href="http://msdn.microsoft.com/en-US/library/ms187752%28v=SQL.90%29.aspx">MS SQL Server data types</a></li>
60
+
</ul>
61
+
62
+
<g:plusone href="http://puntoflotante.org/"></g:plusone>
63
+
<div id="license">
64
+
<p>© Publicado en <a href="http://puntoflotante.org/">http://puntoflotante.org/</a> bajo una licencia
65
+
<a href="http://creativecommons.org/licenses/by/3.0/deed.es">Creative Commons Atribución Unported (BY)</a>.
66
+
Original en inglés por Michael Borgwardt en
67
+
<a href="http://floating-point-gui.de/">http://floating-point-gui.de/</a>.</p>
68
+
</div>
69
+
</div>
70
+
<div id="sidebar">
71
+
<a href="/"><img src="/logo.png"></a>
72
+
<h2>La Guía del Punto Flotante</h2>
73
+
<ul>
74
+
<li><a href="http://floating-point-gui.de/" alt="in English"><img src="/en.png"></a></li>
75
+
<li><a href="/">Inicio</a></li>
76
+
<li><a href="/basic/">Respuestas básicas</a></li>
77
+
<li><a href="/references/">Referencias</a></li>
78
+
<li><a href="/xkcd/">xkcd</a></li>
79
+
</ul>
80
+
81
+
<h2>Formatos Numéricos</h2>
82
+
<ul>
83
+
<li><a href="/formats/binary/">Fracciones binarias</a></li>
84
+
<li><a href="/formats/fp/">Punto flotante</a></li>
85
+
<li><a href="/formats/exact/">Tipos exactos</a></li>
86
+
<li><a href="/formats/integer/">Sobre usar enteros</a></li>
87
+
</ul>
88
+
89
+
<h2>Errores</h2>
90
+
<ul>
91
+
<li><a href="/errors/rounding/">Redondeo</a></li>
92
+
<li><a href="/errors/comparison/">Comparación</a></li>
93
+
<li><a href="/errors/propagation/">Propagación</a></li>
94
+
</ul>
95
+
96
+
<h2>Cheat sheets</h2>
97
+
<ul>
98
+
<li><a href="/languages/csharp/">C#</a></li>
99
+
<li><a href="/languages/java/">Java</a></li>
100
+
<li><a href="/languages/javascript/">JavaScript</a></li>
101
+
<li><a href="/languages/perl/">Perl</a></li>
102
+
<li><a href="/languages/php/">PHP</a></li>
103
+
<li><a href="/languages/python/">Python</a></li>
104
+
<li><a href="/languages/sql/">SQL</a></li>
105
+
</ul>
106
+
</div>
107
+
<a href="http://github.com/Pybonacci/puntoflotante.org"><img style="position: absolute; top: 0; right: 0; border: 0;" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" alt="Fork me on GitHub" /></a>
108
+
109
+
</body>
110
+
</html>
-69
layouts/default.html
-69
layouts/default.html
···
1
-
<!DOCTYPE HTML>
2
-
<html lang="es">
3
-
<head>
4
-
<meta charset="utf-8">
5
-
<title>La Guía del Punto Flotante - <%= @item[:title] %></title>
6
-
<% if @item[:verification] %>
7
-
<meta name="google-site-verification" content="5yrVDy61XOxulQRv7qIErl1GX_Y9M4LmRWg47olpdIM" />
8
-
<% end %>
9
-
<meta name="generator" content="nanoc 3.1.2">
10
-
<% if @item[:description] %>
11
-
<meta name="Description" content="<%= @item[:description] %>">
12
-
<% end %>
13
-
<link rel="stylesheet" type="text/css" href="/style.css" media="screen">
14
-
<link rel="shortcut icon" href="/favicon.ico" type="image/vnd.microsoft.icon">
15
-
<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
16
-
</head>
17
-
<body>
18
-
<div id="main">
19
-
<h1><%= @item[:title] %></h1>
20
-
<%= yield %>
21
-
<g:plusone href="http://puntoflotante.org/"></g:plusone>
22
-
<div id="license">
23
-
<p>© Publicado en <a href="http://puntoflotante.org/">http://puntoflotante.org/</a> bajo una licencia
24
-
<a href="http://creativecommons.org/licenses/by/3.0/deed.es">Creative Commons Atribución Unported (BY)</a>.
25
-
Original en inglés por Michael Borgwardt en
26
-
<a href="http://floating-point-gui.de/">http://floating-point-gui.de/</a>.</p>
27
-
</div>
28
-
</div>
29
-
<div id="sidebar">
30
-
<a href="/"><img src="/logo.png"></a>
31
-
<h2>La Guía del Punto Flotante</h2>
32
-
<ul>
33
-
<li><a href="http://floating-point-gui.de/" alt="in English"><img src="/en.png"></a></li>
34
-
<li><a href="/">Inicio</a></li>
35
-
<li><a href="/basic/">Respuestas básicas</a></li>
36
-
<li><a href="/references/">Referencias</a></li>
37
-
<li><a href="/xkcd/">xkcd</a></li>
38
-
</ul>
39
-
40
-
<h2>Formatos Numéricos</h2>
41
-
<ul>
42
-
<li><a href="/formats/binary/">Fracciones binarias</a></li>
43
-
<li><a href="/formats/fp/">Punto flotante</a></li>
44
-
<li><a href="/formats/exact/">Tipos exactos</a></li>
45
-
<li><a href="/formats/integer/">Sobre usar enteros</a></li>
46
-
</ul>
47
-
48
-
<h2>Errores</h2>
49
-
<ul>
50
-
<li><a href="/errors/rounding/">Redondeo</a></li>
51
-
<li><a href="/errors/comparison/">Comparación</a></li>
52
-
<li><a href="/errors/propagation/">Propagación</a></li>
53
-
</ul>
54
-
55
-
<h2>Cheat sheets</h2>
56
-
<ul>
57
-
<li><a href="/languages/csharp/">C#</a></li>
58
-
<li><a href="/languages/java/">Java</a></li>
59
-
<li><a href="/languages/javascript/">JavaScript</a></li>
60
-
<li><a href="/languages/perl/">Perl</a></li>
61
-
<li><a href="/languages/php/">PHP</a></li>
62
-
<li><a href="/languages/python/">Python</a></li>
63
-
<li><a href="/languages/sql/">SQL</a></li>
64
-
</ul>
65
-
</div>
66
-
<a href="http://github.com/Pybonacci/puntoflotante.org"><img style="position: absolute; top: 0; right: 0; border: 0;" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" alt="Fork me on GitHub" /></a>
67
-
68
-
</body>
69
-
</html>
-2
lib/default.rb
-2
lib/default.rb
logo.png
logo.png
This is a binary file and will not be displayed.
+77
references/index.html
+77
references/index.html
···
1
+
<!DOCTYPE HTML>
2
+
<html lang="es">
3
+
<head>
4
+
<meta charset="utf-8">
5
+
<title>La Guía del Punto Flotante - Referencias</title>
6
+
7
+
<meta name="generator" content="nanoc 3.1.2">
8
+
9
+
<meta name="Description" content="Documentos con más información detallada sobre aritmética de punto flotante">
10
+
11
+
<link rel="stylesheet" type="text/css" href="/style.css" media="screen">
12
+
<link rel="shortcut icon" href="/favicon.ico" type="image/vnd.microsoft.icon">
13
+
<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
14
+
</head>
15
+
<body>
16
+
<div id="main">
17
+
<h1>Referencias</h1>
18
+
<p>Documentos que contienen más información detallada sobre los temas tratados en este sitio:</p>
19
+
20
+
<ul>
21
+
<li><a href="http://grouper.ieee.org/groups/754/">Página del estándar IEEE 754</a></li>
22
+
<li><a href="http://download.oracle.com/docs/cd/E19957-01/806-3568/ncg_goldberg.html">What Every Computer Scientist Should Know About Floating-Point Arithmetic</a></li>
23
+
<li><a href="http://www.cs.berkeley.edu/~wkahan/">Página de William Kahan</a> (arquitecto del estándar IEEE 754, muchos enlaces interesantes)</li>
24
+
<li><a href="http://speleotrove.com/decimal/decifaq.html">Decimal Arithmetic FAQ </a></li>
25
+
<li><a href="http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/">Comparing floating point numbers, 2012 edition</a></li>
26
+
<li><a href="http://www.easysurf.cc/cnver17.htm">Herramienta para convertir números entre bases, incluyendo fracciones</a></li>
27
+
</ul>
28
+
29
+
<g:plusone href="http://puntoflotante.org/"></g:plusone>
30
+
<div id="license">
31
+
<p>© Publicado en <a href="http://puntoflotante.org/">http://puntoflotante.org/</a> bajo una licencia
32
+
<a href="http://creativecommons.org/licenses/by/3.0/deed.es">Creative Commons Atribución Unported (BY)</a>.
33
+
Original en inglés por Michael Borgwardt en
34
+
<a href="http://floating-point-gui.de/">http://floating-point-gui.de/</a>.</p>
35
+
</div>
36
+
</div>
37
+
<div id="sidebar">
38
+
<a href="/"><img src="/logo.png"></a>
39
+
<h2>La Guía del Punto Flotante</h2>
40
+
<ul>
41
+
<li><a href="http://floating-point-gui.de/" alt="in English"><img src="/en.png"></a></li>
42
+
<li><a href="/">Inicio</a></li>
43
+
<li><a href="/basic/">Respuestas básicas</a></li>
44
+
<li><a href="/references/">Referencias</a></li>
45
+
<li><a href="/xkcd/">xkcd</a></li>
46
+
</ul>
47
+
48
+
<h2>Formatos Numéricos</h2>
49
+
<ul>
50
+
<li><a href="/formats/binary/">Fracciones binarias</a></li>
51
+
<li><a href="/formats/fp/">Punto flotante</a></li>
52
+
<li><a href="/formats/exact/">Tipos exactos</a></li>
53
+
<li><a href="/formats/integer/">Sobre usar enteros</a></li>
54
+
</ul>
55
+
56
+
<h2>Errores</h2>
57
+
<ul>
58
+
<li><a href="/errors/rounding/">Redondeo</a></li>
59
+
<li><a href="/errors/comparison/">Comparación</a></li>
60
+
<li><a href="/errors/propagation/">Propagación</a></li>
61
+
</ul>
62
+
63
+
<h2>Cheat sheets</h2>
64
+
<ul>
65
+
<li><a href="/languages/csharp/">C#</a></li>
66
+
<li><a href="/languages/java/">Java</a></li>
67
+
<li><a href="/languages/javascript/">JavaScript</a></li>
68
+
<li><a href="/languages/perl/">Perl</a></li>
69
+
<li><a href="/languages/php/">PHP</a></li>
70
+
<li><a href="/languages/python/">Python</a></li>
71
+
<li><a href="/languages/sql/">SQL</a></li>
72
+
</ul>
73
+
</div>
74
+
<a href="http://github.com/Pybonacci/puntoflotante.org"><img style="position: absolute; top: 0; right: 0; border: 0;" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" alt="Fork me on GitHub" /></a>
75
+
76
+
</body>
77
+
</html>
+133
style.css
+133
style.css
···
1
+
* {
2
+
font-family: Helvetica, Arial, sans-serif;
3
+
}
4
+
5
+
pre, code, tt {
6
+
font-family: Courier, monospace;
7
+
}
8
+
9
+
body {
10
+
background: #ffffee;
11
+
}
12
+
13
+
table {
14
+
border: 1px solid black;
15
+
border-collapse: collapse;
16
+
}
17
+
td{
18
+
border: 1px solid black;
19
+
padding: 5px;
20
+
}
21
+
tr.base_example td{
22
+
font-weight:bold;
23
+
border-left:none;
24
+
border-right:none;
25
+
border-top: 1px solid black;
26
+
border-bottom: 1px solid black;
27
+
padding: 2px;
28
+
vertical-align:bottom;
29
+
}
30
+
tr.base_example td.separator{
31
+
background: #fff0f0;
32
+
border: 1px solid black;
33
+
padding: 5px;
34
+
}
35
+
tr.base_example td.digit{
36
+
color: #ff0000
37
+
}
38
+
th {
39
+
border: 1px solid black;
40
+
padding: 5px;
41
+
background: #fff0f0;
42
+
text-align: left;
43
+
}
44
+
45
+
.num_base{
46
+
color: #0000ff
47
+
}
48
+
49
+
.num_base sup{
50
+
color: #000000
51
+
}
52
+
span.over {
53
+
text-decoration: overline;
54
+
}
55
+
56
+
a img {
57
+
border: none;
58
+
}
59
+
60
+
#main {
61
+
position: absolute;
62
+
63
+
top: 10px;
64
+
left: 280px;
65
+
margin-right:100px;
66
+
}
67
+
68
+
#main h1 {
69
+
font-size: 30px;
70
+
line-height: 30px;
71
+
}
72
+
73
+
#main p {
74
+
margin: 20px 0;
75
+
76
+
font-size: 15px;
77
+
78
+
line-height: 20px;
79
+
}
80
+
81
+
#main li {
82
+
83
+
font-size: 15px;
84
+
85
+
line-height: 20px;
86
+
}
87
+
88
+
#main ul li {
89
+
list-style-type: square;
90
+
}
91
+
92
+
#main ol li {
93
+
list-style-type: decimal;
94
+
}
95
+
96
+
#sidebar {
97
+
position: absolute;
98
+
99
+
top: 10px;
100
+
left: 20px;
101
+
width: 200px;
102
+
103
+
padding: 20px 20px 0 0;
104
+
105
+
border-right: 1px solid #ccc;
106
+
107
+
text-align: right;
108
+
}
109
+
110
+
#sidebar h2 {
111
+
text-transform: uppercase;
112
+
font-size: 13px;
113
+
color: #333;
114
+
letter-spacing: 1px;
115
+
line-height: 20px;
116
+
margin-top: 30px;
117
+
margin-bottom: 5px;
118
+
}
119
+
120
+
#sidebar ul {
121
+
list-style-type: none;
122
+
margin-top: 0px;
123
+
}
124
+
125
+
#sidebar li {
126
+
font-size: 14px;
127
+
line-height: 20px;
128
+
}
129
+
#license p {
130
+
margin-top: 30px;
131
+
font-size: 10px;
132
+
text-align:center;
133
+
}
+74
xkcd/index.html
+74
xkcd/index.html
···
1
+
<!DOCTYPE HTML>
2
+
<html lang="es">
3
+
<head>
4
+
<meta charset="utf-8">
5
+
<title>La Guía del Punto Flotante - xkcd</title>
6
+
7
+
<meta name="generator" content="nanoc 3.1.2">
8
+
9
+
<meta name="Description" content="Cómo fastidiar a la gente que ha aprendido a *esperar* errores de redondeo en aritmética de punto flotante">
10
+
11
+
<link rel="stylesheet" type="text/css" href="/style.css" media="screen">
12
+
<link rel="shortcut icon" href="/favicon.ico" type="image/vnd.microsoft.icon">
13
+
<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
14
+
</head>
15
+
<body>
16
+
<div id="main">
17
+
<h1>xkcd</h1>
18
+
<h2 id="o">o</h2>
19
+
20
+
<h1 id="cmo-fastidiar-a-la-gente-que-ha-aprendido-a-esperar-errores-de-redondeo-en-aritmtica-de-punto-flotante">Cómo fastidiar a la gente que ha aprendido a <em>esperar</em> errores de redondeo en aritmética de punto flotante</h1>
21
+
22
+
<p><img src="http://imgs.xkcd.com/comics/e_to_the_pi_minus_pi.png" alt="Viñeta obligatoria de xkcd" title="Viñeta obligatoria de xkcd" /></p>
23
+
24
+
<p>De <a href="http://www.xkcd.com/217/">xkcd</a></p>
25
+
26
+
<g:plusone href="http://puntoflotante.org/"></g:plusone>
27
+
<div id="license">
28
+
<p>© Publicado en <a href="http://puntoflotante.org/">http://puntoflotante.org/</a> bajo una licencia
29
+
<a href="http://creativecommons.org/licenses/by/3.0/deed.es">Creative Commons Atribución Unported (BY)</a>.
30
+
Original en inglés por Michael Borgwardt en
31
+
<a href="http://floating-point-gui.de/">http://floating-point-gui.de/</a>.</p>
32
+
</div>
33
+
</div>
34
+
<div id="sidebar">
35
+
<a href="/"><img src="/logo.png"></a>
36
+
<h2>La Guía del Punto Flotante</h2>
37
+
<ul>
38
+
<li><a href="http://floating-point-gui.de/" alt="in English"><img src="/en.png"></a></li>
39
+
<li><a href="/">Inicio</a></li>
40
+
<li><a href="/basic/">Respuestas básicas</a></li>
41
+
<li><a href="/references/">Referencias</a></li>
42
+
<li><a href="/xkcd/">xkcd</a></li>
43
+
</ul>
44
+
45
+
<h2>Formatos Numéricos</h2>
46
+
<ul>
47
+
<li><a href="/formats/binary/">Fracciones binarias</a></li>
48
+
<li><a href="/formats/fp/">Punto flotante</a></li>
49
+
<li><a href="/formats/exact/">Tipos exactos</a></li>
50
+
<li><a href="/formats/integer/">Sobre usar enteros</a></li>
51
+
</ul>
52
+
53
+
<h2>Errores</h2>
54
+
<ul>
55
+
<li><a href="/errors/rounding/">Redondeo</a></li>
56
+
<li><a href="/errors/comparison/">Comparación</a></li>
57
+
<li><a href="/errors/propagation/">Propagación</a></li>
58
+
</ul>
59
+
60
+
<h2>Cheat sheets</h2>
61
+
<ul>
62
+
<li><a href="/languages/csharp/">C#</a></li>
63
+
<li><a href="/languages/java/">Java</a></li>
64
+
<li><a href="/languages/javascript/">JavaScript</a></li>
65
+
<li><a href="/languages/perl/">Perl</a></li>
66
+
<li><a href="/languages/php/">PHP</a></li>
67
+
<li><a href="/languages/python/">Python</a></li>
68
+
<li><a href="/languages/sql/">SQL</a></li>
69
+
</ul>
70
+
</div>
71
+
<a href="http://github.com/Pybonacci/puntoflotante.org"><img style="position: absolute; top: 0; right: 0; border: 0;" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" alt="Fork me on GitHub" /></a>
72
+
73
+
</body>
74
+
</html>