Random fraction generator

Frações têm uma história que começa antes de qualquer civilização ter inventado o zero. Os egípcios antigos usavam exclusivamente frações unitárias — frações com numerador 1: ½, ⅓, ¼ — e representavam qualquer fração como soma delas. O Papiro de Rhind, datado de cerca de 1650 a.C., contém uma tabela inteira de decomposições de frações em somas de frações unitárias. Euclides, por volta de 300 a.C., formalizou no Livro VII dos Elementos o algoritmo para calcular o Máximo Divisor Comum (MDC) — que é exatamente o que usamos até hoje para simplificar frações. O algoritmo de Euclides, com mais de 2.300 anos, é provavelmente o algoritmo matemático mais antigo ainda em uso ativo. Racionais — números que podem ser expressos como fração de dois inteiros — são, teoricamente, os números mais fáceis de representar com exatidão. Na prática, os computadores modernos preferem o ponto flutuante.

O padrão IEEE 754, publicado em 1985, define como os computadores representam números de ponto flutuante em binário — e é onde a simplicidade das frações vai por água abaixo. O número 0,1 em decimal não tem representação exata em binário de 32 ou 64 bits, assim como ⅓ não tem representação exata em decimal. Por isso, em JavaScript (e em praticamente toda linguagem que segue o IEEE 754), `0.1 + 0.2` é igual a `0.30000000000000004`, não a `0.3`. Esse é um dos bugs mais famosos e incompreendidos da programação — toda semana alguém descobre isso pela primeira vez e jura que a linguagem está errada. Representar frações como par de inteiros (numerador/denominador) evita esse problema completamente: 1/3 somado a 1/6 é exatamente 1/2, sem nenhum erro de arredondamento.

Frações aparecem em contextos surpreendentes fora da matemática escolar. Compassos musicais (tempo de 3/4 ou 4/4), proporções de aspect ratio (16:9 é a mesma coisa que 16/9), frações de probabilidade em estatística, receitas culinárias que precisam ser ajustadas por fração (¾ da receita original), interfaces que usam frações CSS (`grid-template-columns: 1fr 2fr`). Para quem desenvolve simuladores educacionais, geradores de exercícios ou testa lógica de cálculo fracionário, precisar de frações aleatórias com denominadores variados é uma necessidade prática. Esta ferramenta gera frações com denominador até o valor que você escolher, já simplificadas pelo MDC, em quantidade configurável — prontas para exercícios, testes ou qualquer contexto que precise de racionais variados.

Fractions have a history that predates any civilization inventing zero. Ancient Egyptians used exclusively unit fractions — fractions with numerator 1: ½, ⅓, ¼ — and represented any fraction as a sum of them. The Rhind Papyrus, dated around 1650 BCE, contains an entire table of decompositions of fractions into sums of unit fractions. Euclid, around 300 BCE, formalized in Book VII of the Elements the algorithm for computing the Greatest Common Divisor (GCD) — which is exactly what we use today to simplify fractions. Euclid's algorithm, over 2,300 years old, is arguably the oldest mathematical algorithm still in active use. Rationals — numbers expressible as a fraction of two integers — are theoretically the easiest numbers to represent exactly. In practice, modern computers prefer floating-point.

The IEEE 754 standard, published in 1985, defines how computers represent floating-point numbers in binary — and this is where the simplicity of fractions falls apart. The number 0.1 in decimal has no exact representation in 32- or 64-bit binary, just as ⅓ has no exact representation in decimal. That is why in JavaScript (and in virtually every language following IEEE 754), `0.1 + 0.2` equals `0.30000000000000004`, not `0.3`. This is one of the most famous and misunderstood bugs in programming — every week someone discovers it for the first time and concludes the language is broken. Representing fractions as an integer pair (numerator/denominator) avoids this problem entirely: 1/3 plus 1/6 is exactly 1/2, with no rounding error whatsoever.

Fractions appear in surprising contexts outside school mathematics. Musical time signatures (3/4 or 4/4 time), aspect ratio proportions (16:9 is the same as 16/9), probability fractions in statistics, recipes scaled by a fraction (¾ of the original recipe), CSS layout fractions (`grid-template-columns: 1fr 2fr`). For developers building educational simulators, exercise generators, or testing fractional calculation logic, needing random fractions with varied denominators is a practical requirement. This tool generates fractions with denominators up to the value you choose, already simplified by GCD, in configurable quantities — ready for exercises, tests, or any context that needs varied rational numbers.

Las fracciones tienen una historia que comienza antes de que ninguna civilización inventara el cero. Los antiguos egipcios usaban exclusivamente fracciones unitarias — fracciones con numerador 1: ½, ⅓, ¼ — y representaban cualquier fracción como suma de ellas. El Papiro de Rhind, fechado alrededor del 1650 a.C., contiene una tabla entera de descomposiciones de fracciones en sumas de fracciones unitarias. Euclides, hacia el 300 a.C., formalizó en el Libro VII de los Elementos el algoritmo para calcular el Máximo Común Divisor (MCD) — que es exactamente lo que usamos hoy para simplificar fracciones. El algoritmo de Euclides, con más de 2.300 años de antigüedad, es posiblemente el algoritmo matemático más antiguo que sigue en uso activo. Los racionales — números que pueden expresarse como fracción de dos enteros — son, en teoría, los números más fáciles de representar con exactitud. En la práctica, los ordenadores modernos prefieren el punto flotante.

El estándar IEEE 754, publicado en 1985, define cómo los ordenadores representan los números de punto flotante en binario — y es ahí donde la simplicidad de las fracciones se desmorona. El número 0,1 en decimal no tiene representación exacta en binario de 32 o 64 bits, igual que ⅓ no tiene representación exacta en decimal. Por eso, en JavaScript (y en prácticamente todos los lenguajes que siguen el IEEE 754), `0.1 + 0.2` es igual a `0.30000000000000004`, no a `0.3`. Este es uno de los bugs más famosos e incomprendidos de la programación — cada semana alguien lo descubre por primera vez y jura que el lenguaje está mal. Representar fracciones como par de enteros (numerador/denominador) evita este problema por completo: 1/3 sumado a 1/6 es exactamente 1/2, sin ningún error de redondeo.

Las fracciones aparecen en contextos sorprendentes fuera de las matemáticas escolares. Los compases musicales (tiempo de 3/4 o 4/4), las proporciones de relación de aspecto (16:9 es lo mismo que 16/9), las fracciones de probabilidad en estadística, las recetas que hay que ajustar por fracción (¾ de la receta original), las fracciones en CSS (`grid-template-columns: 1fr 2fr`). Para quienes desarrollan simuladores educativos, generadores de ejercicios o pruebas de lógica de cálculo fraccionario, necesitar fracciones aleatorias con denominadores variados es un requisito práctico. Esta herramienta genera fracciones con denominadores hasta el valor que elijas, ya simplificadas por el MCD, en cantidad configurable — listas para ejercicios, pruebas o cualquier contexto que necesite racionales variados.