Friday, May 31, 2013

Newton-Raphson Method (C code for finding a real root of an equation)

This article is about Newton's method for finding roots.

In numerical analysis, Newton's method (also known as the Newton–Raphson method), named after Isaac Newton and Joseph Raphson, is a method for finding successively better approximations to the roots (or zeroes) of a real-valued function.
x : f(x) = 0 \,.
The Newton-Raphson method in one variable is implemented as follows:
Given a function ƒ defined over the reals x, and its derivative ƒ ', we begin with a first guess x0 for a root of the function f. Provided the function satisfies all the assumptions made in the derivation of the formula, a better approximation x1 is
x_{1} = x_0 - \frac{f(x_0)}{f'(x_0)} \,.
Geometrically, (x1, 0) is the intersection with the x-axis of a line tangent to f at (x0, f (x0)).
The process is repeated as
x_{n+1} = x_n - \frac{f(x_n)}{f'(x_n)} \,
until a sufficiently accurate value is reached.
This algorithm is first in the class of Householder's methods, succeeded by Halley's method. The method can also be extended to complex functions and to systems of equations.

C code for finding a real root of  the equationf(x)= x*x*x-2*x-5 using Newton-Raphson Method

#include
//#include
#include
int main(){
    //clrscr();
    int i;
    float x,fx,fdx,t;
    printf("Enter x0: ");
    scanf("%f",&x);
    //freopen("file.txt","w",stdout);
    for(;;)
    {
        t=x;
        fx=pow(x,3)-(2*x)-5;
        fdx=3*pow(x,2)-2;
        x=t-(fx/fdx);
        printf("\nthe value of x is::%f\n",x);
        if(fabs(x-t)<=0.0001)
        {
            printf("The root is: %f",x);
            break;
        }
    }
    //fclose(stdout);
    getch();
    return 0;
}

sample output:

Enter x0: 2

the value of x is::2.100000

the value of x is::2.094568

the value of x is::2.094552
The root is: 2.094552

Implementation of Iterative Method


In computational mathematics, an iterative method is a mathematical procedure that generates a sequence of improving approximate solutions for a class of problems. A specific implementation of an iterative method, including the termination criteria, is an algorithm of the iterative method. An iterative method is called convergent if the corresponding sequence converges for given initial approximations. A mathematically rigorous convergence analysis of an iterative method is usually performed; however, heuristic-based iterative methods are also common.
In the problems of finding the root of an equation (or a solution of a system of equations), an iterative method uses an initial guess to generate successive approximations to a solution. In contrast, direct methods attempt to solve the problem by a finite sequence of operations. In the absence of rounding errors, direct methods would deliver an exact solution (like solving a linear system of equations Ax = b by Gaussian elimination). Iterative methods are often the only choice for nonlinear equations. However, iterative methods are often useful even for linear problems involving a large number of variables (sometimes of the order of millions), where direct methods would be prohibitively expensive (and in some cases impossible) even with the best available computing power.

C code to find a real root of the equation 2x=cosx+3 using Iterative method:

  /***********************************************************
* You can use all the programs on  www.engineercse.blogspot.com
* for personal and learning purposes.
* contact azam.ruet10@gmail.com
* To find more C programs, do visit www.engineercse.blogspot.com
* and browse!
*
*                            Coding is poetry!!!

***********************************************************/
#include
#include
#include
#include

int main(){
    int i;
    float f,a,b,x,t;
    scanf("%f",&x);
    //x=(a+b)/2;
    if((sin(x)/2)<1 br="">        for(i=0;i<2000 br="" i="">            t=f;
            //x=0;
            //f=0;
            f=(cos(x)+3)/2;
            printf("%f\n",x);
            //t=f;

            x=f;
            if(fabs(f-t)<=0.0001)
                break;
            //t=f;
        }
        printf("\nThe Root is: %f",x);
    }
    else
        printf("\nThe Method cannot be applied..");

    getch();
}


sample output: 90

90.000000
1.275963
1.645290
1.462788
1.553900
1.508448
1.531154
1.519816
1.525479
1.522651
1.524063
1.523358
1.523710
1.523534

The Root is: 1.523622

Implementing Bisection Method[Numerical Methods]

The method is applicable when we wish to solve the equation f(x) = 0 for the real variable x, where f is a continuous function defined on an interval [ab] and f(a) and f(b) have opposite signs. In this case a and b are said to bracket a root since, by the intermediate value theorem, the f must have at least one root in the interval (a, b).
At each step the method divides the interval in two by computing the midpoint c = (a+b) / 2 of the interval and the value of the function f(c) at that point. Unless c is itself a root (which is very unlikely, but possible) there are now two possibilities: either f(a) and f(c) have opposite signs and bracket a root, or f(c) and f(b) have opposite signs and bracket a root. The method selects the subinterval that is a bracket as a new interval to be used in the next step. In this way the interval that contains a zero of f is reduced in width by 50% at each step. The process is continued until the interval is sufficiently small.
Explicitly, if f(a) and f(c) are opposite signs, then the method sets c as the new value for b, and if f(b) and f(c) are opposite signs then the method sets c as the new a. (If f(c)=0 then c may be taken as the solution and the process stops.) In both cases, the new f(a) and f(b) have opposite signs, so the method is applicable to this smaller interval.[4]

C code implementing bisection method for the equation x*x*x-2*x-5
#include
#include
double f(double x)
{
    return (x*x*x-2*x-5);
}
int main()
{
    double a,b,x;
    scanf("%lf %lf",&a,&b);
    if((f(a)>=0 && f(b)>=0) || (f(a)<0 amp="" b="" br="" f="">    printf("possible\n");
    else
    {
       while(1)
       {
           x=(a+b)/2;
           printf("%lf\n",x);
           if(fabs(f(x)-0)<=0.001)
           {
               printf("%lf\n",x);
               break;
           }
           if((f(a)>=0 && f(x)>=0) || (f(a)<0 amp="" br="" f="" x="">              a=x;
           else
              b=x;
       }
    }
    getch();
    return 0;
}


sample o/p:
2 3
2.500000
2.250000
2.125000
2.062500
2.093750
2.109375
2.101563
2.097656
2.095703
2.094727
2.094238
2.094482
2.094482

Analysis :  

The method is guaranteed to converge to a root of f if f is a continuous function on the interval [a, b] and f(a) and f(b) have opposite signs. The absolute error is halved at each step so the method converges linearly, which is comparatively slow.
Specifically, if c1 = (a+b)/2 is the midpoint of the initial interval, and cn is the midpoint of the interval in the nth step, then the difference between cn and a solution c is bounded by
|c_n-c|\le\frac{|b-a|}{2^n}.
This formula can be used to determine in advance the number of iterations that the bisection method would need to converge to a root to within a certain tolerance. The number of iterations needed, n, to achieve a given error (or tolerance), ε, is given by: n = \log_2\left(\frac{\epsilon_0}{\epsilon}\right)=\frac{\log\epsilon_0-\log\epsilon}{\log2} ,
where \epsilon_0 = \text{initial bracket size} = b-a .
Therefore, the linear convergence is expressed by\epsilon_{n+1} = \text{constant} \times \epsilon_n^m, \ m=1 .                     


Friday, May 24, 2013

NQueen problem implementation

 /***********************************************************
* You can use all the programs on  www.engineercse.blogspot.com
* for personal and learning purposes. For permissions to use the
* programs for commercial purposes,
* contact azam.ruet10@gmail.com
* To find more C programs, do visit www.engineercse.blogspot.com
* and browse!
*
*                            Coding is poetry!!!

***********************************************************/
#include
#include
#include
void print_solution(int n,int x[]){
      int i,j;
      char c[100][100];
   for(i=1;i<=n;i++){
   for(j=1;j<=n;j++){
          c[i][j]='X';}
        }
   for(i=1;i<=n;i++){
          c[i][x[i]] ='Q';
           }
           for(i=1;i<=n;i++){
           for(j=1;j<=n;j++){
                printf("%c\t",c[i][j]);
                      }
                  printf("\n");
                  }
    }

int place(int x[],int n){

   int i;
   for(i=1;i        if((x[i] == x[n]) || (i-x[i] == n-x[n]) || (i+x[i]==n +x[n])){
       return 0;
         }
           }
    return 1;
       }

void nqueens(int n){
      int x[100],count=0,k=1;

         x[k] = 0;

        while(k != 0){
          x[k] +=1;
          while((x[k] <= n) && ( !place(x,k))){
              x[k] +=1;
                 }
            if(x[k] <= n){
              if(k == n){
                  count++;
                     printf("solution:%d\n",count);
                      print_solution(n,x);
                        }
               else{
                     k++;
                     x[k]=0;
                     }
                }
             else{
                 k--;
                 }

}
}
int main()
{
int n;
printf("enter number of queens\n");
scanf("%d",&n);

nqueens(n);
getch();
return 0;
}


To get more C Program go here
To get more DFS algorithmic code click

Learn C Programming

Implementing BFS(Breath's First Search) using C++

/***********************************************************
* You can use all the programs on  www.engineercse.blogspot.comprogrammers' blog
* for personal and learning purposes. For permissions to use the
* programs for commercial purposes,
* contact azam.ruet10@gmail.com
* To find more C programs, do visit www.engineercse.blogspot.com
* and browse!
*
*                            Coding is poetry!!!
***********************************************************/

#include
#include
#include
#include
#define inf 1000000
#define clear(x,a) memeset(x,a,sizeof(x))
using namespace std;

bool adj[100][100];
int n, white=1, gray=2, black=3, color[100],d[100],edge, node[100],parent[100],source;
queue Q;
void bfs();

int main()
{
   int start,end;
   cout<<"vertices::";
   cin>>n;
   cout<<"\nedges::";
   for(int i=1;i<=n;i++)
     color[i]=white,d[i]=inf,parent[i]=-1;
     cin>>edge;
     cout<<"\nstart and ending vertex::";
     while(edge--)
     cin>>start>>end,adj[start][end]=true,adj[end][start]=true;
     cout<<"\nsource vertex:";
     cin>>source;
     bfs();
     for(int i=1;i<=n;i++)
     cout<     return 0;
}

void bfs()
{
    d[source]=0;
    Q.push(source);
    color[source]=gray;
    while(!Q.empty())
    {
        int s=Q.front();
        for(int i=0;i<=n;++i)
        {
            if(adj[s][i]and color[i]==white)
            Q.push(i), color[i]=gray, d[i]=d[s]+1, parent[i]=s;
        }
        Q.pop();
    }
}


To get more C Program go here
To get more DFS algorithmic code click

MERGE SORT Algorithm implementation / Application of Divide-and-conquer Method

 /***********************************************************
* You can use all the programs on  www.engineercse.blogspot.com
* for personal and learning purposes. For permissions to use the
* programs for commercial purposes,
* contact azam.ruet10.com
* To find more C programs, do visit www.engineercse.blogspot.com
* and browse!
*
*                        Coding is poetry!!!
***********************************************************/
#include
#include
#define MAX_ARY 10
int arr[MAX_ARY];
void merge_sort(int low, int high);
void Merge(int low, int mid, int high);

int main(void)
{

    int j =0;
    printf("\n\nEnter the elements to be sorted:\n");
    for(j=0;j      scanf("%d",&arr[j]);
      printf("\n");
      printf("Before Merging:");
      for(j=0;j      printf("%d ",arr[j]);
    merge_sort(0,MAX_ARY-1);
    printf("After Merging::");
    for(j=0;j    printf("%d  ", arr[j]);

    getch();
}

void merge_sort(int low, int high)
{

    int mid;

    if(low    {
    mid = (low+high)/2;
    merge_sort(low, mid);
    merge_sort(mid+1 , high);
    Merge(low,mid,high);
    }
}

void Merge(int low, int mid, int high){
    int b[MAX_ARY],k;
   int h = low;
   int i = low;
   int j = mid+1;
   while((h<=mid) && (j<=high))
   {
      if(arr[h]<=arr[j]){
         b[i] = arr[h];
         h++;
      }
      else
      {
          b[i] = arr[j];
          j++;
      }
      i++;
   }
      if(h>mid)
      {
         for( k=j;k<=high;k++)
         {
            b[i]=arr[k];
            i++;
         }
      }
      else
      for(k=h; k<=mid;k++)
      {
          b[i] = arr[k];
          i++;
      }
   for(k=low;k<=high;k++)
   arr[k] = b[k];
}


get CSE 402 LAB codes CSE402 LAB practise

Wednesday, May 22, 2013

Insertion, Deletion & searching operation in BST using Code::Blocks

#include
  #include

  struct treeNode {
        int data;
        struct treeNode *left, *right;
  };

  struct treeNode *root = NULL;

  /* create a new node with the given data */
  struct treeNode* createNode(int data) {
        struct treeNode *newNode;
        newNode = (struct treeNode *) malloc(sizeof (struct treeNode));
        newNode->data = data;
        newNode->left = NULL;
        newNode->right = NULL;
        return(newNode);
  }

  /* insertion in binary search tree */
  void insertion(struct treeNode **node, int data) {
        if (*node == NULL) {
                *node = createNode(data);
        } else if (data < (*node)->data) {
                insertion(&(*node)->left, data);
        } else if (data > (*node)->data) {
                insertion(&(*node)->right, data);
        }
  }


  /* deletion in binary search tree */
  void deletion(struct treeNode **node, struct treeNode **parent, int data) {
        struct treeNode *tmpNode, *tmpParent;
        if (*node == NULL)
                return;
        if ((*node)->data == data) {
                /* deleting the leaf node */
                if (!(*node)->left && !(*node)->right) {
                        if (parent) {
                                /* delete leaf node */
                                if ((*parent)->left == *node)
                                        (*parent)->left = NULL;
                                else
                                        (*parent)->right = NULL;
                                free(*node);
                        } else {
                                /* delete root node with no children */
                                free(*node);
                        }
                /* deleting node with one child */
                } else if (!(*node)->right && (*node)->left) {
                        /* deleting node with left child alone */
                        tmpNode = *node;
                        (*parent)->right = (*node)->left;
                        free(tmpNode);
                        *node = (*parent)->right;
                } else if ((*node)->right && !(*node)->left) {
                        /* deleting node with right child alone */
                        tmpNode = *node;
                        (*parent)->left = (*node)->right;
                        free(tmpNode);
                        (*node) = (*parent)->left;
                } else if (!(*node)->right->left) {
                        /*
                         * deleting a node whose right child
                         * is the smallest node in the right
                         * subtree for the node to be deleted.
                         */

                        tmpNode = *node;
                        (*node)->right->left = (*node)->left;
                        (*parent)->left = (*node)->right;
                        free(tmpNode);
                        *node = (*parent)->left;
                } else {
                        /*
                         * Deleting a node with two children.
                         * First, find the smallest node in
                         * the right subtree.  Replace the
                         * smallest node with the node to be
                         * deleted. Then, do proper connections
                         * for the children of replaced node.
                         */
                        tmpNode = (*node)->right;
                        while (tmpNode->left) {
                                tmpParent = tmpNode;
                                tmpNode = tmpNode->left;
                        }
                        tmpParent->left = tmpNode->right;
                        tmpNode->left = (*node)->left;
                        tmpNode->right =(*node)->right;
                        free(*node);
                        *node = tmpNode;
                }
        } else if (data < (*node)->data) {
                /* traverse towards left subtree */
                deletion(&(*node)->left, node, data);
        } else if (data > (*node)->data) {
                /* traversing towards right subtree */
                deletion(&(*node)->right, node, data);
        }
  }

  /* search the given element in binary search tree */
  void findElement(struct treeNode *node, int data) {
        if (!node)
                return;
        else if (data < node->data) {
                findElement(node->left, data);
        } else if (data > node->data) {
                findElement(node->right, data);
        } else
                printf("data found: %d\n", node->data);
        return;

  }

  void traverse(struct treeNode *node) {
        if (node != NULL) {
                traverse(node->left);
                printf("%3d", node->data);
                traverse(node->right);
        }
        return;
  }

  int main() {
        int data, ch;
        while (1) {
                printf("1. Insertion in Binary Search Tree\n");
                printf("2. Deletion in Binary Search Tree\n");
                printf("3. Search Element in Binary Search Tree\n");
                printf("4. Inorder traversal\n5. Exit\n");
                printf("Enter your choice:");
                scanf("%d", &ch);
                switch (ch) {
                        case 1:
                                while (1) {
                                printf("Enter your data:");
                                scanf("%d", &data);
                                insertion(&root, data);
                                printf("Continue Insertion(0/1):");
                                scanf("%d", &ch);
                                if (!ch)
                                        break;
                                }
                                break;
                        case 2:
                                printf("Enter your data:");
                                scanf("%d", &data);
                                deletion(&root, NULL, data);
                                break;
                        case 3:
                                printf("Enter value for data:");
                                scanf("%d", &data);
                                findElement(root, data);
                                break;
                        case 4:
                                printf("Inorder Traversal:\n");
                                traverse(root);
                                printf("\n");
                                break;
                        case 5:
                                exit(0);
                        default:
                                printf("u've entered wrong option\n");
                                break;
                }
        }
        return 0;

  }

Program of traversing a binary tree in inorder, preorder and postorder in C++ Programming


#include
#include
#include
struct btree
{
    struct btree *left;
    struct btree *right;
    int no;
};
void postorder(struct btree *trav);
void inorder(struct btree *trav);
void preorder(struct btree *trav);
struct btree * create(struct btree *trav);
main()
{
    struct btree *root=NULL;
    char c;
    clrscr();
    while(1)
    {
        root=create(root);
        cout<<"Do you want to continue : ";
        cin>>c;
        if(c=='n' ||c=='N')
            break;
    }
    cout<"Inoder is    : "
;inorder(root); cout<"Preorder is : ";preorder(root); cout<"Postorder is : ";postorder(root); getch(); } struct btree * create(struct btree *trav) { if(trav==NULL) { trav=new btree; trav->right=NULL; trav->left=NULL; cout<<"Enter the no : "; cin>>trav->no; return(trav); } char choice; cout<<"Enter the left or right child : "; cin>>choice; if(choice == 'r' || choice == 'R') { trav->right=create(trav->right); } if(choice=='l' || choice=='L') { trav->left=create(trav->left); } return(trav); } void inorder(struct btree *trav) { if(trav==NULL) return ; inorder(trav->left); cout<<" "<no; inorder(trav->right); } void preorder(struct btree *trav) { if(trav==NULL) return; cout<<" "<no; preorder(trav->left); preorder(trav->right); } void postorder(struct btree *trav) { if(trav==NULL) return; postorder(trav->left); postorder(trav->right); cout<<" "<no; }

Wednesday, May 15, 2013

Implementation of Dijkstra's algorithm(Finding shortest path) using C language



C Program to implement Dijkstra's algorithm. Dijkstra's Algorithm finds the shortest path with the lower cost in a Graph. Dijkstra's Algorithm solves the Single Source Shortest Path problem for a Graph. It is a Greedy algorithm and similar to Prim's algorithm. Read more about C Programming Language .

/***********************************************************
* You can use all the programs on  www.engineercse.blogspot.com
* for personal and learning purposes. For permissions to use the
* programs for commercial purposes,
* contact sm.rumi18@gmail.com
* To find more C programs, do visit www.engineercse.blogspot.com
* and browse!
*
*                       Coding is Poetry !!!
***********************************************************/

#include "stdio.h"
#include "conio.h"
#define infinity 999

void dij(int n,int v,int cost[10][10],int dist[])
{
 int i,u,count,w,flag[10],min;
 for(i=1;i<=n;i++)
  flag[i]=0,dist[i]=cost[v][i];
 count=2;
 while(count<=n)
 {
  min=99;
  for(w=1;w<=n;w++)
   if(dist[w]
    min=dist[w],u=w;
  flag[u]=1;
  count++;
  for(w=1;w<=n;w++)
   if((dist[u]+cost[u][w]
    dist[w]=dist[u]+cost[u][w];
 }
}

void main()
{
 int n,v,i,j,cost[10][10],dist[10];
 clrscr();
 printf("\n Enter the number of nodes:");
 scanf("%d",&n);
 printf("\n Enter the cost matrix:\n");
 for(i=1;i<=n;i++)
  for(j=1;j<=n;j++)
  {
   scanf("%d",&cost[i][j]);
   if(cost[i][j]==0)
    cost[i][j]=infinity;
  }
 printf("\n Enter the source matrix:");
 scanf("%d",&v);
 dij(n,v,cost,dist);
 printf("\n Shortest path:\n");
 for(i=1;i<=n;i++)
  if(i!=v)
   printf("%d->%d,cost=%d\n",v,i,dist[i]);
 getch();
}
Read more Similar C Programs


To get regular updates on new C programs, Algorithm problem solution,