Experiment No. 1 /* Depth First Search Technique*/ #include<iostream.h> #include<conio.

h> #define T 1 #define F 0 class edge {int terminal; struct edge *next;}; class vertex {int visit,vertex_no,path_length; char info; struct edge *edge_ptr; }; void table(int,int matrix[size][size],struct vertex vert[size]); struct edge *insert_vertex(int,struct edge *); void DFS(int,int *dist,vertex vert[size]); void input(int,int a[size][size]); void output(int,int a[size][size]); struct edge * insert_vertex(int vertex_no,struct edge *first) {struct edge *new1,*current; new1=(struct edge *) malloc(sizeof(struct edge)); new1->terminal=vertex_no;new1->next=null;if(!first)return(new1); for(current=first;current->next;current=current->next); current->next=new1;return(first);} void table(int vertex_num,int matrix[size][size],struct vertex vert[size]) {int i,j; for(i=0;i<vertex_num;i++){ vert[i].visit=F; vert[i].vertex_no=i+1; vert[i].info='A'+i; vert[i].path_length=0; vert[i].edge=null;}for(i=0;i<vertex_num;i++)for(j=0;j<vertex_no;j++) if(matrix[i][j]>0)vert[i].edge_ptr=insert_vertex(j,vert[i].edge_ptr);} void DFS(int index,int *dist,struct vertex vert[size]) {struct edge *link; vert[index].visit=t; vert[index].path_length=*dist; *dist+=1; for(link=vert[index].edge_ptr;link;link=link->next) if(vert[link->terminal].visit==f) DFS(link->terminal,dist,vert);} void input(int number,int a[size][size]) { int i,j; cout<<"input the adjency matrix \n"; for(i=0;i<number;i++) { for(j=0;j,number;j++) { cin>>a[i][j]; }}} void output(int number,int a[size][size]) {int i,j; cout<<"\n the adjency matrix \n"; for(i=0;i<number;i++) { for(j=0;j,number;j++) { cout<<a[i][j]; } cout("\n"); }} void main() {int i; int number,index,dist; int a[size][size]; struct vertex vert[size]; struct edge *list; cout<<"\n input the number of vertices in the graph"; cin>>number; input(number,a); output(number,a); table(number,a,vert); cout<<"\n input the starting vertex 0-"<<number-1; cin>>index; dist=0; DFS(index,&dist,vert); cout<<"\n path length of the vertex "<<vert[index].info; cout<<"\n vertex length vertex connectivity \n"; for(i=0;i<number;i++) { cout<<"\n vert[i].info,vert[i].path_length"; for(list=vert[i].edge_ptr;list;list=list->next) { cout<<" "; putchar(list->terminal+'A'); } } }

/*OUTPUT:input the no. of vertices in the graph8 input the adjacency matrix 01100000 00011000 00000100 00000001 00000101 00000010 00100000 00000110 adjacency matrix:01100000 00011000 00000100 00000001 00000101 00000010 00100000 00000110 input the starting 0-7:4 path length of the vertex from e vertex length vertex connectivity A 0 BC B 0 DE C 3 F D 0 H E 0 FH F 1 G G 2 C H 1 FG */

Experiment No. 2 /* Breadth First Search Algorithm*/ #include<iostream.h> class Queue {private: int data; Queue*next; public: void Enque(int); int Deque(); }*head,*tail; void Queue::Enque(int data) { Queue *temp; temp=new Queue; temp->data=data; temp->next=NULL; if(head==NULL) head=temp; else tail->next=temp; tail=temp; } int Queue::Deque() { Queue* temp; temp=head; head=head->next; return temp->data; } int visit[100]; int bfs_span_tree[100][100]; class graph { private: int a; graph*next; public: void bfs(); graph* create(graph*); void ftraverse(graph*); }; graph* graph::create(graph*head) { int a; graph*last; head=last=NULL; graph*temp; cout<<Enter adjecent node ,-1 to stop:\n; cin>>a; while(a!=-1) { temp=new graph; temp->a=a; temp->next=NULL; if(head==NULL) head=temp; else last->next=temp; last=temp; cout<<Enter adjecent node ,-1 to stop:\n; cin>>a; } return head; } void graph::ftraverse(graph*h) { while(h!=NULL) { cout<<h->a<<->; h=h->next; } cout<<NULL\n; } void graph::bfs() { cout<<**********************************************************\n; cout<<This program is to implement bfs for an unweighted graph \n; cout<<**********************************************************\n; graph *ptr[100]; int n; cout<<Enter the no. of nodes in the grph:; cin>>n; for(int i=1;i<=n;i++) { cout<<Enter the adjacent nodes to node no. <<i<<endl; cout<<***************************************\n; ptr[i]=create(ptr[i]); } cout<<\n\nThe Entered Graph is ::\n; for(i=1;i<=n;i++) { cout<<< <<i<< > ::; ftraverse(ptr[i]); } int x; cout<<\nEnter the start node <1,<<n<<>:; cin>>x; cout<<\n\nThe Breadth first search traversal is:\n; Queue object; for(i=1;i<=n;i++) { visit[i]=0; } for(i=1;i<=n;i++) for(int j=1;j<=n;j++) bfs_span_tree[i][j]=0; object.Enque(x); int p; while(head!=NULL&&tail!=NULL) { p=object.Deque(); int x=p; while(ptr[p]!=NULL) { if(visit[ptr[p]->a]!=1)

cout<<node <<ptr[p]->a<< is visited\n; visit[ptr[p]->a]=1; bfs_span_tree[ptr[p]->a][x]=1; } //Enque all its adjacent nodes object.Enque(ptr[p]->a); ptr[p]=ptr[p]->next; } } cout<<\n\nThe required bfs spanning tree is ::\n\n; for(i=1;i<=n;i++) { for(int j=1;j<=n;j++) cout<<bfs_span_tree[i][j]<< ; cout<<endl; } cout<<endl; } int main() { graph obj; obj.bfs(); return 0;
}

Experiment No.3 /*HILL CLIMBING*/ public static ScalesSolution RMHC(ArrayList<Double> weights,int n,int iter) { ScalesSolution sol = new ScalesSolution(n); ScalesSolution oldSol = new ScalesSolution(sol.GetSol()); for(int i = 0; i < iter; i++) { System.out.println("##NEW ITERATION##"); System.out.println("Old Solution : "); oldSol.println(); double f = oldSol.ScalesFitness(weights); System.out.println("Old Fittness: "); System.out.println(f); //the new solution after copying the string from scalesolution sol.SmallChange(); System.out.println("New Solution : "); sol.println(); System.out.println("New Fittness: "); System.out.println(sol.ScalesFitness(weights)); if (oldSol.ScalesFitness(weights) > sol.ScalesFitness(weights)) { oldSol = new ScalesSolution(sol.GetSol()); } } return(oldSol); } My code within the main is as follows :ArrayList<Double> weight = new ArrayList<Double>(); weight.add(1.0); weight.add(2.0); weight.add(3.0); weight.add(4.0); weight.add(10.0); System.out.println(" Final Solution: "+RMHC(weight,5,5).ScalesFitness(weight)); Output:##NEW ITERATION## Old Solution : 01010 Old Fittness: 8.0 New Solution : 00010

New Fittness: 12.0 ##NEW ITERATION## Old Solution : 01010 Old Fittness: 8.0 New Solution : 10010 New Fittness: 10.0 ##NEW ITERATION## Old Solution : 01010 Old Fittness: 8.0 New Solution : 10000 New Fittness: 18.0 ##NEW ITERATION## Old Solution : 01010 Old Fittness: 8.0 New Solution : 10100 New Fittness: 12.0 ##NEW ITERATION## Old Solution : 01010 Old Fittness: 8.0 New Solution : 10101 New Fittness: 8.0 Final Solution: 8.0

Experiment No. 9
/*ERROR BACK ALGORITHM*/ #include "backprop.h" #include <time.h> #include <stdlib.h> CBackProp::CBackProp(int nl,int *sz,double b,double a):beta(b),alpha(a) { numl=nl; lsize=new int[numl]; for(int i=0;i<numl;i++){ lsize[i]=sz[i]; } out = new double*[numl]; for( i=0;i<numl;i++){ out[i]=new double[lsize[i]]; } delta = new double*[numl]; for(i=1;i<numl;i++){ delta[i]=new double[lsize[i]]; } weight = new double**[numl]; for(i=1;i<numl;i++){ weight[i]=new double*[lsize[i]]; } for(i=1;i<numl;i++){ for(int j=0;j<lsize[i];j++){ weight[i][j]=new double[lsize[i-1]+1];}} prevDwt = new double**[numl]; for(i=1;i<numl;i++){prevDwt[i]=new double*[lsize[i]];} for(i=1;i<numl;i++){for(int j=0;j<lsize[i];j++){prevDwt[i][j]=new double[lsize[i-1]+1];} }srand((unsigned)(time(NULL))); for(i=1;i<numl;i++) for(int j=0;j<lsize[i];j++) for(int k=0;k<lsize[i-1]+1;k++) weight[i][j][k]=(double)(rand())/(RAND_MAX/2) - 1;//32767 for(i=1;i<numl;i++) for(int j=0;j<lsize[i];j++) for(int k=0;k<lsize[i-1]+1;k++) prevDwt[i][j][k]=(double)0.0; } CBackProp::~CBackProp() {for(int i=0;i<numl;i++) delete[] out[i]; delete[] out; for(i=1;i<numl;i++) delete[] delta[i]; delete[] delta; for(i=1;i<numl;i++) for(int j=0;j<lsize[i];j++) delete[] weight[i][j]; for(i=1;i<numl;i++) delete[] weight[i]; delete[] weight; for(i=1;i<numl;i++) for(int j=0;j<lsize[i];j++) delete[] prevDwt[i][j]; for(i=1;i<numl;i++) delete[] prevDwt[i]; delete[] prevDwt; delete[] lsize; } double CBackProp::sigmoid(double in) { return (double)(1/(1+exp(-in))); } double CBackProp::mse(double *tgt) const { double mse=0; for(int i=0;i<lsize[numl-1];i++){ mse+=(tgt[i]-out[numl-1][i])*(tgt[i]-out[numl1][i]); } return mse/2; } double CBackProp::Out(int i) const { return out[numl-1][i]; } void CBackProp::ffwd(double *in) { double sum; for(int i=0;i<lsize[0];i++) out[0][i]=in[i]; for(i=1;i<numl;i++){ for(int j=0;j<lsize[i];j++){ sum=0.0; for(int k=0;k<lsize[i1];k++){ sum+= out[i-1][k]*weight[i][j][k]; } sum+=weight[i][j][lsize[i-1]]; out[i][j]=sigmoid(sum); }}} void CBackProp::bpgt(double *in,double *tgt) { double sum; // update output values for each neuron ffwd(in);

// find delta for output layer for(int i=0;i<lsize[numl-1];i++){ delta[numl-1][i]=out[numl-1][i]* (1-out[numl-1][i])*(tgt[i]-out[numl-1][i]); } // find delta for hidden layers for(i=numl-2;i>0;i--){ for(int j=0;j<lsize[i];j++){ sum=0.0; for(int k=0;k<lsize[i+1];k++){ sum+=delta[i+1][k]*weight[i+1][k][j]; } delta[i][j]=out[i][j]*(1-out[i][j])*sum; } } // apply momentum ( does nothing if alpha=0 ) for(i=1;i<numl;i++){ for(int j=0;j<lsize[i];j++){ for(int k=0;k<lsize[i-1];k++){ weight[i][j][k]+=alpha*prevDwt[i][j][k]; } weight[i][j][lsize[i-1]]+=alpha*prevDwt[i][j][lsize[i-1]]; } } // adjust weights usng steepest descent for(i=1;i<numl;i++){ for(int j=0;j<lsize[i];j++){ for(int k=0;k<lsize[i-1];k++){ prevDwt[i][j][k]=beta*delta[i][j]*out[i-1][k]; weight[i][j][k]+=prevDwt[i][j][k]; } prevDwt[i][j][lsize[i-1]]=beta*delta[i][j]; weight[i][j][lsize[i-1]]+=prevDwt[i][j][lsize[i-1]]; } } }

Experiment No. 7

/* Perception for AND */ Program to implement perceptron learning rule #include <iostream> #include <cstdlib> #include <ctime> #include <cmath> using namespace std; int main() { float w [3]; float t, o; const double eta = .1; int i; int count = 0; bool correct = 0; int train [4] [3] = { 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1 }; int x0, x1, x2; float weightsum, deltaw1, deltaw2; srand((unsigned)(time(0))); rand(); //initialize threshold x0 = -1; w[0] = fabs((float)(rand())/(32767/2)-1); for ( i = 1; i < 3; ++i) w[i] = (float)(rand())/(32767/2) - 1; cout << "INITIAL WEIGHTS" << endl << "---------------" << endl; cout << "w0 = " << w[0] << endl; cout << "w1 = " << w[1] << endl; cout << "w2 = " << w[2] << endl; while(!correct) { correct = 1; count++; for (i = 0; i < 4; ++i) { x1 = train[i][0]; //input for x1 x2 = train[i][1]; //input for x2 //find weighted sum of inputs and threshold values

weightsum = x0 * w[0] + x1 * w[1] + x2 * w[2]; if (weightsum > 0) o = 1; else o = 0; if (o != t) { deltaw1 = eta * (t - o) * x1;w[1] = w[1] + deltaw1; deltaw2 = eta * (t - o) * x2;w[2] = w[2] + deltaw2; correct = 0; }}} //OUTPUT cout << endl << endl; cout << "FINAL WEIGHTS" << endl << "-------------" << endl; cout << "w0 = " << w[0] << endl;cout << "w1 = " << w[1] << endl; cout << "w2 = " << w[2] << endl; cout << "The delta rules were invoked " << count << " times"<<endl; return 0; }

Experiment no. 4 /* Steepest Accent Hill Climbing*/ // Algorithm implemented in the Ruby Programming Language def onemax(vector) return vector.inject(0.0){|sum, v| sum + ((v=="1") ? 1 : 0)} end def random_bitstring(num_bits) return Array.new(num_bits){|i| (rand<0.5) ? "1" : "0"} end def random_neighbor(bitstring) mutant = Array.new(bitstring) pos = rand(bitstring.size) mutant[pos] = (mutant[pos]=='1') ? '0' : '1' return mutant end def search(max_iterations, num_bits) candidate = {} candidate[:vector] = random_bitstring(num_bits) candidate[:cost] = onemax(candidate[:vector]) max_iterations.times do |iter| neighbor = {} neighbor[:vector] = random_neighbor(candidate[:vector]) neighbor[:cost] = onemax(neighbor[:vector]) candidate = neighbor if neighbor[:cost] >= candidate[:cost] puts " > iteration #{(iter+1)}, best=#{candidate[:cost]}" break if candidate[:cost] == num_bits end return candidate end if __FILE__ == $0 # problem configuration num_bits = 64 # algorithm configuration max_iterations = 1000 # execute the algorithm best = search(max_iterations, num_bits) puts "Done. Best Solution: c=#{best[:cost]}, v=#{best[:vector].join}" end

Experiment No. 6 /* A* Algorithm */

function A*(start,goal) closedset := the empty set // The set of nodes already evaluated. openset := set containing the initial node // The set of tentative nodes to be evaluated. came_from := the empty map // The map of navigated nodes. g_score[start] := 0 // Cost from start along best known path. h_score[start] := heuristic_cost_estimate(start, goal) f_score[start] := h_score[start] // Estimated total cost from start to goal through y. while openset is not empty x := the node in openset having the lowest f_score[] value if x = goal return reconstruct_path(came_from, came_from[goal]) remove x from openset add x to closedset foreach y in neighbor_nodes(x) if y in closedset continue tentative_g_score := g_score[x] + dist_between(x,y) if y not in openset add y to openset tentative_is_better := true else if tentative_g_score < g_score[y] tentative_is_better := true else tentative_is_better := false if tentative_is_better = true came_from[y] := x g_score[y] := tentative_g_score h_score[y] := heuristic_cost_estimate(y, goal) f_score[y] := g_score[y] + h_score[y] return failure function reconstruct_path(came_from, current_node) if came_from[current_node] is set p = reconstruct_path(came_from, came_from[current_node]) return (p + current_node) else return current_node

Experiment No. 5 /* Best First Search Algorithm */

#include<stdio.h> #include<stdlib.h> void main() { int graph[15][15],s[15],pathestimate[15],mark[15]; int num_of_vertices,source,i,j,u,predecessor[15]; int count=0; int minimum(int a[],int m[],int k); void printpath(int,int,int[]); printf("\nenter the no.of vertices\n"); scanf("%d",&num_of_vertices); if(num_of_vertices<=0) { printf("\nthis is meaningless\n"); exit(1); } printf("\nenter the adjacent matrix\n"); for(i=1;i<=num_of_vertices;i++) { printf("\nenter the elements of row %d\n",i); for(j=1;j<=num_of_vertices;j++) { scanf("%d",&graph[i][j]); } } printf("\nenter the source vertex\n"); scanf("%d",&source); for(j=1;j<=num_of_vertices;j++) { mark[j]=0; pathestimate[j]=999; predecessor[j]=0; } pathestimate=0; while(count<num_of_vertices) { u=minimum(pathestimate,mark,num_of_vertices); s[++count]=u; mark[u]=1; for(i=1;i<=num_of_vertices;i++) { if(graph[u][i]>0) { if(mark[i]!=1) {

if(pathestimate[i]>pathestimate[u]+graph[u][i]) { pathestimate[i]=pathestimate[u]+graph[u][i]; predecessor[i]=u; } } } }} for(i=1;i<=num_of_vertices;i++) { printpath(source,i,predecessor); if(pathestimate[i]!=999) printf("->(%d)\n",pathestimate[i]); } } int minimum(int a[],int m[],int k) { int mi=999; int i,t; for(i=1;i<=k;i++) { if(m[i]!=1) { if(mi>=a[i]) { mi=a[i]; t=i; } }} return t; } void printpath(int x,int i,int p[]) { printf("\n"); if(i==x) { printf("%d",x); } else if(p[i]==0) printf("no path from %d to %d",x,i); else { printpath(x,p[i],p); printf("..%d",i); } }