#!/usr/bin/env julia # -*- julia -*- # remez.jl - implementation of the Remez algorithm for polynomial approximation # # Copyright (c) 2015-2019, Arm Limited. # SPDX-License-Identifier: MIT OR Apache-2.0 WITH LLVM-exception import Base.\ # ---------------------------------------------------------------------- # Helper functions to cope with different Julia versions. if VERSION >= v"0.7.0" array1d(T, d) = Array{T, 1}(undef, d) array2d(T, d1, d2) = Array{T, 2}(undef, d1, d2) else array1d(T, d) = Array(T, d) array2d(T, d1, d2) = Array(T, d1, d2) end if VERSION < v"0.5.0" String = ASCIIString end if VERSION >= v"0.6.0" # Use Base.invokelatest to run functions made using eval(), to # avoid "world age" error run(f, x...) = Base.invokelatest(f, x...) else # Prior to 0.6.0, invokelatest doesn't exist (but fortunately the # world age problem also doesn't seem to exist) run(f, x...) = f(x...) end # ---------------------------------------------------------------------- # Global variables configured by command-line options. floatsuffix = "" # adjusted by --floatsuffix xvarname = "x" # adjusted by --variable epsbits = 256 # adjusted by --bits debug_facilities = Set() # adjusted by --debug full_output = false # adjusted by --full array_format = false # adjusted by --array preliminary_commands = array1d(String, 0) # adjusted by --pre # ---------------------------------------------------------------------- # Diagnostic and utility functions. # Enable debugging printouts from a particular subpart of this # program. # # Arguments: # facility Name of the facility to debug. For a list of facility names, # look through the code for calls to debug(). # # Return value is a BigFloat. function enable_debug(facility) push!(debug_facilities, facility) end # Print a diagnostic. # # Arguments: # facility Name of the facility for which this is a debug message. # printargs Arguments to println() if debugging of that facility is # enabled. macro debug(facility, printargs...) printit = quote print("[", $facility, "] ") end for arg in printargs printit = quote $printit print($(esc(arg))) end end return quote if $facility in debug_facilities $printit println() end end end # Evaluate a polynomial. # Arguments: # coeffs Array of BigFloats giving the coefficients of the polynomial. # Starts with the constant term, i.e. coeffs[i] is the # coefficient of x^(i-1) (because Julia arrays are 1-based). # x Point at which to evaluate the polynomial. # # Return value is a BigFloat. function poly_eval(coeffs::Array{BigFloat}, x::BigFloat) n = length(coeffs) if n == 0 return BigFloat(0) elseif n == 1 return coeffs[1] else return coeffs[1] + x * poly_eval(coeffs[2:n], x) end end # Evaluate a rational function. # Arguments: # ncoeffs Array of BigFloats giving the coefficients of the numerator. # Starts with the constant term, and 1-based, as above. # dcoeffs Array of BigFloats giving the coefficients of the denominator. # Starts with the constant term, and 1-based, as above. # x Point at which to evaluate the function. # # Return value is a BigFloat. function ratfn_eval(ncoeffs::Array{BigFloat}, dcoeffs::Array{BigFloat}, x::BigFloat) return poly_eval(ncoeffs, x) / poly_eval(dcoeffs, x) end # Format a BigFloat into an appropriate output format. # Arguments: # x BigFloat to format. # # Return value is a string. function float_to_str(x) return string(x) * floatsuffix end # Format a polynomial into an arithmetic expression, for pasting into # other tools such as gnuplot. # Arguments: # coeffs Array of BigFloats giving the coefficients of the polynomial. # Starts with the constant term, and 1-based, as above. # # Return value is a string. function poly_to_string(coeffs::Array{BigFloat}) n = length(coeffs) if n == 0 return "0" elseif n == 1 return float_to_str(coeffs[1]) else return string(float_to_str(coeffs[1]), "+", xvarname, "*(", poly_to_string(coeffs[2:n]), ")") end end # Format a rational function into a string. # Arguments: # ncoeffs Array of BigFloats giving the coefficients of the numerator. # Starts with the constant term, and 1-based, as above. # dcoeffs Array of BigFloats giving the coefficients of the denominator. # Starts with the constant term, and 1-based, as above. # # Return value is a string. function ratfn_to_string(ncoeffs::Array{BigFloat}, dcoeffs::Array{BigFloat}) if length(dcoeffs) == 1 && dcoeffs[1] == 1 # Special case: if the denominator is just 1, leave it out. return poly_to_string(ncoeffs) else return string("(", poly_to_string(ncoeffs), ")/(", poly_to_string(dcoeffs), ")") end end # Format a list of x,y pairs into a string. # Arguments: # xys Array of (x,y) pairs of BigFloats. # # Return value is a string. function format_xylist(xys::Array{Tuple{BigFloat,BigFloat}}) return ("[\n" * join([" "*string(x)*" -> "*string(y) for (x,y) in xys], "\n") * "\n]") end # ---------------------------------------------------------------------- # Matrix-equation solver for matrices of BigFloat. # # I had hoped that Julia's type-genericity would allow me to solve the # matrix equation Mx=V by just writing 'M \ V'. Unfortunately, that # works by translating the inputs into double precision and handing # off to an optimised library, which misses the point when I have a # matrix and vector of BigFloat and want my result in _better_ than # double precision. So I have to implement my own specialisation of # the \ operator for that case. # # Fortunately, the point of using BigFloats is that we have precision # to burn, so I can do completely naïve Gaussian elimination without # worrying about instability. # Arguments: # matrix_in 2-dimensional array of BigFloats, representing a matrix M # in row-first order, i.e. matrix_in[r,c] represents the # entry in row r col c. # vector_in 1-dimensional array of BigFloats, representing a vector V. # # Return value: a 1-dimensional array X of BigFloats, satisfying M X = V. # # Expects the input to be an invertible square matrix and a vector of # the corresponding size, on pain of failing an assertion. function \(matrix_in :: Array{BigFloat,2}, vector_in :: Array{BigFloat,1}) # Copy the inputs, because we'll be mutating them as we go. M = copy(matrix_in) V = copy(vector_in) # Input consistency criteria: matrix is square, and vector has # length to match. n = length(V) @assert(n > 0) @assert(size(M) == (n,n)) @debug("gausselim", "starting, n=", n) for i = 1:1:n # Straightforward Gaussian elimination: find the largest # non-zero entry in column i (and in a row we haven't sorted # out already), swap it into row i, scale that row to # normalise it to 1, then zero out the rest of the column by # subtracting a multiple of that row from each other row. @debug("gausselim", "matrix=", repr(M)) @debug("gausselim", "vector=", repr(V)) # Find the best pivot. bestrow = 0 bestval = 0 for j = i:1:n if abs(M[j,i]) > bestval bestrow = j bestval = M[j,i] end end @assert(bestrow > 0) # make sure we did actually find one @debug("gausselim", "bestrow=", bestrow) # Swap it into row i. if bestrow != i for k = 1:1:n M[bestrow,k],M[i,k] = M[i,k],M[bestrow,k] end V[bestrow],V[i] = V[i],V[bestrow] end # Scale that row so that M[i,i] becomes 1. divisor = M[i,i] for k = 1:1:n M[i,k] = M[i,k] / divisor end V[i] = V[i] / divisor @assert(M[i,i] == 1) # Zero out all other entries in column i, by subtracting # multiples of this row. for j = 1:1:n if j != i factor = M[j,i] for k = 1:1:n M[j,k] = M[j,k] - M[i,k] * factor end V[j] = V[j] - V[i] * factor @assert(M[j,i] == 0) end end end @debug("gausselim", "matrix=", repr(M)) @debug("gausselim", "vector=", repr(V)) @debug("gausselim", "done!") # Now we're done: M is the identity matrix, so the equation Mx=V # becomes just x=V, i.e. V is already exactly the vector we want # to return. return V end # ---------------------------------------------------------------------- # Least-squares fitting of a rational function to a set of (x,y) # points. # # We use this to get an initial starting point for the Remez # iteration. Therefore, it doesn't really need to be particularly # accurate; it only needs to be good enough to wiggle back and forth # across the target function the right number of times (so as to give # enough error extrema to start optimising from) and not have any # poles in the target interval. # # Least-squares fitting of a _polynomial_ is actually a sensible thing # to do, and minimises the rms error. Doing the following trick with a # rational function P/Q is less sensible, because it cannot be made to # minimise the error function (P/Q-f)^2 that you actually wanted; # instead it minimises (P-fQ)^2. But that should be good enough to # have the properties described above. # # Some theory: suppose you're trying to choose a set of parameters a_i # so as to minimise the sum of squares of some error function E_i. # Basic calculus says, if you do this in one variable, just # differentiate and solve for zero. In this case, that works fine even # with multiple variables, because you _partially_ differentiate with # respect to each a_i, giving a system of equations, and that system # turns out to be linear so we just solve it as a matrix. # # In this case, our parameters are the coefficients of P and Q; to # avoid underdetermining the system we'll fix Q's constant term at 1, # so that our error function (as described above) is # # E = \sum (p_0 + p_1 x + ... + p_n x^n - y - y q_1 x - ... - y q_d x^d)^2 # # where the sum is over all (x,y) coordinate pairs. Setting dE/dp_j=0 # (for each j) gives an equation of the form # # 0 = \sum 2(p_0 + p_1 x + ... + p_n x^n - y - y q_1 x - ... - y q_d x^d) x^j # # and setting dE/dq_j=0 gives one of the form # # 0 = \sum 2(p_0 + p_1 x + ... + p_n x^n - y - y q_1 x - ... - y q_d x^d) y x^j # # And both of those row types, treated as multivariate linear # equations in the p,q values, have each coefficient being a value of # the form \sum x^i, \sum y x^i or \sum y^2 x^i, for various i. (Times # a factor of 2, but we can throw that away.) So we can go through the # list of input coordinates summing all of those things, and then we # have enough information to construct our matrix and solve it # straight off for the rational function coefficients. # Arguments: # f The function to be approximated. Maps BigFloat -> BigFloat. # xvals Array of BigFloats, giving the list of x-coordinates at which # to evaluate f. # n Degree of the numerator polynomial of the desired rational # function. # d Degree of the denominator polynomial of the desired rational # function. # w Error-weighting function. Takes two BigFloat arguments x,y # and returns a scaling factor for the error at that location. # A larger value indicates that the error should be given # greater weight in the square sum we try to minimise. # If unspecified, defaults to giving everything the same weight. # # Return values: a pair of arrays of BigFloats (N,D) giving the # coefficients of the returned rational function. N has size n+1; D # has size d+1. Both start with the constant term, i.e. N[i] is the # coefficient of x^(i-1) (because Julia arrays are 1-based). D[1] will # be 1. function ratfn_leastsquares(f::Function, xvals::Array{BigFloat}, n, d, w = (x,y)->BigFloat(1)) # Accumulate sums of x^i y^j, for j={0,1,2} and a range of x. # Again because Julia arrays are 1-based, we'll have sums[i,j] # being the sum of x^(i-1) y^(j-1). maxpow = max(n,d) * 2 + 1 sums = zeros(BigFloat, maxpow, 3) for x = xvals y = f(x) weight = w(x,y) for i = 1:1:maxpow for j = 1:1:3 sums[i,j] += x^(i-1) * y^(j-1) * weight end end end @debug("leastsquares", "sums=", repr(sums)) # Build the matrix. We're solving n+d+1 equations in n+d+1 # unknowns. (We actually have to return n+d+2 coefficients, but # one of them is hardwired to 1.) matrix = array2d(BigFloat, n+d+1, n+d+1) vector = array1d(BigFloat, n+d+1) for i = 0:1:n # Equation obtained by differentiating with respect to p_i, # i.e. the numerator coefficient of x^i. row = 1+i for j = 0:1:n matrix[row, 1+j] = sums[1+i+j, 1] end for j = 1:1:d matrix[row, 1+n+j] = -sums[1+i+j, 2] end vector[row] = sums[1+i, 2] end for i = 1:1:d # Equation obtained by differentiating with respect to q_i, # i.e. the denominator coefficient of x^i. row = 1+n+i for j = 0:1:n matrix[row, 1+j] = sums[1+i+j, 2] end for j = 1:1:d matrix[row, 1+n+j] = -sums[1+i+j, 3] end vector[row] = sums[1+i, 3] end @debug("leastsquares", "matrix=", repr(matrix)) @debug("leastsquares", "vector=", repr(vector)) # Solve the matrix equation. all_coeffs = matrix \ vector @debug("leastsquares", "all_coeffs=", repr(all_coeffs)) # And marshal the results into two separate polynomial vectors to # return. ncoeffs = all_coeffs[1:n+1] dcoeffs = vcat([1], all_coeffs[n+2:n+d+1]) return (ncoeffs, dcoeffs) end # ---------------------------------------------------------------------- # Golden-section search to find a maximum of a function. # Arguments: # f Function to be maximised/minimised. Maps BigFloat -> BigFloat. # a,b,c BigFloats bracketing a maximum of the function. # # Expects: # a,b,c are in order (either a<=b<=c or c<=b<=a) # a != c (but b can equal one or the other if it wants to) # f(a) <= f(b) >= f(c) # # Return value is an (x,y) pair of BigFloats giving the extremal input # and output. (That is, y=f(x).) function goldensection(f::Function, a::BigFloat, b::BigFloat, c::BigFloat) # Decide on a 'good enough' threshold. threshold = abs(c-a) * 2^(-epsbits/2) # We'll need the golden ratio phi, of course. Or rather, in this # case, we need 1/phi = 0.618... one_over_phi = 2 / (1 + sqrt(BigFloat(5))) # Flip round the interval endpoints so that the interval [a,b] is # at least as large as [b,c]. (Then we can always pick our new # point in [a,b] without having to handle lots of special cases.) if abs(b-a) < abs(c-a) a, c = c, a end # Evaluate the function at the initial points. fa = f(a) fb = f(b) fc = f(c) @debug("goldensection", "starting") while abs(c-a) > threshold @debug("goldensection", "a: ", a, " -> ", fa) @debug("goldensection", "b: ", b, " -> ", fb) @debug("goldensection", "c: ", c, " -> ", fc) # Check invariants. @assert(a <= b <= c || c <= b <= a) @assert(fa <= fb >= fc) # Subdivide the larger of the intervals [a,b] and [b,c]. We've # arranged that this is always [a,b], for simplicity. d = a + (b-a) * one_over_phi # Now we have an interval looking like this (possibly # reversed): # # a d b c # # and we know f(b) is bigger than either f(a) or f(c). We have # two cases: either f(d) > f(b), or vice versa. In either # case, we can narrow to an interval of 1/phi the size, and # still satisfy all our invariants (three ordered points, # [a,b] at least the width of [b,c], f(a)<=f(b)>=f(c)). fd = f(d) @debug("goldensection", "d: ", d, " -> ", fd) if fd > fb a, b, c = a, d, b fa, fb, fc = fa, fd, fb @debug("goldensection", "adb case") else a, b, c = c, b, d fa, fb, fc = fc, fb, fd @debug("goldensection", "cbd case") end end @debug("goldensection", "done: ", b, " -> ", fb) return (b, fb) end # ---------------------------------------------------------------------- # Find the extrema of a function within a given interval. # Arguments: # f The function to be approximated. Maps BigFloat -> BigFloat. # grid A set of points at which to evaluate f. Must be high enough # resolution to make extrema obvious. # # Returns an array of (x,y) pairs of BigFloats, with each x,y giving # the extremum location and its value (i.e. y=f(x)). function find_extrema(f::Function, grid::Array{BigFloat}) len = length(grid) extrema = array1d(Tuple{BigFloat, BigFloat}, 0) for i = 1:1:len # We have to provide goldensection() with three points # bracketing the extremum. If the extremum is at one end of # the interval, then the only way we can do that is to set two # of the points equal (which goldensection() will cope with). prev = max(1, i-1) next = min(i+1, len) # Find our three pairs of (x,y) coordinates. xp, xi, xn = grid[prev], grid[i], grid[next] yp, yi, yn = f(xp), f(xi), f(xn) # See if they look like an extremum, and if so, ask # goldensection() to give a more exact location for it. if yp <= yi >= yn push!(extrema, goldensection(f, xp, xi, xn)) elseif yp >= yi <= yn x, y = goldensection(x->-f(x), xp, xi, xn) push!(extrema, (x, -y)) end end return extrema end # ---------------------------------------------------------------------- # Winnow a list of a function's extrema to give a subsequence of a # specified length, with the extrema in the subsequence alternating # signs, and with the smallest absolute value of an extremum in the # subsequence as large as possible. # # We do this using a dynamic-programming approach. We work along the # provided array of extrema, and at all times, we track the best set # of extrema we have so far seen for each possible (length, sign of # last extremum) pair. Each new extremum is evaluated to see whether # it can be added to any previously seen best subsequence to make a # new subsequence that beats the previous record holder in its slot. # Arguments: # extrema An array of (x,y) pairs of BigFloats giving the input extrema. # n Number of extrema required as output. # # Returns a new array of (x,y) pairs which is a subsequence of the # original sequence. (So, in particular, if the input was sorted by x # then so will the output be.) function winnow_extrema(extrema::Array{Tuple{BigFloat,BigFloat}}, n) # best[i,j] gives the best sequence so far of length i and with # sign j (where signs are coded as 1=positive, 2=negative), in the # form of a tuple (cost, actual array of x,y pairs). best = fill((BigFloat(0), array1d(Tuple{BigFloat,BigFloat}, 0)), n, 2) for (x,y) = extrema if y > 0 sign = 1 elseif y < 0 sign = 2 else # A zero-valued extremum cannot possibly contribute to any # optimal sequence, so we simply ignore it! continue end for i = 1:1:n # See if we can create a new entry for best[i,sign] by # appending our current (x,y) to some previous thing. if i == 1 # Special case: we don't store a best zero-length # sequence :-) candidate = (abs(y), [(x,y)]) else othersign = 3-sign # map 1->2 and 2->1 oldscore, oldlist = best[i-1, othersign] newscore = min(abs(y), oldscore) newlist = vcat(oldlist, [(x,y)]) candidate = (newscore, newlist) end # If our new candidate improves on the previous value of # best[i,sign], then replace it. if candidate[1] > best[i,sign][1] best[i,sign] = candidate end end end # Our ultimate return value has to be either best[n,1] or # best[n,2], but it could be either. See which one has the higher # score. if best[n,1][1] > best[n,2][1] ret = best[n,1][2] else ret = best[n,2][2] end # Make sure we did actually _find_ a good answer. @assert(length(ret) == n) return ret end # ---------------------------------------------------------------------- # Construct a rational-function approximation with equal and # alternating weighted deviation at a specific set of x-coordinates. # Arguments: # f The function to be approximated. Maps BigFloat -> BigFloat. # coords An array of BigFloats giving the x-coordinates. There should # be n+d+2 of them. # n, d The degrees of the numerator and denominator of the desired # approximation. # prev_err A plausible value for the alternating weighted deviation. # (Required to kickstart a binary search in the nonlinear case; # see comments below.) # w Error-weighting function. Takes two BigFloat arguments x,y # and returns a scaling factor for the error at that location. # The returned approximation R should have the minimum possible # maximum value of abs((f(x)-R(x)) * w(x,f(x))). Optional # parameter, defaulting to the always-return-1 function. # # Return values: a pair of arrays of BigFloats (N,D) giving the # coefficients of the returned rational function. N has size n+1; D # has size d+1. Both start with the constant term, i.e. N[i] is the # coefficient of x^(i-1) (because Julia arrays are 1-based). D[1] will # be 1. function ratfn_equal_deviation(f::Function, coords::Array{BigFloat}, n, d, prev_err::BigFloat, w = (x,y)->BigFloat(1)) @debug("equaldev", "n=", n, " d=", d, " coords=", repr(coords)) @assert(length(coords) == n+d+2) if d == 0 # Special case: we're after a polynomial. In this case, we # have the particularly easy job of just constructing and # solving a system of n+2 linear equations, to find the n+1 # coefficients of the polynomial and also the amount of # deviation at the specified coordinates. Each equation is of # the form # # p_0 x^0 + p_1 x^1 + ... + p_n x^n ± e/w(x) = f(x) # # in which the p_i and e are the variables, and the powers of # x and calls to w and f are the coefficients. matrix = array2d(BigFloat, n+2, n+2) vector = array1d(BigFloat, n+2) currsign = +1 for i = 1:1:n+2 x = coords[i] for j = 0:1:n matrix[i,1+j] = x^j end y = f(x) vector[i] = y matrix[i, n+2] = currsign / w(x,y) currsign = -currsign end @debug("equaldev", "matrix=", repr(matrix)) @debug("equaldev", "vector=", repr(vector)) outvector = matrix \ vector @debug("equaldev", "outvector=", repr(outvector)) ncoeffs = outvector[1:n+1] dcoeffs = [BigFloat(1)] return ncoeffs, dcoeffs else # For a nontrivial rational function, the system of equations # we need to solve becomes nonlinear, because each equation # now takes the form # # p_0 x^0 + p_1 x^1 + ... + p_n x^n # --------------------------------- ± e/w(x) = f(x) # x^0 + q_1 x^1 + ... + q_d x^d # # and multiplying up by the denominator gives you a lot of # terms containing e × q_i. So we can't do this the really # easy way using a matrix equation as above. # # Fortunately, this is a fairly easy kind of nonlinear system. # The equations all become linear if you switch to treating e # as a constant, so a reasonably sensible approach is to pick # a candidate value of e, solve all but one of the equations # for the remaining unknowns, and then see what the error # turns out to be in the final equation. The Chebyshev # alternation theorem guarantees that that error in the last # equation will be anti-monotonic in the input e, so we can # just binary-search until we get the two as close to equal as # we need them. function try_e(e) # Try a given value of e, derive the coefficients of the # resulting rational function by setting up equations # based on the first n+d+1 of the n+d+2 coordinates, and # see what the error turns out to be at the final # coordinate. matrix = array2d(BigFloat, n+d+1, n+d+1) vector = array1d(BigFloat, n+d+1) currsign = +1 for i = 1:1:n+d+1 x = coords[i] y = f(x) y_adj = y - currsign * e / w(x,y) for j = 0:1:n matrix[i,1+j] = x^j end for j = 1:1:d matrix[i,1+n+j] = -x^j * y_adj end vector[i] = y_adj currsign = -currsign end @debug("equaldev", "trying e=", e) @debug("equaldev", "matrix=", repr(matrix)) @debug("equaldev", "vector=", repr(vector)) outvector = matrix \ vector @debug("equaldev", "outvector=", repr(outvector)) ncoeffs = outvector[1:n+1] dcoeffs = vcat([BigFloat(1)], outvector[n+2:n+d+1]) x = coords[n+d+2] y = f(x) last_e = (ratfn_eval(ncoeffs, dcoeffs, x) - y) * w(x,y) * -currsign @debug("equaldev", "last e=", last_e) return ncoeffs, dcoeffs, last_e end threshold = 2^(-epsbits/2) # convergence threshold # Start by trying our previous iteration's error value. This # value (e0) will be one end of our binary-search interval, # and whatever it caused the last point's error to be, that # (e1) will be the other end. e0 = prev_err @debug("equaldev", "e0 = ", e0) nc, dc, e1 = try_e(e0) @debug("equaldev", "e1 = ", e1) if abs(e1-e0) <= threshold # If we're _really_ lucky, we hit the error right on the # nose just by doing that! return nc, dc end s = sign(e1-e0) @debug("equaldev", "s = ", s) # Verify by assertion that trying our other interval endpoint # e1 gives a value that's wrong in the other direction. # (Otherwise our binary search won't get a sensible answer at # all.) nc, dc, e2 = try_e(e1) @debug("equaldev", "e2 = ", e2) @assert(sign(e2-e1) == -s) # Now binary-search until our two endpoints narrow enough. local emid while abs(e1-e0) > threshold emid = (e1+e0)/2 nc, dc, enew = try_e(emid) if sign(enew-emid) == s e0 = emid else e1 = emid end end @debug("equaldev", "final e=", emid) return nc, dc end end # ---------------------------------------------------------------------- # Top-level function to find a minimax rational-function approximation. # Arguments: # f The function to be approximated. Maps BigFloat -> BigFloat. # interval A pair of BigFloats giving the endpoints of the interval # (in either order) on which to approximate f. # n, d The degrees of the numerator and denominator of the desired # approximation. # w Error-weighting function. Takes two BigFloat arguments x,y # and returns a scaling factor for the error at that location. # The returned approximation R should have the minimum possible # maximum value of abs((f(x)-R(x)) * w(x,f(x))). Optional # parameter, defaulting to the always-return-1 function. # # Return values: a tuple (N,D,E,X), where # N,D A pair of arrays of BigFloats giving the coefficients # of the returned rational function. N has size n+1; D # has size d+1. Both start with the constant term, i.e. # N[i] is the coefficient of x^(i-1) (because Julia # arrays are 1-based). D[1] will be 1. # E The maximum weighted error (BigFloat). # X An array of pairs of BigFloats giving the locations of n+2 # points and the weighted error at each of those points. The # weighted error values will have alternating signs, which # means that the Chebyshev alternation theorem guarantees # that any other function of the same degree must exceed # the error of this one at at least one of those points. function ratfn_minimax(f::Function, interval::Tuple{BigFloat,BigFloat}, n, d, w = (x,y)->BigFloat(1)) # We start off by finding a least-squares approximation. This # doesn't need to be perfect, but if we can get it reasonably good # then it'll save iterations in the refining stage. # # Least-squares approximations tend to look nicer in a minimax # sense if you evaluate the function at a big pile of Chebyshev # nodes rather than uniformly spaced points. These values will # also make a good grid to use for the initial search for error # extrema, so we'll keep them around for that reason too. # Construct the grid. lo, hi = minimum(interval), maximum(interval) local grid let mid = (hi+lo)/2 halfwid = (hi-lo)/2 nnodes = 16 * (n+d+1) pi = 2*asin(BigFloat(1)) grid = [ mid - halfwid * cos(pi*i/nnodes) for i=0:1:nnodes ] end # Find the initial least-squares approximation. (nc, dc) = ratfn_leastsquares(f, grid, n, d, w) @debug("minimax", "initial leastsquares approx = ", ratfn_to_string(nc, dc)) # Threshold of convergence. We stop when the relative difference # between the min and max (winnowed) error extrema is less than # this. # # This is set to the cube root of machine epsilon on a more or # less empirical basis, because the rational-function case will # not converge reliably if you set it to only the square root. # (Repeatable by using the --test mode.) On the assumption that # input and output error in each iteration can be expected to be # related by a simple power law (because it'll just be down to how # many leading terms of a Taylor series are zero), the cube root # was the next thing to try. threshold = 2^(-epsbits/3) # Main loop. while true # Find all the error extrema we can. function compute_error(x) real_y = f(x) approx_y = ratfn_eval(nc, dc, x) return (approx_y - real_y) * w(x, real_y) end extrema = find_extrema(compute_error, grid) @debug("minimax", "all extrema = ", format_xylist(extrema)) # Winnow the extrema down to the right number, and ensure they # have alternating sign. extrema = winnow_extrema(extrema, n+d+2) @debug("minimax", "winnowed extrema = ", format_xylist(extrema)) # See if we've finished. min_err = minimum([abs(y) for (x,y) = extrema]) max_err = maximum([abs(y) for (x,y) = extrema]) variation = (max_err - min_err) / max_err @debug("minimax", "extremum variation = ", variation) if variation < threshold @debug("minimax", "done!") return nc, dc, max_err, extrema end # If not, refine our function by equalising the error at the # extrema points, and go round again. (nc, dc) = ratfn_equal_deviation(f, map(x->x[1], extrema), n, d, max_err, w) @debug("minimax", "refined approx = ", ratfn_to_string(nc, dc)) end end # ---------------------------------------------------------------------- # Check if a polynomial is well-conditioned for accurate evaluation in # a given interval by Horner's rule. # # This is true if at every step where Horner's rule computes # (coefficient + x*value_so_far), the constant coefficient you're # adding on is of larger magnitude than the x*value_so_far operand. # And this has to be true for every x in the interval. # # Arguments: # coeffs The coefficients of the polynomial under test. Starts with # the constant term, i.e. coeffs[i] is the coefficient of # x^(i-1) (because Julia arrays are 1-based). # lo, hi The bounds of the interval. # # Return value: the largest ratio (x*value_so_far / coefficient), at # any step of evaluation, for any x in the interval. If this is less # than 1, the polynomial is at least somewhat well-conditioned; # ideally you want it to be more like 1/8 or 1/16 or so, so that the # relative rounding error accumulated at each step are reduced by # several factors of 2 when the next coefficient is added on. function wellcond(coeffs, lo, hi) x = max(abs(lo), abs(hi)) worst = 0 so_far = 0 for i = length(coeffs):-1:1 coeff = abs(coeffs[i]) so_far *= x if coeff != 0 thisval = so_far / coeff worst = max(worst, thisval) so_far += coeff end end return worst end # ---------------------------------------------------------------------- # Small set of unit tests. function test() passes = 0 fails = 0 function approx_eq(x, y, limit=1e-6) return abs(x - y) < limit end function test(condition) if condition passes += 1 else println("fail") fails += 1 end end # Test Gaussian elimination. println("Gaussian test 1:") m = BigFloat[1 1 2; 3 5 8; 13 34 21] v = BigFloat[1, -1, 2] ret = m \ v println(" ",repr(ret)) test(approx_eq(ret[1], 109/26)) test(approx_eq(ret[2], -105/130)) test(approx_eq(ret[3], -31/26)) # Test leastsquares rational functions. println("Leastsquares test 1:") n = 10000 a = array1d(BigFloat, n+1) for i = 0:1:n a[1+i] = i/BigFloat(n) end (nc, dc) = ratfn_leastsquares(x->exp(x), a, 2, 2) println(" ",ratfn_to_string(nc, dc)) for x = a test(approx_eq(exp(x), ratfn_eval(nc, dc, x), 1e-4)) end # Test golden section search. println("Golden section test 1:") x, y = goldensection(x->sin(x), BigFloat(0), BigFloat(1)/10, BigFloat(4)) println(" ", x, " -> ", y) test(approx_eq(x, asin(BigFloat(1)))) test(approx_eq(y, 1)) # Test extrema-winnowing algorithm. println("Winnow test 1:") extrema = [(x, sin(20*x)*sin(197*x)) for x in BigFloat(0):BigFloat(1)/1000:BigFloat(1)] winnowed = winnow_extrema(extrema, 12) println(" ret = ", format_xylist(winnowed)) prevx, prevy = -1, 0 for (x,y) = winnowed test(x > prevx) test(y != 0) test(prevy * y <= 0) # tolerates initial prevx having no sign test(abs(y) > 0.9) prevx, prevy = x, y end # Test actual minimax approximation. println("Minimax test 1 (polynomial):") (nc, dc, e, x) = ratfn_minimax(x->exp(x), (BigFloat(0), BigFloat(1)), 4, 0) println(" ",e) println(" ",ratfn_to_string(nc, dc)) test(0 < e < 1e-3) for x = 0:BigFloat(1)/1000:1 test(abs(ratfn_eval(nc, dc, x) - exp(x)) <= e * 1.0000001) end println("Minimax test 2 (rational):") (nc, dc, e, x) = ratfn_minimax(x->exp(x), (BigFloat(0), BigFloat(1)), 2, 2) println(" ",e) println(" ",ratfn_to_string(nc, dc)) test(0 < e < 1e-3) for x = 0:BigFloat(1)/1000:1 test(abs(ratfn_eval(nc, dc, x) - exp(x)) <= e * 1.0000001) end println("Minimax test 3 (polynomial, weighted):") (nc, dc, e, x) = ratfn_minimax(x->exp(x), (BigFloat(0), BigFloat(1)), 4, 0, (x,y)->1/y) println(" ",e) println(" ",ratfn_to_string(nc, dc)) test(0 < e < 1e-3) for x = 0:BigFloat(1)/1000:1 test(abs(ratfn_eval(nc, dc, x) - exp(x))/exp(x) <= e * 1.0000001) end println("Minimax test 4 (rational, weighted):") (nc, dc, e, x) = ratfn_minimax(x->exp(x), (BigFloat(0), BigFloat(1)), 2, 2, (x,y)->1/y) println(" ",e) println(" ",ratfn_to_string(nc, dc)) test(0 < e < 1e-3) for x = 0:BigFloat(1)/1000:1 test(abs(ratfn_eval(nc, dc, x) - exp(x))/exp(x) <= e * 1.0000001) end println("Minimax test 5 (rational, weighted, odd degree):") (nc, dc, e, x) = ratfn_minimax(x->exp(x), (BigFloat(0), BigFloat(1)), 2, 1, (x,y)->1/y) println(" ",e) println(" ",ratfn_to_string(nc, dc)) test(0 < e < 1e-3) for x = 0:BigFloat(1)/1000:1 test(abs(ratfn_eval(nc, dc, x) - exp(x))/exp(x) <= e * 1.0000001) end total = passes + fails println(passes, " passes ", fails, " fails ", total, " total") end # ---------------------------------------------------------------------- # Online help. function help() print(""" Usage: remez.jl [options] [] Arguments: , Bounds of the interval on which to approximate the target function. These are parsed and evaluated as Julia expressions, so you can write things like '1/BigFloat(6)' to get an accurate representation of 1/6, or '4*atan(BigFloat(1))' to get pi. (Unfortunately, the obvious 'BigFloat(pi)' doesn't work in Julia.) , The desired degree of polynomial(s) you want for your approximation. These should be non-negative integers. If you want a rational function as output, set to the degree of the numerator, and the denominator. If you just want an ordinary polynomial, set to 0, and to the degree of the polynomial you want. A Julia expression giving the function to be approximated on the interval. The input value is predefined as 'x' when this expression is evaluated, so you should write something along the lines of 'sin(x)' or 'sqrt(1+tan(x)^2)' etc. If provided, a Julia expression giving the weighting factor for the approximation error. The output polynomial will minimise the largest absolute value of (P-f) * w at any point in the interval, where P is the value of the polynomial, f is the value of the target function given by , and w is the weight given by this function. When this expression is evaluated, the input value to P and f is predefined as 'x', and also the true output value f(x) is predefined as 'y'. So you can minimise the relative error by simply writing '1/y'. If the argument is not provided, the default weighting function always returns 1, so that the polynomial will minimise the maximum absolute error |P-f|. Computation options: --pre= Evaluate the Julia expression before starting the computation. This permits you to pre-define variables or functions which the Julia expressions in your main arguments can refer to. All of , , and can make use of things defined by . One internal remez.jl function that you might sometimes find useful in this expression is 'goldensection', which finds the location and value of a maximum of a function. For example, one implementation strategy for the gamma function involves translating it to put its unique local minimum at the origin, in which case you can write something like this --pre='(m,my) = goldensection(x -> -gamma(x), BigFloat(1), BigFloat(1.5), BigFloat(2))' to predefine 'm' as the location of gamma's minimum, and 'my' as the (negated) value that gamma actually takes at that point, i.e. -gamma(m). (Since 'goldensection' always finds a maximum, we had to negate gamma in the input function to make it find a minimum instead. Consult the comments in the source for more details on the use of this function.) If you use this option more than once, all the expressions you provide will be run in sequence. --bits= Specify the accuracy to which you want the output polynomial, in bits. Default 256, which should be more than enough. --bigfloatbits= Turn up the precision used by Julia for its BigFloat evaluation. Default is Julia's default (also 256). You might want to try setting this higher than the --bits value if the algorithm is failing to converge for some reason. Output options: --full Instead of just printing the approximation function itself, also print auxiliary information: - the locations of the error extrema, and the actual (weighted) error at each of those locations - the overall maximum error of the function - a 'well-conditioning quotient', giving the worst-case ratio between any polynomial coefficient and the largest possible value of the higher-order terms it will be added to. The well-conditioning quotient should be less than 1, ideally by several factors of two, for accurate evaluation in the target precision. If you request a rational function, a separate well-conditioning quotient will be printed for the numerator and denominator. Use this option when deciding how wide an interval to approximate your function on, and what degree of polynomial you need. --variable= When writing the output polynomial or rational function in its usual form as an arithmetic expression, use as the name of the input variable. Default is 'x'. --suffix= When writing the output polynomial or rational function in its usual form as an arithmetic expression, write after every floating-point literal. For example, '--suffix=F' will generate a C expression in which the coefficients are literals of type 'float' rather than 'double'. --array Instead of writing the output polynomial as an arithmetic expression in Horner's rule form, write out just its coefficients, one per line, each with a trailing comma. Suitable for pasting into a C array declaration. This option is not currently supported if the output is a rational function, because you'd need two separate arrays for the numerator and denominator coefficients and there's no obviously right way to provide both of those together. Debug and test options: --debug= Enable debugging output from various parts of the Remez calculation. should be the name of one of the classes of diagnostic output implemented in the program. Useful values include 'gausselim', 'leastsquares', 'goldensection', 'equaldev', 'minimax'. This is probably mostly useful to people debugging problems with the script, so consult the source code for more information about what the diagnostic output for each of those facilities will be. If you want diagnostics from more than one facility, specify this option multiple times with different arguments. --test Run remez.jl's internal test suite. No arguments needed. Miscellaneous options: --help Display this text and exit. No arguments needed. """) end # ---------------------------------------------------------------------- # Main program. function main() nargs = length(argwords) if nargs != 5 && nargs != 6 error("usage: remez.jl []\n" * " run 'remez.jl --help' for more help") end for preliminary_command in preliminary_commands eval(Meta.parse(preliminary_command)) end lo = BigFloat(eval(Meta.parse(argwords[1]))) hi = BigFloat(eval(Meta.parse(argwords[2]))) n = parse(Int,argwords[3]) d = parse(Int,argwords[4]) f = eval(Meta.parse("x -> " * argwords[5])) # Wrap the user-provided function with a function of our own. This # arranges to detect silly FP values (inf,nan) early and diagnose # them sensibly, and also lets us log all evaluations of the # function in case you suspect it's doing the wrong thing at some # special-case point. function func(x) y = run(f,x) @debug("f", x, " -> ", y) if !isfinite(y) error("f(" * string(x) * ") returned non-finite value " * string(y)) end return y end if nargs == 6 # Wrap the user-provided weight function similarly. w = eval(Meta.parse("(x,y) -> " * argwords[6])) function wrapped_weight(x,y) ww = run(w,x,y) if !isfinite(ww) error("w(" * string(x) * "," * string(y) * ") returned non-finite value " * string(ww)) end return ww end weight = wrapped_weight else weight = (x,y)->BigFloat(1) end (nc, dc, e, extrema) = ratfn_minimax(func, (lo, hi), n, d, weight) if array_format if d == 0 functext = join([string(x)*",\n" for x=nc],"") else # It's unclear how you should best format an array of # coefficients for a rational function, so I'll leave # implementing this option until I have a use case. error("--array unsupported for rational functions") end else functext = ratfn_to_string(nc, dc) * "\n" end if full_output # Print everything you might want to know about the function println("extrema = ", format_xylist(extrema)) println("maxerror = ", string(e)) if length(dc) > 1 println("wellconditioning_numerator = ", string(wellcond(nc, lo, hi))) println("wellconditioning_denominator = ", string(wellcond(dc, lo, hi))) else println("wellconditioning = ", string(wellcond(nc, lo, hi))) end print("function = ", functext) else # Just print the text people will want to paste into their code print(functext) end end # ---------------------------------------------------------------------- # Top-level code: parse the argument list and decide what to do. what_to_do = main doing_opts = true argwords = array1d(String, 0) for arg = ARGS global doing_opts, what_to_do, argwords global full_output, array_format, xvarname, floatsuffix, epsbits if doing_opts && startswith(arg, "-") if arg == "--" doing_opts = false elseif arg == "--help" what_to_do = help elseif arg == "--test" what_to_do = test elseif arg == "--full" full_output = true elseif arg == "--array" array_format = true elseif startswith(arg, "--debug=") enable_debug(arg[length("--debug=")+1:end]) elseif startswith(arg, "--variable=") xvarname = arg[length("--variable=")+1:end] elseif startswith(arg, "--suffix=") floatsuffix = arg[length("--suffix=")+1:end] elseif startswith(arg, "--bits=") epsbits = parse(Int,arg[length("--bits=")+1:end]) elseif startswith(arg, "--bigfloatbits=") set_bigfloat_precision( parse(Int,arg[length("--bigfloatbits=")+1:end])) elseif startswith(arg, "--pre=") push!(preliminary_commands, arg[length("--pre=")+1:end]) else error("unrecognised option: ", arg) end else push!(argwords, arg) end end what_to_do()