time-to-botec

generators.js (5818B)

---

 /**
 * @license Apache-2.0
 *
 * Copyright (c) 2018 The Stdlib Authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
 'use strict';
 
 // MODULES //
 
 var abs = require( './../../../../base/special/abs' );
 var FLOAT32_SMALLEST_NORMAL = require( '@stdlib/constants/float32/smallest-normal' );
 var EPS = require( '@stdlib/constants/float64/eps' );
 
 
 // VARIABLES //
 
 var MAX_ITER = 1000000;
 
 
 // FUNCTIONS //
 
 /**
 * Evaluates a continued fraction expansion.
 *
 * ```text
 *           a1
 *      ---------------
 *      b1 +     a2
 *           ----------
 *            b2 +   a3
 *                -----
 *                b3 + ...
 * ```
 *
 * @private
 * @param {Function} gen - function giving terms of continued fraction expansion
 * @param {PositiveNumber} factor - further terms are only added as long as factor*result is smaller than the next term
 * @param {PositiveInteger} maxIter - maximum number of iterations
 * @returns {number} evaluated expansion
 */
 function continuedFractionA( gen, factor, maxIter ) {
 	var isgenerator;
 	var delta;
 	var a0;
 	var f;
 	var C;
 	var D;
 	var v;
 
 	isgenerator = typeof gen.next === 'function';
 	v = ( isgenerator ) ? gen.next().value : gen();
 	f = v[ 1 ];
 	a0 = v[ 0 ];
 	if ( f === 0.0 ) {
 		f = FLOAT32_SMALLEST_NORMAL;
 	}
 	C = f;
 	D = 0;
 	if ( isgenerator === true ) {
 		do {
 			v = gen.next().value;
 			if ( v ) {
 				D = v[ 1 ] + ( v[ 0 ] * D );
 				if ( D === 0.0 ) {
 					D = FLOAT32_SMALLEST_NORMAL;
 				}
 				C = v[ 1 ] + ( v[ 0 ] / C );
 				if ( C === 0.0 ) {
 					C = FLOAT32_SMALLEST_NORMAL;
 				}
 				D = 1.0 / D;
 				delta = C * D;
 				f *= delta;
 			}
 		} while ( ( abs( delta - 1.0 ) > factor ) && --maxIter ); // eslint-disable-line no-plusplus
 	} else {
 		do {
 			v = gen();
 			if ( v ) {
 				D = v[ 1 ] + ( v[ 0 ] * D );
 				if ( D === 0.0 ) {
 					D = FLOAT32_SMALLEST_NORMAL;
 				}
 				C = v[ 1 ] + ( v[ 0 ] / C );
 				if ( C === 0.0 ) {
 					C = FLOAT32_SMALLEST_NORMAL;
 				}
 				D = 1.0 / D;
 				delta = C * D;
 				f *= delta;
 			}
 		} while ( v && ( abs( delta - 1.0 ) > factor ) && --maxIter ); // eslint-disable-line no-plusplus
 	}
 	return a0 / f;
 }
 
 /**
 * Evaluates a continued fraction expansion.
 *
 * ```text
 *      b0 +    a1
 *      ---------------
 *      b1 +     a2
 *           ----------
 *           b2 +   a3
 *                -----
 *                b3 + ...
 * ```
 *
 * @private
 * @param {Function} gen - function giving terms of continued fraction expansion
 * @param {PositiveNumber} factor - further terms are only added as long as factor*result is smaller than the next term
 * @param {PositiveInteger} maxIter - maximum number of iterations
 * @returns {number} evaluated expansion
 */
 function continuedFractionB( gen, factor, maxIter ) {
 	var isgenerator;
 	var delta;
 	var f;
 	var C;
 	var D;
 	var v;
 
 	isgenerator = typeof gen.next === 'function';
 	v = ( isgenerator ) ? gen.next().value : gen();
 	f = v[ 1 ];
 	if ( f === 0.0 ) {
 		f = FLOAT32_SMALLEST_NORMAL;
 	}
 	C = f;
 	D = 0.0;
 	if ( isgenerator === true ) {
 		do {
 			v = gen.next().value;
 			if ( v ) {
 				D = v[ 1 ] + ( v[ 0 ] * D );
 				if ( D === 0.0 ) {
 					D = FLOAT32_SMALLEST_NORMAL;
 				}
 				C = v[ 1 ] + ( v[ 0 ] / C );
 				if ( C === 0.0 ) {
 					C = FLOAT32_SMALLEST_NORMAL;
 				}
 				D = 1.0 / D;
 				delta = C * D;
 				f *= delta;
 			}
 		} while ( v && ( abs( delta - 1.0 ) > factor ) && --maxIter ); // eslint-disable-line no-plusplus
 	} else {
 		do {
 			v = gen();
 			if ( v ) {
 				D = v[ 1 ] + ( v[ 0 ] * D );
 				if ( D === 0.0 ) {
 					D = FLOAT32_SMALLEST_NORMAL;
 				}
 				C = v[ 1 ] + ( v[ 0 ] / C );
 				if ( C === 0.0 ) {
 					C = FLOAT32_SMALLEST_NORMAL;
 				}
 				D = 1.0 / D;
 				delta = C * D;
 				f *= delta;
 			}
 		} while ( v && ( abs( delta - 1.0 ) > factor ) && --maxIter ); // eslint-disable-line no-plusplus
 	}
 	return f;
 }
 
 
 // MAIN //
 
 /**
 * Evaluates the continued fraction approximation for the supplied series generator using the modified Lentz algorithm.
 *
 * ## References
 *
 * -   Lentz, William J. 1976. "Generating bessel functions in Mie scattering calculations using continued fractions." _Applied Optics_ 15 (3): 668–71. doi:[10.1364/AO.15.000668](https://doi.org/10.1364/AO.15.000668).
 *
 * @param {Function} generator - function returning terms of continued fraction expansion
 * @param {Object} [options] - function options
 * @param {PositiveInteger} [options.maxIter=1000] - maximum number of iterations
 * @param {PositiveNumber} [options.tolerance=2.22e-16] - further terms are only added as long as the next term is greater than current term times the tolerance
 * @param {boolean} [options.keep=false] - whether to keep the leading b term
 * @returns {number} value of continued fraction
 *
 * @example
 * // Continued fraction for (e-1)^(-1):
 * var gen = generator();
 * var out = continuedFraction( gen );
 * // returns ~0.582
 *
 * function* generator() {
 *    var i = 0;
 *    while ( true ) {
 *        i++;
 *        yield [ i, i ];
 *    }
 * }
 */
 function continuedFraction( generator, options ) {
 	var maxIter;
 	var opts;
 	var eps;
 
 	opts = {};
 	if ( arguments.length > 1 ) {
 		opts = options;
 	}
 	maxIter = opts.maxIter || MAX_ITER;
 	eps = opts.tolerance || EPS;
 
 	if ( opts.keep ) {
 		return continuedFractionB( generator, eps, maxIter );
 	}
 	return continuedFractionA( generator, eps, maxIter );
 }
 
 
 // EXPORTS //
 
 module.exports = continuedFraction;