# fraction 4.1.4 fraction: ^4.1.4 copied to clipboard

A package that helps you working with fractions and mixed fractions. A package that helps you working with fractions and mixed fractions.

https://pub.dev/packages/fraction

## Working with fractions #

You can create an instance of `Fraction` using one of its constructors:

• Default: it just requires the numerator and/or the denominator.

``````Fraction(3, 5); // 3/5
Fraction(3, 1); // 3
``````
• fromString: requires a `String` representing a fraction.

``````Fraction.fromString("2/4"); // 2/4
Fraction.fromString("-2/4"); // -2/4
Fraction.fromString("2/-4"); // Throws an exception
Fraction.fromString("-2"); // -2/1
Fraction.fromString("/3"); // Error
``````
• fromDouble: converts a `double` into a fraction. Note that irrational numbers cannot be converted into fractions by definition; the constructor has the `precision` parameter which decides how precise the representation has to be.

``````Fraction.fromDouble(1.5); // 3/2
Fraction.fromDouble(-8.5); // -17/2
Fraction.fromDouble(math.pi); // 208341/66317
Fraction.fromDouble(math.pi, precision: 1.0e-4); // 333/106
``````

The constant `pi` cannot be represented as a fraction because it's an irrational number. The constructor considers only `precison` decimal digits to create a fraction.

Thanks to extension methods you can also create a `Fraction` object "on the fly" by calling the `toFraction()` method on a number or a string.

``````5.toFraction(); // 5/1
1.5.toFraction(); // 3/2
"6/5".toFraction(); // 6/5
``````

Note that a `Fraction` object is immutable so methods that require changing the internal state of the object return a new instance. For example, the `reduce()` method reduces the fraction to the lowest terms and returns a new instance:

``````final fraction = Fraction.fromString("12/20"); // 12/20
final reduced = fraction.reduce(); // 3/5
``````

Fraction strings can be converted from and to unicode glyphs when possible.

``````Fraction.fromGlyph("¼"); // Fraction(1, 4)
Fraction(1, 2).toStringAsGlyph(); // "½"
``````

You can easily sum, subtract, multiply and divide fractions thanks to arithmetic operators:

``````final f1 = Fraction(5, 7);
final f2 = Fraction(1, 5);

final sum = f1 + f2; // -> 5/7 + 1/5
final sub = f1 - f2; // -> 5/7 - 1/5
final mul = f1 * f2; // -> 5/7 * 1/5
final div = f1 / f2; // -> 5/7 / 1/5
``````

The `Fraction` type has a wide API with the most common operations you'd expect to make on a fraction:

``````Fraction(10, 2).toDouble();  // 5.0
Fraction(10, 2).inverse();   // 2/10
Fraction(1, 15).isWhole;     // false
Fraction(2, 3).negate();     // -2/3
Fraction(1, 15).isImproper;  // false
Fraction(1, 15).isProper;    // true

// Access numerator and denominator by index
final fraction = Fraction(-7, 12);

print('\${fraction}'); // -7
print('\${fraction}'); // 12
``````

Any other index value different from `0` and `1` throws a `FractionException` exception. Two fractions are equal if their "cross product" is equal. For example `1/2` and `3/6` are said to be equivalent because `1*6 = 3*2` (and in fact `3/6` is the same as `1/2`).

## Working with mixed fractions #

A mixed fraction is made up of a whole part and a proper fraction (a fraction in which numerator <= denominator). Building a `MixedFraction` object is very easy:

``````MixedFraction(
whole: 3,
numerator: 4,
denominator: 7
);
``````

As it happens with fractions, you can use various named constructors as well:

``````MixedFraction.fromDouble(1.5);
MixedFraction.fromString("1 1/2");
``````

There also is the possibility to initialize a `MixedFraction` using extension methods:

``````final mixed = "1 1/2".toMixedFraction();
``````

Note that `MixedFraction` objects are immutable exactly like `Fraction` objects so you're guaranteed that the internal state of the instance won't change. Make sure to check the official documentation at pub.dev for a complete overview of the API.

## Egyptian fractions #

An Egyptian fraction is a finite sum of distinct fractions where the numerator is always 1 and, the denominator is a positive number and all the denominators differ from each other. For example:

• 5/8 = 1/2 + 1/8 (where "1/2 + 1/8" is the egyptian fraction)

In other words, egyptian fractions are a sum of fractions in the form 1/x that represent a proper or an improper fraction. Here's how they can be computed:

``````final egyptianFraction1 = Fraction(5, 8).toEgyptianFraction();
print("\$egyptianFraction1"); // prints "1/2 + 1/8"

final egyptianFraction2 = MixedFraction(2, 4, 5).toEgyptianFraction();
print("\$egyptianFraction2"); // prints "1 + 1 + 1/2 + 1/4 + 1/20"
``````

The `compute()` method returns an iterable.

Both `Fraction` and `MixedFraction` descend from the `Rational` type which allows parsing both kind of fractions with a single method call:

``````// This is a 'Fraction' object
Rational.tryParse('1/5'); // 1/5

// This is a 'MixedFraction' object
Rational.tryParse('2 4/7'); // 2 4/7

// This is 'null' because the string doesn't represent a fraction or a mixed fraction
Rational.tryParse(''); // null
``````

Parsing integer values like `Rational.tryParse('3')` always returns a `Fraction` type but it can easily be converted into a mixed fraction using the `Fraction.toMixedFraction` method.

36
likes
140
pub points
90%
popularity

### Publisher fluttercompletereference.com

A package that helps you working with fractions and mixed fractions.

### Documentation MIT (LICENSE)