Taylor and Maclaurin Series

Lets try with Taylor and Maclaurin Series. We start by supposing that ƒ is any function that can be represented by a power series:

Let’s try to determine what the coefficients c_n must be in terms of ƒ. To begin, notice that if we put x = a in Equation 1, then all terms after the first one are 0 and we get

ƒ(a) = c₀

If we differentiate the series in equation 1 term by term...

Here we just convert the degree in radian as we know that
180⁰ = π^c

And the substitution of x = a in equation 2

ƒ^'(a) = c₁

Now we differentiate both sides of Equation 2 and obtain

Again we put x = a in Equation 3. The result is

ƒ^''(a) = 2c₂

Let’s apply the procedure one more time. Differentiation of the series in Equation 3 gives

ƒ^'''(a) = 2.3c₃ = 3!c₃

By now you can see the pattern. If we continue to differentiate and substitute x = a, we obtain

Solving this equation for the n^th coefficient c_n, we get

This formula remains valid even for n = 0 if we adopt the conventions that 0! = 1 and ƒ⁽⁰⁾ = ƒ.

Thus we have proved the following theorem.
THEOREM: If ƒ has a power series representation (expansion) at a, that is, if

Substituting this formula for c_n back into the series, we see that if ƒ has a power series expansion at a, then it must be of the following form.

This equation is called the Taylor series of the function ƒ at a (or about a or centered at a). For the special case a = 0 the Taylor series becomes

This case arises frequently enough that is is given the special name Maclaurin series.

EXAMPLE 1: Find the Maclaurin series for sin x and prove that it represents sin x for all x.
Solution: We arrange our computation in two columns as follows:

Since the derivatives repeat in a cycle of four, we can write the Maclaurin series as follows:

See the C program to find out sin(x)

EXAMPLE 2: Find the Maclaurin series for cosx and prove that it represents cosx for all x.
Solution: We arrange our computation in two columns as follows:

See the C program to find cos(x)

Collected from Calculus Website, by Kiryl Tsishchanka

C program For Trigonometric ratio.

Lets try with the library function to calculate the trigonometric ratio. Here use the built in function. The C library function double cos(double x) returns the cosine of a radian angle x. Correspondingly the sin(x) and tan(x)

Here we just convert the degree in radian using 180⁰ = π^c (Radian)

// Using Library function
#include<stdio.h>
void main(){
    float tempt, degree;
    printf("Enter the number \(In degree\)\n");
    scanf("%f",&degree);
    tempt = degree;
    degree = degree * 3.14159265359 / 180;
    printf("sin\(%.2f\) = %1.2f\n",tempt, sin(degree));
    printf("cos\(%.2f\) = %1.2f\n",tempt, cos(degree));
    printf("tan\(%.2f\) = %1.2f\n",tempt, tan(degree));


}

Now try with Taylor and Maclaurin Series Following are these equations.. we will transform them in our program.

#include<math.h>
#include<stdio.h>
double  factorial(int num){
        double fact =1;
        int i;
        for(i=1;i<=num;i++){
            fact = fact*i;
        }

        return fact;
}

void main(){
    double tempt, x,sum=1.0;
    int term,counter;
    int  sign =-1.0;
    printf("Enter the term number till you want to calculate the value\n");
    scanf("%d",&term);
    printf("Enter the value of x\n");
    scanf("%lf",&x);
    tempt=x;

//ex
    for(counter=1;counter <= term ; counter++){
        sum = sum + ((pow(x,counter))/(factorial(counter)));
    }
 printf("So the Taylor series of ex around %.1lf is %.15lf \n",tempt,sum);

//sinx
x = x * 3.14159265359 / 180;
sum = x;
for(counter=3;counter<=term;counter+=2){
   sum = sum + (sign * (pow(x,counter))/factorial(counter));
}
printf("The Taylor series of sin(x) around %.1lf is %.15lf \n",tempt,sum);


// cosx
 sum = 1.0;
 sign = -1.0;
 for(counter=2;counter <= term ; counter += 2){
        sum = sum + (sign *(pow(x,counter))/factorial(counter));
        sign = sign * (-1);
    }
 printf("The Taylor series of cos(x) around %.1lf is %.15lf \n",tempt,sum);


}

Explanation

Here we use a user defined function factorial which takes an integer value to calculate it's factorial and the function also return a double type integer.

Here we use some variables
x = the variable of Taylor series.
sum = to hold the value of cos, sin and e^x
tempt = to hold the value of x, as we change the value of x into radian.
term = Number of term of Taylor series.
counter = loop counter.
sign = to make negative number.

---

e^x

We initialize the sum with 1, and the series of e^x also start with 1 then just use it's corresponding arithmetic expression

sin(x)

Again we initialize the sum with 1 since the series of cos(x) start with 1, the counter variable start with 2 and each time it increases by 2, as the series goes. and the sign variable also changes its negativity after each iteration.

cos(x)

Notice that the sin(x) series start with x so again we initialize the sum with x and goes as like the Taylor series.

1's and 2's complement

1’s Complements: Just replaces each one with ‘0’ and each zero with ‘1’. For example: 100101 it’s 1’s complement is 011010

2’s Complements: When we add an extra one with the 1’s complements of a number we will get the 2’s complements. For example: 100101 it’s 1’s complement is 011010 and 2’s complement is 011010+1 = 011011 (By adding one with 1's complement)

Why we need the complements of a number

One reason of it is to represent the negative number. In binary system we use ‘1’ for negative number and ‘0’ for positive number. We represent the sign of a number using an extra bit at the extreme left of the number. For example 0,101 is +5 and 1,011 is -3.

And the most important reason is that, if we can evolve only one convention for representing positive and negative numbers which would allow us to use one basic procedure for both addition and subtraction. If the procedure is same, we could use a single electronic circuit to implement both addition and subtraction. A convention for representing negative numbers which allows this is the ‘complement representation’ of numbers.

2’s Complement

With n bits we can represent 2ⁿ number. For example if we take 4 bits then 2⁴ = 16, so with 4 bits we can represents 16 different numbers(0 to 15 here.)

From the above image we can see that we have divided the total range (0-15) into two parts. one is 0001(1) to 0111(7) and another is 1001(9) to 1111(15). Now we use the first seven combinations of 4 bits for representing positive numbers 1 to 7 (See the above image). And we reserve the other seven combinations for representing the negative number -1 to -7. This images actually as the following…

Let’s see with formula

The 2’s complement of a binary number x, which has n bits, is given by (2ⁿ-x).. Of the n bits of the complement representation (n-1) bits represent the magnitude. That is 4 bits for the whole system {0000 through 1111(15)} and (n-1) = 4-1 = 3 bits represents the magnitude {000 through 111(8)} Consider the number +3 whose binary representation is 0011. it has four bits. Hence the 2’s complement of +3 is (2⁴-3) which is 13 (1101) (See on the image). Thus 0011’s 2’s complement is 1101

From the above two images we see that the code 1111, which is normally represents 15, is assigned to -1. So 2⁴-1 = 15. Similarly the binary equivalent of 4(0100) is assigned to 12(1100). And 2⁴-4 = 12

1’s Comppement

If we notice the circular image we can see that 0001(1) points to the 1110(-2), Similarly 0110(6) points to 1001(-7). The amazing thing is that 1110(-2) is the 1’s complements of 0001(1) and 1001(-7) is 1’s complement of 0110(6). So the normal thinking is that if we want to find the 1’s complements of 165 is -166, we can say without any doubt. Just increment it by one and make its sign negative.

Are you thinking what about 8!!
Yeah that’s right. Lets see what about the 8(1000) 2’s complements

1’s complements of 8(1000) is 0111, and 2’s complement is 0111+1 = 1000. Which is equivalent 8.

C program for Bitwise Operation.

To know more about Bitwise operation please read the Bitwise Operator in C. It explains how these bitwise operator work in C

#include <stdio.h>
void main(void)
{
    int i=165,j=281;
    printf("Bitwise AND operation of %d and %d is %d \n", i,j, i&j);
    printf("Bitwise OR operation of %d and %d is %d \n", i,j, i|j);
    printf("Bitwise XOR operation of %d and %d is %d \n", i,j, i^j);
    printf("2 bits right shift of %d is %d \n", i, i>>2 );
    printf("3 bits left shift of %d is %d \n", i, i<<3);
    printf("NOT operation of %d is %d \n", i, ~i);

}

Bitwise Operator in C

In the C programming language, operations can be performed on a bit level using bitwise operators.

Following are the six bitwise operators provided by C for bit manipulation

Symbol	Operator
&	bitwise AND
|	bitwise inclusive OR
^	bitwise exclusive OR
<<	left shift
>>	right shift
~	bitwise NOT (one's complement) (unary)

To understand these operation lets ahead with two example..
We know that in C, integer consumed 2 bytes or 16 bit memory. So the binary representation of 165 and 281 as the following

(165)₁₀ = (10100101)₂

(281)₁₀ = (100011001)₂

But in C when it consumed 16 bits, it will like the following..

165 = 0000000010100101

281 = 0000000100011001

These extra bits(0's) are added to make it 16 bit integer number. Now the operation take place as..

Now remains the shift operations, yeah..
You will clear by seeing the following two images of Right shift (>>) and Left Shift (<<)

Right Shift >>

To understand the operation we shifted it by 2 bits. All the bits of the number (165) shifted to right by 2 bits.

Left Shift

To understand it we shifted the number by 3 bits, all the bits of the number (165) shifted to left by 3 bits

NOT operation

We first complement each bit of the number (i.e., replace '1' by '0' and '0' by '1') To know more about 1's and 2's Complement

See the C program With All the bitwise operation

C program and flowchart to find the largest of three numbers

Following is the flowchart to find out the largest of three number

And following is the C code

#include <stdio.h>
void main(void)
{
    int A,B,C;
    printf("Enter 3 integer number \n");
    scanf("%d",&A);
    scanf("%d",&B);
    scanf("%d",&C);
    if(A>B){
        if(A>C){
            printf(" %d is the Greatest Number \n",A);
        }
        else{
            printf("%d is the greatest Number \n",C);
        }
    }
    else{
            if(B>C){
                printf("%d is the greatest Number \n",B );
            }
            else{
                printf("%d is the greatest Number \n", C);
            }
    }
}

To check if it is Leap Year with C

#include <stdio.h>
void main(void)
{
    int year;
    printf("Enter a year to check if it is Leap Year\n");
    scanf("%d",&year);
    if(year%400==0) /* Why  mod 400 */
        printf("%d is a Leap Year\n",year);
    else if(year%100==0) /*  Why  mod 100  */
        printf("%d is not a Leap Year\n",year);
    else if(year%4==0)
        printf("%d is a Leap Year\n",year);
    else
        printf("%d is not a Leap Year\n",year);

}

The reason for leap year

Who invented Leap Years?

Julius Caesar introduced Leap Years in the Roman empire over 2000 years ago, but the Julian calendar had only one rule: any year evenly divisible by 4 would be a leap year. This led to way too many leap years, but didn't get corrected until the introduction of the Gregorian Calendar more than 1500 years later.

Which Years are Leap Years?

In the Gregorian calendar 3 criteria must be taken into account to identify leap years:

1. The year is evenly divisible by 4;
2. If the year can be evenly divided by 100, it is NOT a leap year, unless;
3. The year is also evenly divisible by 400. Then it is a leap year.

Example

The year 1600 was a leap year. The years 1700, 1800, 1900 were not leap years. However, the year 2000 was a leap year. The years 2100, 2200, 2300 will not be leap years. The year 2400 will be a leap year. The year 2500 will not be a leap year.

But Why??

Because of the following reasons

It takes the Earth approximately 365.242199 days – or 365 days, 5 hours, 48 minutes, and 46 seconds – to circle once around the Sun. This is called a tropical year. So we are 5 hours, 48 minutes, and 46 ahead than calender, this makes after four years.........

We found that we are ahead 23 hours, 15 Mins and 4 Seconds. And we count it as one day(24 hours) and this makes February 29 days instead of 28 days.

Now notice that it also got some error since we are considering 23 Hours 15 Minutes and 4 seconds as a day. So calendar now ahead by..

From the above we can see that the calendar is now ahead by 0 hours, 44 minutes and 56 seconds after each four years to make an extra days(February -29). So for 1 year the calender is ahead by 0/4 = 0 years, 44/4=11 minutes and 56/4=14 Seconds. And for 100 years…

After 100 years, As the calendar is ahead by 18 hours, 43 Minutes and 20 seconds So don't count the 100 years as the leap year, though it is divisible by 4

It has also a problem!

Since calendar was ahead by 18 hours, 43 Minutes and 20 seconds we give to the calender 24 hours(By letting February in 28 days). Again we are ahead by ...6 hours 17 Minutes and 40 seconds...

This causes after 100 years, what will happen after 400 years!!

So after 400 years we are ahead by 25 hours 10 minutes and 40 seconds This makes the 400^th a leap year.

You may ask that we are still ahead by 1 hour 10 minutes and 40 seconds. Yeah that's right! But this has trivial effect on tropical year as it divide among each year of 400 years!!! Gotcha??

Here the C Program to find Leap year

What is Modulo operation?

In computing, the modulo operation finds the remainder of division of one number by another (sometimes called modulus).

Given two positive numbers, a (the dividend) and n (the divisor), a modulo n (abbreviated as a mod n) is the remainder of the division of a by n .

For instance, the expression "5 mod 2" would evaluate to 1 because 5 divided by 2 leaves a quotient of 2 and a remainder of 1.

While "9 mod 3" would evaluate to 0 because the division of 9 by 3, has a quotient of 3 and leaves a remainder of 0; there is nothing to subtract from 9 after multiplying 3 times 3.

The following example of modulo operation will explain itself better, For example you are given some hours, Let’s consider 772 hours and you are told to find out the extra days which do not make a day. Then you will do it by the following arithmetic division

So there are 32 days and 4 hour. Now you find your result 4(The extra days which do not make a day) But in programming we can do by just one command “772 mod 24” which evaluates 4.

See a program to find out the odd-even number with modulus operator

Find out Odd and Even number using C

C program tofind out odd or even number using modulus operator

#include <stdio.h>

void main(void)
{
int i;
printf("Enter an integer\n");
scanf("%d",&i);       
if(i%2==0)/* Modulo operator  Here it produce 0 for every even Number */
{
        printf("This is an even number.\n");
}

else
{
    printf("This is an odd Number\n");
}