A Computational Method with MAPLE for a Piecewise Polynomial Approximation to the Trigonometric Functions

Abstract

A complete MAPLE procedure is designed to effectively implement an algorithm for approximating trigonometric functions. The algorithm gives a piecewise polynomial approximation on an arbitrary interval, presenting a special partition that we can get its parts, subintervals with ending points of finite rational numbers, together with corresponding approximate polynomials. The procedure takes a sequence of pairs of interval–polynomial as its output that we can easily exploit in some useful ways. Examples on calculating approximate values of the sine function with arbitrary accuracy for both rational and irrational arguments as well as drawing the graph of the piecewise approximate functions are presented. Moreover, from the approximate integration on $[a,b]$ with integrands of the form $x^{m}sinx$, another MAPLE procedure is proposed to find the desired polynomial estimates in norm for the best $L^2$-approximation of the sine function in the vector space ${\mathcal{P}}_{\ell }$ of polynomials of degree at most ℓ, a subspace of $L^2(a,b)$.

1. Introduction

There are two aspects of implementation of an algorithm. One is the illustration for the validity of the algorithm, and the other for the efficient exploitation of its steps thanks to the choice of suitable tools.

Remez’s minimax algorithm is well established (see Section 3.5 in [1]), but all the steps to proceed it contain the two main obstacles when being performed in practice:

• solving a nonlinear equation and a system of linear equations; and
• using the cosine function to compute the initial set of points.

As a warning to experienced users, they should have close control of the evaluation error at almost every calculation for the above steps. Therefore, it could be difficult to effectively implement this algorithm for approximating the trigonometric functions themselves.

Here, we choose Algorithm 2 in [2] to be implemented with MAPLE (or any of Computer Algebra Systems (CAS), if possible), because it has the great advantage: only using arithmetic calculations on finite rational numbers and comparisons. The choice of MAPLE is due to its powerfulness of symbolic computation and its ability to display exact number of significant digits for the obtained numerical results. The description of Algorithm 2 is clear, but examples on numerical integration and graphical plots in [2] seem to be as of the first kind of implementation as mentioned above. Therefore, we come back to the article [2] with aspiration to provide the beginners or occasional users with a complete MAPLE procedure, the output of which being easy and convenient to exploit when implementing Algorithm 2.

From [2], we have that the function $sinx$ is piecewise approximated on an interval $[a,b]$ by the polynomials $A_i\left(x\right)$ on the subintervals $[{\alpha }_i,{\alpha }_{i+1}]$, $i=0,\dots ,n$, such that $[a,b]=[a,{\alpha }_1]\cup [{\alpha }_1,{\alpha }_2]\cup \cdots \cup [{\alpha }_n,b]$, where ${\alpha }_0=a$ and ${\alpha }_{n+1}=b$ and

$$A_i\left(x\right)={(-1)}^{(k_i-1)/2}\sum _{m=0}^{\lfloor n/2\rfloor }\frac{{(-1)}^m}{\left(2m\right)!}{(x-k_i{p}_i)}^{2m},$$

or

$$A_i\left(x\right)={(-1)}^{k_i/2}\sum _{m=0}^{\lfloor (n-1)/2\rfloor }\frac{{(-1)}^m}{(2m+1)!}{(x-k_i{p}_i)}^{2m+1},i=0,\dots ,n.$$

These approximations all have the accuracy of $1/{10}^r$ in absolute value for a given arbitrary positive integer r. The main purpose of Algorithm 2 is to give the pairs of $\left[[{\alpha }_i,{\alpha }_{i+1}],A_i\left(x\right)\right]$, $i=0,\dots ,n$, and, as a convention, the notations of this output is used in the next sections.

The paper is organized as follows. In Section 2, we construct a complete MAPLE procedure by blocks of commands so that we can modify them easily. These blocks whose purpose is clearly explained may be useful to design other procedures. Section 3 is for exploitation of the obtained results from the output of the procedure. Section 3 is the detailed discussion on how to find a desired estimate p for the best $L^2$-approximation $p_{\mathrm{best}}$ of the sine function in the vector space ${\mathcal{P}}_{\ell }$. In particular, it is possible to make a complete MAPLE procedure to find p’s with different values of ℓ from the existing materials, and we let the reader do it with his or her close control of evaluation error for the steps containing norms of vectors. Moreover, the crucial components of a procedure that computes approximate values of integration with integrands of the form $x^{m}sinx$ ($m\in \mathbb{N}$) are also provided. Section 4 is the conclusion.

2. Implementation by MAPLE Procedures

We list here the MAPLE commands that appear in our procedures. They are all very important and frequently used in MAPLE programming: add, coeff, Digits, ERROR, evalf, floor, for, irem, int, nops, op, piecewise, RETURN, seq, sort, and while. A declaration to create a function, e.g., f, such as f:=x->F(x) or f:=unapply(F(x),x), where F(x) is an expression in x, is a very useful and convenient tool in MAPLE procedures for doing calculations. In addition, the conditional structure if–then is indispensable in branch programming, whereas the type list is a flexible ordered arrangement of operands (or things and elements). See [3,4] and MAPLE help pages in each session to know more details about meaning, syntax and usage of these commands, structures and types.

In the following, we consider in succession the steps to perform Algorithm 2 in [2] with their content and corresponding MAPLE codes. However, we modify some steps in Algorithm 2 to get the extraction results conveniently from its output. Firstly, we recall the two blocks of commands (inside steps) for getting the degree n of the approximate polynomial $P_n^{\mathrm{c}}(x)$ of the function $sinx$ (Block 1), which satisfies the accuracy of $1/{10}^r$, and for finding the approximate values of $\pi /2$, which appear in $P_n^{\mathrm{c}}(x)$.

Block 1

n:=0: d:=1:

while (d>0) do

n:=n+1:

d:=(0.8)^(n+1)*10^(r+1)-(n+1)!;

end do:

Block 2 is nothing but the full content of FindPoint, a procedure to determine nodes of the form $k{p}^{\prime }$, where $k\in \mathbb{Z}$ and $p^{\prime }$ is an approximate value of $\pi /2$ (see [2]). These nodes are ending points of subintervals in the partition of an arbitrary interval $[a,b]$. The output of FindPoint from its argument y also gives the approximate polynomial F. Moreover, we have them all together, k, $p^{\prime }$ and F from a list of three components; that is, we may write $\mathtt{FindPoint}($y$)=[$k,p’,P] with $p^{\prime }\approx p=\pi /2$, $|sinx-P(x)|<1/{10}^r$ for all $x\in [k{p}^{\prime }-p^{\prime }/2,k{p}^{\prime }+p^{\prime }/2]$ and $|y-k{p}^{\prime }|<0.8$.

Block 2

m:=r+2:

while ((b+3.2)*10^(r+3)-10^m>0) do

m:=m+1:

end do:

Digits:=m+4:

q:=evalf[m+3](Pi/2):

T:=x/q-floor(x/q):

if (T=0.5) then

k0:=floor(x/q):

else

while (2.4*10^m*min(T,0.5-T)-abs(x)<0) and

(2.4*10^m*min(1-T,T-0.5)-abs(x)<0) do

m:=m+1: Digits:=m+4:

q:=evalf[m+3](Pi/2):

T:=x/q-floor(x/q):

end do:

end if:

if (0.5<T) then

k0:=floor(x/q)+1:

else

k0:=floor(x/q):

end if:

if (irem(k0-1,2)=0) then

F:=unapply((-1)^((k0-1)/2)*add((-1)^s*(t-k0*q)^(2*s)/((2*s)!),

s=0..floor(n/2)),t):

else

F:=unapply((-1)^(k0/2)*add((-1)^s*(t-k0*q)^(2*s+1)/((2*s+1)!),

s=0..floor((n-1)/2)),t):

end if:

[k0,q,F];

Next, Block 3 that may be the most important one is designed to find approximate polynomials $A_j(x)$, corresponding to intervals $[{\alpha }_{j-1},{\alpha }_j]$, where ${\alpha }_j$, $j=1,\dots ,i$, are the nodes mentioned above. This block gives a so-called spreading technique that takes nodes together with the polynomials $A_j(x)$, by using Block 2 successively, as clearly described in [2]. We choose the output of Block 3 as a function of a finite sequence of lists given in the form of

$$H:=x\to \left[[{\alpha }_0,{\alpha }_1],A_0(x)\right],\left[[{\alpha }_1,{\alpha }_2],A_1(x)\right],\dots ,\left[[{\alpha }_{i-1},{\alpha }_i],A_{i-1}(x)\right].$$

This output has the advantages of a function itself or a sequence of terms, because we can take its values $H(x)$ and $H(-x)$, or its components (or operands) $h_j(x)=\left[[{\alpha }_{j-1},{\alpha }_j],A_{j-1}(x)\right]$ as we want.

We design a MAPLE procedure named ApproxFunct to give the approximate function P for the sine function on an interval $[a,b]$ for $a\ge 0$. In the cases of $0\le a<b\le 0.8$ and $0\le a<0.8<b$, we may set $P=G$ on $[a,b]$ and $P=G$ on $[a,0.8]$, respectively, where

$$G(x)=\sum _{m=0}^{\lfloor (n-1)/2\rfloor }\frac{{(-1)}^m}{(2m+1)!}{x}^{2m+1}$$

and n is determined by Block 1. Before giving the MAPLE codes of Block 3 chosen as the full content of TempApproxFunct, the procedure to give the approximation to the sine function on $[a,b]$ only for $a\ge 0.8$, we recall here (from [2]) the important remark: if $\alpha ,\beta \in [a,b]$ are numbers such that

$$\mathtt{FindPoint}(\alpha )[1]=\mathtt{FindPoint}(\beta )[1]=k$$

with p’ = FindPoint($\alpha$)[2], p” = FindPoint($\beta$)[2], then we have |α − kp”| < 0.8 and |β − kp’| < 0.8.

Block 3

n0:=FindPoint(b)[1]:

p0:=FindPoint(b)[2]:

B0:=FindPoint(b)[3]:

i:=0:

k[i]:=FindPoint(a)[1]:

p[i]:=FindPoint(a)[2]:

A[i]:=FindPoint(a)[3]:

u:=k[i]:

if n0<=u then

H:=x->[[a,b],A[0](x)]:

RETURN(H);

end if:

while u<n0 do

i:=i+1:

k[i]:=FindPoint(k[i-1]*p[i-1]+p[i-1])[1]:

p[i]:=FindPoint(k[i-1]*p[i-1]+p[i-1])[2]:

A[i]:=FindPoint(k[i-1]*p[i-1]+p[i-1])[3]:

u:=k[i]:

end do:

if i=1 then

if b<=k[0]*p[0]+p[0]/2 then

H:=x->[[a,b],A[0](x)]:

RETURN(H);

elif b<=k[0]*p[0]+p[0] then

H:=x->([[a,k[0]*p[0]+p[0]/2],A[0](x)],[[k[0]*p[0]+p[0]/2,b],A[1](x)]):

RETURN(H);

else

H:=x->([[a,k[0]*p[0]+p[0]/2],A[0](x)],[[k[0]*p[0]+p[0]/2,k[0]*p[0]+p[0]],

A[1](x)],[[k[0]*p[0]+p[0],b],B0(x)]):

RETURN(H);

end if:

elif i=2 then

if b<=k[1]*p[1]+p[1]/2 then

H:=x->([[a,k[0]*p[0]+p[0]/2],A[0](x)],[[k[0]*p[0]+p[0]/2,b],A[1](x)]):

RETURN(H);

elif b<=k[1]*p[1]+p[1] then

H:=x->([[a,k[0]*p[0]+p[0]/2],A[0](x)],[[k[0]*p[0]+p[0]/2,k[1]*p[1]+p[1]/2],

A[1](x)],[[k[1]*p[1]+p[1]/2,b],A[2](x)]):

RETURN(H);

else

H:=x->([[a,k[0]*p[0]+p[0]/2],A[0](x)],[[k[0]*p[0]+p[0]/2,k[1]*p[1]+p[1]/2],

A[1](x)],[[k[1]*p[1]+p[1]/2,k[1]*p[1]+p[1]],A[2](x)],[[k[1]*p[1]+p[1],b],B0(x)]):

RETURN(H);

end if:

else

if b<=k[i-1]*p[i-1]+p[i-1]/2 then

H:=x->([[a,k[0]*p[0]+p[0]/2],A[0](x)],seq([[k[m-1]*p[m-1]+p[m-1]/2,

k[m]*p[m]+p[m]/2],A[m](x)],m=1..i-2),[[k[i-2]*p[i-2]+p[i-2]/2,b],A[i-1](x)]):

RETURN(H);

elif b<=k[i-1]*p[i-1]+p[i-1] then

H:=x->([[a,k[0]*p[0]+p[0]/2],A[0](x)],seq([[k[m-1]*p[m-1]+p[m-1]/2,

k[m]*p[m]+p[m]/2],A[m](x)],m=1..i-1),[[k[i-1]*p[i-1]+p[i-1]/2,b],A[i](x)]):

RETURN(H);

else

H:=x->([[a,k[0]*p[0]+p[0]/2],A[0](x)],seq([[k[m-1]*p[m-1]+p[m-1]/2,

k[m]*p[m]+p[m]/2],A[m](x)],m=1..i-1),[[k[i-1]*p[i-1]+p[i-1]/2,k[i]*p[i-1]],

A[i](x)],[[k[i]*p[i-1],b],B0(x)]):

RETURN(H);

end if:

end if:

Note that TempApproxFunct takes three arguments in order as a, b and r. Next, we combine Block 1 and Block 3 with some conditional commands to form Block 4, which is the content of the ApproxFunct.

Block 4

G:=unapply(add((-1)^s*t^(2*s+1)/((2*s+1)!),s=0..floor((n-1)/2)),t):

if (a<0) then ERROR(‘1st argument must be nonegative’);

elif (a<0.8) then

if (b<=0.8) then

[[a,b],G];

else

([[a,0.8],G],TempApproxFunct(0.8,b,r));

end if:

else

TempApproxFunct(a,b,r);

end if:

Now, we may call ApproxFunct(a,b,r) to fully access all subintervals together with approximate polynomials for the accuracy of $1/{10}^r$ on an interval $[a,b]$, $a\ge 0$. In particular, if we want to extract the jth interval and its corresponding approximate polynomial, use the calling sequence ApproxFunct(a,b,r)(x)[j], where j is chosen from the output ApproxFunct(a,b,r)(x).

Finally, from the above analysis, we obtain the desired procedure named PiecewiseFunct (see the supplementary material accompanying this paper for MAPLE codes), which gives a special partition of an arbitrary interval $[a,b]$ into subintervals [${\alpha }_{j-1}$,${\alpha }_j$] together with corresponding approximate polynomials $A_j(x)$, where

$$|sinx-A_j(x)|<\frac{1}{{10}^r}\mathrm{for}\mathrm{all}x\in [{\alpha }_{j-1},{\alpha }_j],j=1,\dots ,N,$$

with $N=\mathtt{nops}([\mathtt{PiecewiseFunct}(a,b,r)])$. Here, there is a warning that, in MAPLE, if A:=a,b,c,d or A:=(a,b,c,d), we cannot determine nops(A); however, we can if A:=[a,b,c,d], so $\mathtt{nops}(\mathtt{A})=4$. To all three settings for A, we can select ordered elements of A, namely $\mathtt{A}[\mathtt{3}]=\mathtt{c}$, for example.

Thus, a complete MAPLE procedure to perform Algorithm 2 in [2] is suggested to be

The PiecewiseFunct procedure

PiecewiseFunct:=proc(a::realcons,b::realcons,r::posint)

local ApproxFunct,j,n,d,G,num,funct,intrv;

ApproxFunct:=proc(a::realcons,b::realcons,r::posint)

local TempApproxFunct,n,d,G;option remember;

TempApproxFunct:=proc(a::realcons,b::realcons,r::posint)

local i,p0,n0,B0,u,p,k,A,H,FindPoint;option remember;

FindPoint:=proc(x::realcons)

local m,q,n,d,k0,F,T;option remember;

Block 1

Block 2

end proc:

Block 3

end proc:

Block 1

Block 4

end proc:

Block 1

G:=unapply(add((-1)^s*t^(2*s+1)/((2*s+1)!),s=0..floor((n-1)/2)),t):

if (0<=a) then

ApproxFunct(a,b,r)(x);

elif (-0.8<=a) then

if (b<=0) then

[[a,b],G(x)];

else

([[a,0],G(x)],ApproxFunct(0,b,r)(x));

end if:

else

if (b<=0) then

num:=nops([ApproxFunct(-b,-a,r)(-x)]):

for j from 1 to num do

funct[j]:=op(2,(-1)*ApproxFunct(-b,-a,r)(-x)[j]):

intrv[j]:=sort(op(1,(-1)*ApproxFunct(-b,-a,r)(-x)[j])):

end do:

seq([intrv[num+1-i],funct[num+1-i]],i=1..num);

else

num:=nops([ApproxFunct(0,-a,r)(-x)]):

for j from 1 to num do

funct[j]:=op(2,(-1)*ApproxFunct(0,-a,r)(-x)[j]):

intrv[j]:=sort(op(1,(-1)*ApproxFunct(0,-a,r)(-x)[j])):

end do:

(seq([intrv[num+1-i],funct[num+1-i]],i=1..num),ApproxFunct(0,b,r)(x));

end if:

end if:

end proc:

The last part of the PiecewiseFunct procedure might need to be explained in more detail. In the case $a<b\le 0$, we make a partition first for the interval $[-b,-a]$; then, from the result of the partition, we take a sample of the form $\left[[{\beta }_{j-1},{\beta }_j],B_j(x)\right]$ and convert it into its symmetric part in the partition of $[a,b]$: $\left[[-{\beta }_j,-{\beta }_{j-1}],-B_j(-x)\right]$. Such a sample in MAPLE language is given by the declaration: [intrv[j],funct[j]], where

$$\begin{array}{cc}\hfill \mathtt{intrv}[\mathtt{j}]& :=\mathtt{sort}(\mathtt{op}(\mathtt{1},(-\mathtt{1})\ast \mathtt{ApproxFunct}(-\mathtt{b},-\mathtt{a},\mathtt{r})(-\mathtt{x})[\mathtt{j}])),\hfill \\ \hfill \mathtt{funct}[\mathtt{j}]& :=\mathtt{op}(\mathtt{2},(-\mathtt{1})\ast \mathtt{ApproxFunct}(-\mathtt{b},-\mathtt{a},\mathtt{r})(-\mathtt{x})[\mathtt{j}]).\hfill \end{array}$$

Because the converted intervals should be arranged in the correct order on the real axis, we use the calling sequence seq([intrv[num+1-i],funct[num+1-i]],i=1..num).

In fact, PiecewiseFunct contains a technique that indirectly solves a difficult problem “How to reduce values of arguments when doing calculations with the trigonometric functions”. There was a great attempt to solve the problem and perhaps [1] would be one of the best reference books on this fact. However, this technique is only a suitable remedy for applying Taylor’s Theorem, which has not been considered a good way in approximation theory.

PiecewiseFunct can be also used to give pointwise approximate values of the sine function, so we do not need to recall here Algorithm 1 (see [2]). A hint: Combine Block 1, Block 2 and the illustrated MAPLE codes for the distinction between “r-th decimal digit” and “r significant digits” on [2] to make a procedure, e.g., Sine, to implement Algorithm 1.

3. Exploitation of the Output of the PiecewiseFunct Procedure

Firstly, we save the result from performing PiecewiseFunct in a variable chosen as a list of lists A:=[PiecewiseFunct(a,b,r)], then put num:=nops(A). Now, we number the ending points of subintervals and corresponding approximate polynomials, for instance, by a for-loop:

$$\begin{array}{c}\mathtt{for}\mathtt{i}\mathtt{from}\mathtt{1}\mathtt{to}\mathtt{num}\mathtt{do}\hfill \\ \mathtt{a}[\mathtt{i}]:=\mathtt{op}(\mathtt{1},\mathtt{op}(\mathtt{1},\mathtt{A}[\mathtt{i}])):\hfill \\ \mathtt{b}[\mathtt{i}]:=\mathtt{op}(\mathtt{2},\mathtt{op}(\mathtt{1},\mathtt{A}[\mathtt{i}])):\hfill \\ \mathtt{F}[\mathtt{i}]:=\mathtt{op}(\mathtt{2},\mathtt{A}[\mathtt{i}]):\hfill \\ \mathtt{end}\mathtt{do}:\hfill \end{array}$$

(1)

For a given number $\alpha \in [a,b]$, we can choose the index i such that the interval $[\mathtt{a}[\mathtt{i}],\mathtt{b}[\mathtt{i}]]$ contains $\alpha$, hence we put $g:=\mathtt{unapply}(\mathtt{F}[\mathtt{i}],\mathtt{x})$. Note that F[i] is still an expression in x as default, not a function; besides, we cannot set $g:=\mathtt{x}->\mathtt{F}[\mathtt{i}]$ because x here and x in F[i] are not the same by MAPLE’s rule. Then, $sin\alpha \approx g(\alpha )$ with the accuracy of $1/{10}^r$. In MAPLE, we can use the command piecewise for a sequence of conditional settings to get the piecewise polynomial approximation to the sine function on $[a,b]$ by putting

$$f:=\mathtt{x}->\mathtt{piecewise}(\mathtt{seq}([\mathtt{a}[\mathtt{j}]<=\mathtt{x} \mathtt{and} \mathtt{x}<=\mathtt{b}[\mathtt{j}],\mathtt{F}[\mathtt{j}]][],\mathtt{j}=\mathtt{1}..\mathtt{num}),\mathtt{NULL}):$$

(2)

Now, we have $sinx\approx f(x)$ for all $x\in [a,b]$ with the accuracy of $1/{10}^r$.

In the following, we take examples on approximating values of the sine function at rational and irrational arguments and getting the graph of approximate functions on an arbitrary intervals with various accuracy. Moreover, the approximation of integration on $[a,b]$ with integrands of the form $x^{m}sinx$ ($m\in \mathbb{N}$) is considered in both theoretical and practical aspects.

To find the approximate value of $sin(123.45)$ with the accuracy of $1/{10}^{20}$, we put $A:=[\mathtt{PiecewiseFunct}($123,124,20$)]$. Then, $\mathtt{nops}($A$)=2$ and the interval $[123,124]$ is partitioned into the subintervals $[123,123.3075117]$ and $[123.3075117,124]$. Thus, we take $f:=\mathtt{unapply}(\mathtt{op}(\mathtt{2},$A$[2]),\mathtt{x})$ and obtain

$$\begin{array}{cc}\hfill f(x)=& -1+\frac{{(x-x_0)}^2}{2}-\frac{{(x-x_0)}^4}{24}+\frac{{(x-x_0)}^6}{720}-\frac{{(x-x_0)}^8}{40320}\hfill \\ & +\frac{{(x-x_0)}^{10}}{3628800}-\frac{{(x-x_0)}^{12}}{479001600}+\frac{{(x-x_0)}^{14}}{87178291200}-\frac{{(x-x_0)}^{16}}{20922789888000}\hfill \\ & +\frac{{(x-x_0)}^{18}}{6402373705728000}-\frac{{(x-x_0)}^{20}}{2432902008176640000},\hfill \end{array}$$

where $x_0=123.092909816796832919274413636$. Hence, we have the desired approximation

$$sin(123.45)\approx \mathtt{evalf}[20](f(123.45))=-0.80035463532671180916.$$

Now, with an irrational number x, how do we approximate the value of $sinx$ with the accuracy of $1/{10}^r$? In principle, we can find a rational number $x^{\prime }$ such that $|x-x^{\prime }|<1/{10}^{r+1}$ and use the PiecewiseFunct procedure to determine a polynomial P that satisfies $|sin(x^{\prime })-P(x^{\prime })|<1/{10}^{r+1}$. Then, we have the estimate $|sinx-P(x^{\prime })|<1/{10}^r$. For example, we approximate the value of $sin(\sqrt{3})$ with the accuracy of $1/{10}^{50}$ by first taking

$$\sqrt{3}\approx x^{\prime }=1.732050807568877293527446341505872366942805253810381.$$

Since $\mathtt{nops}($A$)=1$, with $A:=[\mathtt{PiecewiseFunct}($1.73,2,51$)]$, we set $f:=\mathtt{unapply}(\mathtt{op}(\mathtt{2},$A$[1]),\mathtt{x})$. Then, we have the needed estimate

$$sin(\sqrt{3})\approx \mathtt{evalf}[51](f(x^{\prime }))=0.987026644990353783993324392439670388957092614144764.$$

There are many algorithms in the literature to find rational approximations to an irrational number with the desired accuracy, mostly using continued fractions. The theoretical basis of this classic problem can be found in the two great books [5] and [6]. CAS of course have their built-in commands to compute such approximations. Here, we may take $x^{\prime }$ by the calling sequence evalf[51](sqrt(3)).

Besides, from Equation (1) with the declaration in Equation (2), we derive the graph of piecewise polynomial approximation to the sine function by the command $\mathtt{plot}\mathtt{(}\mathtt{f}\mathtt{(}\mathtt{x}\mathtt{)}\mathtt{,}\mathtt{x}\mathtt{=}\mathtt{a}\mathtt{.}\mathtt{.}\mathtt{b}\mathtt{,}\mathtt{numpoints}\mathtt{=}\mathtt{500}\mathtt{)}$. We choose the large values $r=150$ and $r=500$ for the intervals $[-200,-50]$ and $[-100,600]$, respectively. Let us try the case $r=500$ to see the display of 448 pairs of interval–polynomial with the accuracy of $1/{10}^{500}$. The corresponding graphs are depicted in Figure 1.

We may also exploit PiecewiseFunct from the other side of our approximation. We have used Taylor polynomials with larger degrees when higher accuracy is required thus far. If we want to confine approximate polynomials to a fixed degree, we might relate this determination to the vector space ${\mathcal{P}}_{\ell }$, a subspace of $L^2(a,b)$. We know that in ${\mathcal{P}}_{\ell }$ there is the best polynomial approximation $p_{\mathrm{best}}$ of the sine function in $L^2$-norm $\parallel ·\parallel ={\langle ·,·\rangle }^{1/2}$ of $L^2(a,b)$, which is endowed with the inner product

$$\langle \phi ,\psi \rangle ={\int }_a^b\phi (x)\psi (x)dx.$$

Now, we use the Gram–Schmidt procedure to find an orthonormal basis $\{p_0,p_1,\dots ,p_{\ell }\}$ for ${\mathcal{P}}_{\ell }$ from the basis $\{1,x,x^2,\dots ,x^{\ell }\}$, according to the recursion

$$p_0:=1/\parallel 1\parallel =1/\sqrt{b-a},q_k:=x^k-\sum _{i=0}^{k-1}\langle x^k,p_i\rangle p_i,p_k:=q_k/\parallel q_k\parallel ,k=1,\dots ,\ell .$$

(3)

Once the orthonormal basis has been found, we obtain

$$p_{\mathrm{best}}=\langle sin,p_0\rangle p_0+\langle sin,p_1\rangle p_1+\cdots +\langle sin,p_{\ell }\rangle p_{\ell }=\sum _{k=0}^{\ell }\langle sin,p_k\rangle p_k.$$

To give an estimate for $\parallel sin-F\parallel$, where F is our piecewise polynomial approximation to the sine function on $[a,b]$, we first approximate $\langle sin,p_k\rangle$ by

$$\langle sin,p_k\rangle ={\int }_a^b{p}_k(x)sinxdx\approx \langle F,p_k\rangle ={\int }_a^b{p}_k(x)F(x)dx.$$

These estimates have the absolute error

$$|\langle sin,p_k\rangle -\langle F,p_k\rangle |=|\langle sin-F,p_k\rangle |\le \parallel sin-F\parallel ,$$

where

$$\parallel sin-F\parallel ={\left({\int }_a^b{|sinx-F(x)|}^{2}dx\right)}^{1/2}\le {\left(\frac{b-a}{{10}^{2r}}\right)}^{1/2}=\frac{\sqrt{b-a}}{{10}^r}.$$

Therefore, we may choose

$$p_{\mathrm{best}}^{\mathrm{c}}:=\sum _{k=0}^{\ell }\langle F,p_k\rangle p_k$$

(4)

as an approximation of $p_{\mathrm{best}}$. Then, we have the following estimation for the error norm

$$\parallel p_{\mathrm{best}}-p_{\mathrm{best}}^{\mathrm{c}}\parallel =\parallel \sum _{k=0}^{\ell }\langle sin-F,p_k\rangle p_k\parallel \le \sum _{k=0}^{\ell }\left|\langle sin-F,p_k\rangle \right|\le \frac{(\ell +1)\sqrt{b-a}}{{10}^r}.$$

(5)

Hence, we may take $r=\lfloor lg((\ell +1)\sqrt{b-a})\rfloor +1+u$ to obtain the estimate

$$\parallel p_{\mathrm{best}}-p_{\mathrm{best}}^{\mathrm{c}}\parallel <\frac{1}{{10}^u}.$$

To determine $p_{\mathrm{best}}^{\mathrm{c}}$ with MAPLE, it would be better to write the polynomial $p_k$ in the form of $p_k:={\sum }_{s=0}^k{a}_{ks}{x}^s$, hence we have

$$\langle F,p_k\rangle =\sum _{s=0}^k{a}_{ks}\langle F,x^s\rangle ,\mathrm{with}\langle F,x^s\rangle ={\int }_a^b{x}^{s}F(x)dx=\sum _{i=0}^n{\int }_{{\alpha }_i}^{{\alpha }_{i+1}}{x}^s{A}_i(x)dx.$$

(6)

According to the initial settings in Equation (1), the coefficients $a_{ks}$ and the inner products $\langle F,x^s\rangle$ can be computed by the following commands

$$\begin{array}{cc}\hfill a_{ks}& \to \mathtt{coeff}(\mathtt{p}[\mathtt{k}],\mathtt{x},\mathtt{s})\hfill \\ \hfill \langle F,x^s\rangle & \to \mathtt{add}(\mathtt{int}(\mathtt{x}^\mathtt{s}\ast \mathtt{F}[\mathtt{i}],\mathtt{x}=\mathtt{a}[\mathtt{i}]..\mathtt{b}[\mathtt{i}]),\mathtt{i}=\mathtt{1}..\mathtt{num})\hfill \end{array}$$

We can make a procedure named PowerIntApprox only to compute $\langle F,x^s\rangle$, $s=0,\dots ,\ell$. This procedure, which has one more argument, e.g., “deg”, for the chosen degree of $p_{\mathrm{best}}$, may take all the blocks of PiecewiseFunct, but replacing the output of Block 3, Block 4 and the last part of PiecewiseFunct with the commands recapped in the following. For the output RETURN of Block 3, we take the sum of integrals of $x^s{A}_i(x)$ on $[{\alpha }_i,{\alpha }_{i+1}]$, instead of giving the sequence of $\left[[{\alpha }_i,{\alpha }_{i+1}],A_i\right]$; and we do similarly for the output of Block 4. The last part of PiecewiseFunct may be replaced with the commands

$$\begin{array}{c}\mathtt{if}\mathtt{0}\mathtt{<}\mathtt{=}\mathtt{a}\mathtt{then}\hfill \\ \mathtt{evalf}\mathtt{[}\mathtt{r}\mathtt{]}\mathtt{(}\mathtt{ApproxInt}\mathtt{(}\mathtt{a}\mathtt{,}\mathtt{b}\mathtt{,}\mathtt{deg}\mathtt{,}\mathtt{r}\mathtt{)}\mathtt{)}\mathtt{;}\hfill \\ \mathtt{elif}\mathtt{b}\mathtt{<}\mathtt{=}\mathtt{0}\mathtt{then}\hfill \\ \mathtt{evalf}\mathtt{[}\mathtt{r}\mathtt{]}\mathtt{(}\mathtt{[}\mathtt{seq}\mathtt{(}\mathtt{(}\mathtt{-}\mathtt{1}\mathtt{)}\mathtt{^}\mathtt{(}\mathtt{i}\mathtt{+}\mathtt{1}\mathtt{)}\mathtt{\ast }\mathtt{ApproxInt}\mathtt{(}\mathtt{-}\mathtt{b}\mathtt{,}\mathtt{-}\mathtt{a}\mathtt{,}\mathtt{deg}\mathtt{,}\mathtt{r}\mathtt{)}\mathtt{[}\mathtt{i}\mathtt{+}\mathtt{1}\mathtt{]}\mathtt{,}\mathtt{i}\mathtt{=}\mathtt{0}\mathtt{.}\mathtt{.}\mathtt{deg}\mathtt{)}\mathtt{]}\mathtt{)}\mathtt{;}\hfill \\ \mathtt{else}\hfill \\ \mathtt{evalf}\mathtt{[}\mathtt{r}\mathtt{]}\mathtt{(}\mathtt{[}\mathtt{seq}\mathtt{(}\mathtt{(}\mathtt{-}\mathtt{1}\mathtt{)}\mathtt{^}\mathtt{(}\mathtt{i}\mathtt{+}\mathtt{1}\mathtt{)}\mathtt{\ast }\mathtt{ApproxInt}\mathtt{(}\mathtt{0}\mathtt{,}\mathtt{-}\mathtt{a}\mathtt{,}\mathtt{deg}\mathtt{,}\mathtt{r}\mathtt{)}\mathtt{[}\mathtt{i}\mathtt{+}\mathtt{1}\mathtt{]}\mathtt{,}\mathtt{i}\mathtt{=}\mathtt{0}\mathtt{.}\mathtt{.}\mathtt{deg}\mathtt{)}\mathtt{]}\hfill \\ \mathtt{+}\mathtt{ApproxInt}\mathtt{(}\mathtt{0}\mathtt{,}\mathtt{b}\mathtt{,}\mathtt{deg}\mathtt{,}\mathtt{r}\mathtt{)}\mathtt{)}\mathtt{;}\hfill \\ \mathtt{end}\mathtt{if}\mathtt{:}\hfill \end{array}$$

and the reason we do so can be easily recognized. Here, ApproxInt has a similar role as ApproxFunct, but is simpler to use.

Now, we have enough materials derived from Equations (3)–(6) to make a procedure for finding a desired approximation on $[a,b]$ in $L^2$-norm to the best approximation $p_{\mathrm{best}}$ of the sine function in ${\mathcal{P}}_{\ell }$ with a given positive integer ℓ. The procedure takes four arguments, a, b, ℓ and u, to give $p\in {\mathcal{P}}_{\ell }$ as its output such that $\parallel p-p_{\mathrm{best}}\parallel <1/{10}^u$. As mentioned above, if we named the procedure BestApprox, hence it takes PowerIntApprox as its local variable, then it would be interesting to run BestApprox with different values of its input. However, as warned in Section 1, we should pay much attention to the cases of large values of ℓ and u to take an appropriate regulation.

4. Conclusions

There could be some more useful ways to exploit the output of PiecewiseFunct and its corollary, PowerIntApprox, as well as Sine. Although these procedures are designed only for the sine function, we can make some appropriate changes to the blocks of commands to obtain their “cosine” version. It is hoped that some application results of our procedures would supply some more improved computational tools in applied mathematics.