iterContinuedFractionSeq
Create an iterator which generates a list of all continued fraction terms which can be obtained given the precision of a provided number.
A generalized continued fraction has the form
If a_i = 1
for all i
, the above expression reduces to a simple continued fraction.
where the values b_i
are called the coefficients or terms of the continued fraction and the rationals
are called convergents.
Usage
var iterContinuedFractionSeq = require( '@stdlib/math/iter/sequences/continued-fraction' );
iterContinuedFractionSeq( x, [options] )
Returns an iterator which generates a list of all continued fraction terms (b_i
) which can be obtained given the precision of x
.
var it = iterContinuedFractionSeq( 3.245 );
// returns <Object>
var v = it.next().value;
// returns 3
v = it.next().value;
// returns 4
v = it.next().value;
// returns 12
v = it.next().value;
// returns 4
var bool = it.next().done;
// returns true
The returned iterator protocol-compliant object has the following properties:
- next: function which returns an iterator protocol-compliant object containing the next iterated value (if one exists) assigned to a
value
property and adone
property having aboolean
value indicating whether the iterator is finished. - return: function which closes an iterator and returns a single (optional) argument in an iterator protocol-compliant object.
The function supports the following options
:
iter: maximum number of iterations. Default:
1e308
.tol: tolerance at which to terminate further evaluation of the continued fraction. Default: floating-point epsilon.
returns: specifies the type of result to return. Must be one of the following options:
- terms: return continued fraction terms.
- convergents: return continued fraction convergents.
- *: return both continued fraction terms and their associated convergents as a two-element array:
[ <term>, <convergent> ]
.
Default:
'terms'
.
By default, in theory, the function returns an infinite iterator; however, in practice, due to limited precision, every floating-point number is a rational number, and, thus, every returned iterator will end in a finite number of iterations. To explicitly cap the maximum number of iterations, set the iter
option.
var opts = {
'iter': 2
};
var it = iterContinuedFractionSeq( 3.245, opts );
// returns <Object>
var v = it.next().value;
// returns 3
v = it.next().value;
// returns 4
var bool = it.next().done;
// returns true
The returned iterator terminates once the difference between the input value x
and a continued fraction approximation is sufficiently small. The default tolerance is floating-point epsilon (~2.22e-16
). Once an update to a continued fraction approximation is less than or equal to this tolerance, the iterator terminates. To adjust the tolerance (e.g., to return a rough approximation of an input value x
), set the tol
option.
var opts = {
'tol': 1.0e-7
};
var it = iterContinuedFractionSeq( 3.141592653589793, opts );
// returns <Object>
var v = it.next().value;
// returns 3
v = it.next().value;
// returns 7
v = it.next().value;
// returns 16
var bool = it.next().done;
// returns true
// The returned terms [3; 7, 16] evaluate to 3.1415929203539825
By default, the returned iterator returns continued fraction terms. To return convergents, set the returns
option to 'convergents'
.
var it = iterContinuedFractionSeq( 3.245, {
'returns': 'convergents'
});
// returns <Object>
var v = it.next().value;
// returns 3.0
v = it.next().value;
// returns 3.25
v = it.next().value;
// returns ~3.2449
v = it.next().value;
// returns 3.245
var bool = it.next().done;
// returns true
To return both continued fraction terms and their associated convergents, set the returns
option to *
.
var it = iterContinuedFractionSeq( 3.245, {
'returns': '*'
});
// returns <Object>
var v = it.next().value;
// returns [ 3, 3.0 ]
v = it.next().value;
// returns [ 4, 3.25 ]
v = it.next().value;
// returns [ 12, ~3.2449 ]
v = it.next().value;
// returns [ 4, 3.245 ]
var bool = it.next().done;
// returns true
Notes
- The returned iterator returns the terms for a simple continued fraction.
- For
x < 0
, the returned iterator returns negated terms for|x|
(i.e., if the terms for|x|
are[b0; b1, b2, ..., bn]
, the returned iterator returns[-b0; -b1, -b2, ..., -bn]
). While other continued fraction representations are possible, floating-point rounding error can introduce asymmetries when evaluating terms to recover the original values for|x|
andx < 0
. Accordingly, alternative continued fraction representations for negative input values are not supported. - If an environment supports
Symbol.iterator
, the returned iterator is iterable.
Examples
var PI = require( '@stdlib/constants/float64/pi' );
var iterContinuedFractionSeq = require( '@stdlib/math/iter/sequences/continued-fraction' );
function evaluate( terms ) {
var sum;
var N;
var i;
N = terms.length;
sum = 0.0;
if ( N > 1 ) {
sum = 1.0 / terms[ N-1 ];
for ( i = N-2; i > 0; i-- ) {
sum = 1.0 / ( terms[ i ] + sum );
}
}
sum += terms[ 0 ];
return sum;
}
// Create an iterator:
var opts = {
'iter': 20
};
var it = iterContinuedFractionSeq( PI, opts );
// Perform manual iteration...
var terms = [];
var v;
while ( true ) {
v = it.next();
if ( v.done ) {
break;
}
terms.push( v.value );
}
console.log( 'original: %d', PI );
console.log( terms );
console.log( 'computed: %d', evaluate( terms ) );