evalrationalf

Evaluate a rational function using single-precision floating-point arithmetic.

A rational function f(x) is defined as

where both P(x) and Q(x) are polynomials in x. A polynomial in x can be expressed

where c_n, c_{n-1}, ..., c_0 are constants.

Usage

var evalrationalf = require( '@stdlib/math/base/tools/evalrationalf' );

evalrationalf( P, Q, x )

Evaluates a rational function at a value x using single-precision floating-point arithmetic.

var Float32Array = require( '@stdlib/array/float32' );

var P = new Float32Array( [ -6.0, -5.0 ] );
var Q = new Float32Array( [ 3.0, 0.5 ] );

var v = evalrationalf( P, Q, 6.0 ); // => ( -6*6^0 - 5*6^1 ) / ( 3*6^0 + 0.5*6^1 ) = (-6-30)/(3+3)
// returns -6.0

For polynomials of different degree, the coefficient array for the lower degree polynomial should be padded with zeros.

var Float32Array = require( '@stdlib/array/float32' );

// 2x^3 + 4x^2 - 5x^1 - 6x^0 => degree 4
var P = new Float32Array( [ -6.0, -5.0, 4.0, 2.0 ] );

// 0.5x^1 + 3x^0 => degree 2
var Q = new Float32Array( [ 3.0, 0.5, 0.0, 0.0 ] ); // zero-padded

var v = evalrationalf( P, Q, 6.0 ); // => ( -6*6^0 - 5*6^1 + 4*6^2 + 2*6^3 ) / ( 3*6^0 + 0.5*6^1 + 0*6^2 + 0*6^3 ) = (-6-30+144+432)/(3+3)
// returns ~90.0

Coefficients should be ordered in ascending degree, thus matching summation notation.

evalrationalf.factory( P, Q )

Uses code generation to in-line coefficients and return a function for evaluating a rational function using single-precision floating-point arithmetic.

var Float32Array = require( '@stdlib/array/float32' );

var P = new Float32Array( [ 20.0, 8.0, 3.0 ] );
var Q = new Float32Array( [ 10.0, 9.0, 1.0 ] );

var rational = evalrationalf.factory( P, Q );

var v = rational( 10.0 ); // => (20*10^0 + 8*10^1 + 3*10^2) / (10*10^0 + 9*10^1 + 1*10^2) = (20+80+300)/(10+90+100)
// returns 2.0

v = rational( 2.0 ); // => (20*2^0 + 8*2^1 + 3*2^2) / (10*2^0 + 9*2^1 + 1*2^2) = (20+16+12)/(10+18+4)
// returns 1.5

Notes

The coefficients P and Q are expected to be arrays of the same length.
For hot code paths in which coefficients are invariant, a compiled function will be more performant than evalrationalf().
While code generation can boost performance, its use may be problematic in browser contexts enforcing a strict content security policy (CSP). If running in or targeting an environment with a CSP, avoid using code generation.

## Examples

var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
var uniform = require( '@stdlib/random/base/uniform' );
var evalrationalf = require( '@stdlib/math/base/tools/evalrationalf' );

// Create two arrays of random coefficients...
var opts = {
    'dtype': 'float32'
};
var P = discreteUniform( 10, -100, 100, opts );
var Q = discreteUniform( 10, -100, 100, opts );

// Evaluate the rational function at random values...
var v;
var i;
for ( i = 0; i < 100; i++ ) {
    v = uniform( 0.0, 100.0 );
    console.log( 'f(%d) = %d', v, evalrationalf( P, Q, v ) );
}

// Generate an `evalrationalf` function...
var rational = evalrationalf.factory( P, Q );
for ( i = 0; i < 100; i++ ) {
    v = uniform( -50.0, 50.0 );
    console.log( 'f(%d) = %d', v, rational( v ) );
}