MatLab: Code for a sparse version of Horner's rule - matlab

Question

I have written code to evaluate polynomials
p(x)=a_0+x(a_1+x(a_2+x(a_3+...+x(a_(n-1)+xa_n)...)))
using Horner's rule as follows
function [answer ] = Simple( a,x )
%Simple takes two arguments that are in order and returns the value of the
%polynomial p(x). Simple is called by typing Simple(a,x)
% a is a row vector
%x is the associated scalar value
n=length(a);
result=a(n);
if (any(a~=floor(a))
error('The values in a must be integers')
end
for j=n-1:-1:1 %for loop working backwards through the vector a
result=x*result+a(j);
end
answer=result;
end
I am now trying to write a code for a sparse version of this ie
p(x)=x^(i_1)(b_1+x^((i_2)-(i_1))(b_2+x^((i_3)-(i_2))(b_3+...+x^((i_(k-1))-(i_(k-2)))(b_(k-1)+x^((i_k)-(i(k-1)))b_k)...)))
I think I need the inputs to be a row vector of i and a row vector of b and a scalar value x. Any ideas where I can find this? I am unsure how to code it myself.

Answer 1

One way to answer this is to look at an intermediate term in p(x),
this will be
...(b_j + x^(i_(j+1) - i_j)(...
instead of the usual ...(a_j + x(..., thus you need to change the line result=x*result+a(j);.
Also there is a slight flaw in your formula for p(x), it should be p(x) = x^(i_1 - 1)(..., this comes from the fact that p(x) = a_1 x^0 + a_2 x^1 + ... + a_n x^(n-1) which comes from the fact that indexes of matrices in Matlab start at 1 instead of 0. Here is the full code
function [answer ] = SparseHorner( a,x )
% SparseHorner takes two arguments that are in order and returns the value of the
% polynomial p(x). SparseHorner is called by typing SparseHorner(a,x)
% a is a sparse row vector
% x is the associated scalar value
%// Find the entries where a is nonzero
[xInd yInd aVal] = find(a);
if any(aVal~=floor(aVal))
error('The values in a must be integers')
end
%// a is a row vector so only yInd's values change
ind = yInd;
result=aVal(end);
%// for loop working backwards through the vector a
%// numel is better than length
for j=(numel(ind)-1):-1:1
%// a(ind(j)) is much slower than aVal(j)
result=x^(ind(j+1)-ind(j))*result + aVal(j);
end
answer=result*x^(ind(1)-1);
end
Note that this treats a differently than Matlab's polyval, the latter has p(x) = a_1 x^n + ... + a_n; if you want to be consistent, then add the line a = fliplr(a) near the beginning of the function.