# NAME

Math::NumSeq::FractionDigits -- the digits of a fraction p/q

# SYNOPSIS

`````` use Math::NumSeq::FractionDigits;
my \$seq = Math::NumSeq::FractionDigits->new (fraction => '2/11');
my (\$i, \$value) = \$seq->next;``````

# DESCRIPTION

The sequence of digits which are a given fraction. For example 1/7 in decimal, being 0.14285714...

``    1, 4, 2, 8, 5, 7, 1, 4, etc``

After any integer part, the fraction digits are a repeating sequence. If the fraction is num/den and is in least terms (num and den have no common factor) then the period is either den-1 or some divisor of den-1.

A particular a repeating sequence a,b,c,d,a,b,c,d,etc can be cooked up with fraction abcd/9999, the denominator being as many 9s as digits to repeat. For a base other than decimal the "9" is radix-1.

# FUNCTIONS

See "FUNCTIONS" in Math::NumSeq for behaviour common to all sequence classes.

`\$seq = Math::NumSeq::FractionDigits->new (fraction => \$f)`
`\$seq = Math::NumSeq::FractionDigits->new (fraction => \$f, radix => \$r)`

Create and return a new sequence object giving the digits of `\$f`. `\$f` is a string "num/den", or a decimal "xx.yy",

``````    2/29
29.125
1.5/3.25``````

The default sequence values are decimal digits, or the `radix` parameter can select another base. (But the `fraction` parameter is still decimal.)

If the numerator or denominator of the fraction is bigger than fits Perl integer calculations then `Math::BigInt` is used automatically.

## Random Access

`\$value = \$seq->ith(\$i)`

Return the `\$i`'th digit of the fraction.

# FORMULAS

## Next

For a given num/den, with num < den, the next digit below the radix point is formed by

``````    num *= radix               # now 0 <= num/den < radix
quot,rem = num divide den
digit = quot               # 0 <= digit < radix
new num = rem``````

## Ith

For an arbitrary digit i, the repeated num*=radix can be applied by a modular powering

``````    rpower = radix^i mod den
num = num * rpower mod den``````

i here acts as a count of how many digits to skip. For example if i=0 then rpower=1 and doesn't change the numerator at all. With that big skip the digit is then the same as for "next" above,

``````    num *= radix             # now 0 <= num/den < radix
digit = floor(num/den)   # 0 <= digit < radix``````

The usual modular powering techniques can be applied to calculate radix^i mod den. `Math::BigInt` has a bmodpow which is used in the code if the inputs are big.