How to write a prorgram to compute sin(x) without using trigonometric function that uses taylor series?

For a homework assignment I am asked the following, I am asking for help here because my Prof. will not help and the TA's do not know how to do it. Here it is:

Write a program to compute sin(x). The name of the program is dsin, and it accepts the user input – x – in degrees. Your program converts x to radians, and uses taylor series to compute sin(x) within some defined accuracy. The program has two versions; one version uses the ‘while’ construct, and the other version uses the ‘for’ construct.

Note: • Taylor series approximates the sinusoidal function for -180 ≤ x ≤ 180 degrees (or -pi ≤ x ≤ pi). If your input is out of this range, your program must translate it to a value within the range. • When you run dsin, it prompts; Enter angle in degrees: • After you type desired angle, the result will return. • You are not allowed to use the trigonometric functions provided by Matlab!

Answer 1

[Geoff Hayes]

Jake - from https://en.wikipedia.org/wiki/Taylor_series, a Taylor series is a representation of a function as an infinite sum of terms that are calculated from the values of the function's derivatives at a single point... If the Taylor series is centered at zero, then that series is also called a Maclaurin series. So you will be implementing the Maclaurin series for sin(x). Since the series is a representation of a function as an infinite sum of terms, then you will use while or for loop to compute the sum (to some defined accuracy).

As this is a homework question, we can only give out hints so you will need to post a describe what you have attempted. Are you observing any errors and, if so, what are they?

Answer 2

[John BG]

Hi Stringfellow

1.

Many hand held calculators use the CORDIC algorithm

.

that is pretty good at approximating sin and cos trigonometric functions.

MATLAB includes a group of CORDIC related functions, following MATLAB example from this link:

https://uk.mathworks.com/help/fixedpoint/ref/cordiccos.html?s_tid=srchtitle

.

% Create 1024 points between [0, 2*pi)
stepSize = pi/512;
thRadDbl = 0:stepSize:(2*pi - stepSize);
thRadFxp = sfi(thRadDbl, 12);    % signed, 12-bit fixed-point
cosThRef = cos(double(thRadFxp));   % reference results

% Use 12-bit quantized inputs and vary the number
% of iterations from 2 to 10.
% Compare the  fixed-point CORDIC results to the
% double-precision trig function results.
for niters = 2:2:10
    cdcCosTh  = cordiccos(thRadFxp,  niters);
    errCdcRef = cosThRef - double(cdcCosTh);
end

figure
hold on
axis([0 2*pi -1.25 1.25]);
    plot(thRadFxp, cosThRef,  'b');
    plot(thRadFxp, cdcCosTh,  'g');
    plot(thRadFxp, errCdcRef, 'r');
    ylabel('cos(\Theta)');
    gca.XTick = 0:pi/2:2*pi;
    gca.XTickLabel = {'0','pi/2','pi','3*pi/2','2*pi'};
    gca.YTick = -1:0.5:1;
    gca.YTickLabel = {'-1.0','-0.5','0','0.5','1.0'};
    ref_str = 'Reference: cos(double(\Theta))';
    cdc_str = sprintf('12-bit CORDIC cosine; N = %d', niters);
    err_str = sprintf('Error (max = %f)', max(abs(errCdcRef)));
    legend(ref_str, cdc_str, err_str);

.

CORDIC reading: https://en.wikipedia.org/wiki/CORDIC

.

CORDIC requires a table with atan values

2.

Another approximation, between 0º and 180º, for sin function, is Bhaskara I's

dx=180/210;
x=[0:dx:180-dx];
y=sind(x);
y2=4*x.*(180-x)./(40500-x.*(180-x));
 err=abs(y-y2);
max(err)
=
   0.001630316128806

or from same author, approximate sin between 0º and 180º with 2 parabolas:

y_upper=x.*(180-x)./8100;

y_lower=x.*(180-x)./9000;

if you find this answer useful would you please be so kind to mark my answer as Accepted Answer?

To any other reader, please if you find this answer of any help solving your question,

please click on the thumbs-up vote link,

thanks in advance

John BG

<mailto:[e-mail] [e-mail]>

[Jan]

An interesting answer. Jake asks for Taylor series explicitly.

[John BG]

the question header reads

How to write a program to compute sin(x) 

*without using trigonometric function that uses Taylor series*

any one understands from the header: without using Taylor

then in the rather convoluted explanation the following rather awkward requirements are made

1. get the input in degree but translate to radians.

(just get the input in radians, oder?)

2. use taylor series to some degree of accuracy

(!?)

without the error threshold one doesn't know when to stop the Taylor series.

3.

Taylor series approximates the sinusoidal function for -180 ≤ x ≤ 180 degrees (or -pi ≤ x ≤ pi).

not correct

the Taylor series approximates a function around a point, a single point.

The more terms the wider the range around the chosen point where the error is kept below specs, BUT Taylor series error grows really quickly, have a look at the following:

da=2*pi/200;x=[0:da:2*pi];
N=5;n=[1:2:N];

P=zeros(1,numel(x));
for k=n

L=x.^k/factorial(k)*(-1)^k;
P=[P;L];

end

P(1,:)=[];

plot(sin(x));grid on
hold all;
plot(P(2,:))
plot(P(3,:))
plot(P(4,:))

the terms used to approximate sin(x) do not keep error small through the [0 360] cycle, but the nature of the functions used makes Taylor unsuitable to approximate sin(x) or cos(x) throughout a broad range like [0 360] or [-180 180]

figure(2);plot(sin(x));grid on
hold all
figure(2);plot(sum(P([1:end],:)));

the sin(x) signal is the blue trace inboth pictures, almost flat compared to the functions used to approximate sin(x)

the more terms you take with a Taylor series, the higher the accuracy around a rather narrow range centred on the chosen point, but no way one can approximate throughout [-180 180].

So, the other way to approximate sin(x) or cos(x) is with Chebychev polynomials, and these polynomials can keep error below specs throughout the entire cycle, if enough Cheby polynomials used:

syms x y
for n = [1, 2, 3, 4, 5]
  fplot(chebyshevT(n, x))
  hold on
end

hold off

axis([-1.5, 1.5, -6, 6]);grid on;ylabel('T_n(x)')

legend('T_1(x)', 'T_2(x)', 'T_3(x)', 'T_4(x)', 'T_5(x)', 'Location', 'Best')
title('Chebyshev polynomials of the first kind')

hold on;patch('XData',[-1 1 1 -1],'YData',[1 1 -1 -1],'LineStyle','--','FaceAlpha',0)

.

So CORDIC is a very robust way to implement the polynomial approximation.

It's like the butterfly algorithm to the Discrete Fourier Transform. You wouldn't stop calling the FFT a Fourier Transform just because of the way the different bundles are interleaved in a faster implementation of the transform, would you?

So CORDIC is to sin(x) approximation what the FFT to te DFT.

Recommended reading: Texas Instruments Knowledge Centre CORDIC note

https://epsstore.ti.com/OA_HTML/csksxvm.jsp?nSetId=74414

Therefore, dear readers, I have to insist on the point that CORDIC would be the ideal algorithm to approximate sin(x) throughout an entire cycle, and therefore I consider that my answer is the one that deserves to be the accepted answer to this question.

Would please Mr Stringfellow mind commenting a bit, it would be greatly appreciated a bit from his side

regards

John BG

<mailto:[e-mail] [e-mail]>

[Walter Roberson]

The body of the Question, copying the homework assignment (which the poster specifically says they are working on), requires,

"Your program converts x to radians, and uses taylor series to compute sin(x) within some defined accuracy."

[John D'Errico]

John BG - As seems to be a common event for you, you have spent a great deal of time doing a homework assignment for someone, something that we explicitly try NOT to do here. Worse, you have never bothered to actually read the requirements.

[Jan]

@John BG: As I have written already, your remarks are interesting, but they do not match the asked question. You have missunderstood the title, but the body of the question is unequivocal.

You had selected your answer as accepted by your own. This was a bad choice and this thread is a perfect example, why selecting own answers should and must be forbidden in this forum.