Computer Engineering Made Easy: February 2013

Thursday, 28 February 2013

K-means Clustering Algorithm: Java Code

The Java Code for K-means clustering is given below:

//Aim:To implement Kmeans clustering algorithm.
//Program
import java.util.*;
class k_means
{
static int count1,count2,count3;
static int d[];
static int k[][];
static int tempk[][];
static double m[];
static double diff[];
static int n,p;

static int cal_diff(int a) // This method will determine the cluster in which an element go at a particular step.
{
int temp1=0;
for(int i=0;i<p;++i)
{
if(a>m[i])
diff[i]=a-m[i];
else
diff[i]=m[i]-a;
}
int val=0;
double temp=diff[0];
for(int i=0;i<p;++i)
{
if(diff[i]<temp)
{
temp=diff[i];
val=i;
}
}//end of for loop
return val;
}

static void cal_mean() // This method will determine intermediate mean values
{
for(int i=0;i<p;++i)
m[i]=0; // initializing means to 0
int cnt=0;
for(int i=0;i<p;++i)
{
cnt=0;
for(int j=0;j<n-1;++j)
{
if(k[i][j]!=-1)
{
m[i]+=k[i][j];
++cnt;
}}
m[i]=m[i]/cnt;
}
}

static int check1() // This checks if previous k ie. tempk and current k are same.Used as terminating case.
{
for(int i=0;i<p;++i)
for(int j=0;j<n;++j)
if(tempk[i][j]!=k[i][j])
{
return 0;
}
return 1;
}

public static void main(String args[])
{
Scanner scr=new Scanner(System.in);
/* Accepting number of elements */
System.out.println("Enter the number of elements ");
n=scr.nextInt();
d=new int[n];
/* Accepting elements */
System.out.println("Enter "+n+" elements: ");
for(int i=0;i<n;++i)
d[i]=scr.nextInt();
/* Accepting num of clusters */
System.out.println("Enter the number of clusters: ");
p=scr.nextInt();
/* Initialising arrays */
k=new int[p][n];
tempk=new int[p][n];
m=new double[p];
diff=new double[p];
/* Initializing m */
for(int i=0;i<p;++i)
m[i]=d[i];

int temp=0;
int flag=0;
do
{
for(int i=0;i<p;++i)
for(int j=0;j<n;++j)
{
k[i][j]=-1;
}
for(int i=0;i<n;++i) // for loop will cal cal_diff(int) for every element.
{
temp=cal_diff(d[i]);
if(temp==0)
k[temp][count1++]=d[i];
else
if(temp==1)
k[temp][count2++]=d[i];
else
if(temp==2)
k[temp][count3++]=d[i]; 
}
cal_mean(); // call to method which will calculate mean at this step.
flag=check1(); // check if terminating condition is satisfied.
if(flag!=1)
/*Take backup of k in tempk so that you can check for equivalence in next step*/
for(int i=0;i<p;++i)
for(int j=0;j<n;++j)
tempk[i][j]=k[i][j];

System.out.println("\n\nAt this step");
System.out.println("\nValue of clusters");
for(int i=0;i<p;++i)
{
System.out.print("K"+(i+1)+"{ ");
for(int j=0;k[i][j]!=-1 && j<n-1;++j)
System.out.print(k[i][j]+" ");
System.out.println("}");
}//end of for loop
System.out.println("\nValue of m ");
for(int i=0;i<p;++i)
System.out.print("m"+(i+1)+"="+m[i]+"  ");

count1=0;count2=0;count3=0;
}
while(flag==0);

System.out.println("\n\n\nThe Final Clusters By Kmeans are as follows: ");
for(int i=0;i<p;++i)
{
System.out.print("K"+(i+1)+"{ ");
for(int j=0;k[i][j]!=-1 && j<n-1;++j)
System.out.print(k[i][j]+" ");
System.out.println("}");
}
}
}
/*
OUTPUT
C:\Users\Aditya\Desktop\aditya>javac k_means.java
C:\Users\Aditya\Desktop\aditya>java k_means
Enter the number of elements
8
Enter 8 elements:
2 3 6 8 12 15 18 22
Enter the number of clusters:
3

At this step
Value of clusters
K1{ 2 }
K2{ 3 }
K3{ 6 8 12 15 18 22 }
Value of m
m1=2.0  m2=3.0  m3=13.5

At this step
Value of clusters
K1{ 2 }
K2{ 3 6 8 }
K3{ 12 15 18 22 }
Value of m
m1=2.0  m2=5.666666666666667  m3=16.75

At this step
Value of clusters
K1{ 2 3 }
K2{ 6 8 }
K3{ 12 15 18 22 }
Value of m
m1=2.5  m2=7.0  m3=16.75

At this step
Value of clusters
K1{ 2 3 }
K2{ 6 8 }
K3{ 12 15 18 22 }
Value of m
m1=2.5  m2=7.0  m3=16.75

The Final Clusters By Kmeans are as follows:
K1{ 2 3 }
K2{ 6 8 }
K3{ 12 15 18 22 } */

VIEW OUR SPECIAL PAGE FOR SEM 7 STUDENTS - sem 6 java codes

Friday, 22 February 2013

Internal Forwarding Techniques(Java Code):Store Fetch,Fetch Fetch,Store Store Forwarding

To download the program use the download box

AIM:To study Internal Forwarding Techniques.
//Program:
import java.util.*;
class internal_forward
{
static void menu()
{
System.out.println("Menu:\nRegisters: R1 R2 R3\nMemory locations: M1 M2 M3\nSample instruction:MOV M1,R1\n");
}
static void accept(String s[][])
{
Scanner scr=new Scanner(System.in);
System.out.print("\nEnter the two intructions:");
System.out.print("\nFirst Instruction:\nSource: ");
s[0][1]=scr.nextLine();
System.out.print("\nDestination: ");
s[0][0]=scr.nextLine();
System.out.print("\nSecond instruction:\nSource: ");
s[1][1]=scr.nextLine();
System.out.print("\nDestination: ");
s[1][0]=scr.nextLine();
}
static int check1(String s[][])
{
if(s[0][0].equals(s[1][1]))
{
System.out.println("\nStore Fetch Forwarding can be used");
System.out.println("MOV "+s[0][0]+" "+s[0][1]+"\nMOV "+s[1][0]+" "+s[0][1]);
return 1;
}
return 0;
}
static int check2(String s[][])
{
if(s[0][1].equals(s[1][1]))
{
System.out.println("\nFetch Fetch Forwarding can be used");
System.out.println("MOV "+s[0][0]+" "+s[0][1]+"\nMOV "+s[1][0]+" "+s[0][0]);
return 2;
}
return 0;
}
static int check3(String s[][])
{
if(s[0][0].equals(s[1][0]))
{
System.out.println("\nStore Store Forwarding can be used");
System.out.println("MOV "+s[0][0]+" "+s[1][1]);
return 3;
}
return 0;
}
public static void main(String args[])
{
Scanner scr=new Scanner(System.in);
System.out.println("Three Internal forwarding techniques:\n1.Store Fetch Forwarding\n2.Fetch Fetch Forwarding\n3.Store Store Forwarding\n\n");
String s[][]=new String[2][2];
int choice=1;
int flag=0;
do
{
flag=0;
menu();
accept(s);
System.out.println("Your intructions are as follows:\nMOV "+s[0][0]+" "+s[0][1]+"\nMOV "+s[1][0]+" "+s[1][1]);
flag=check1(s);
if(flag==0)
flag=check2(s);
if(flag==0)
flag=check3(s);
if(flag==0)
System.out.println("Your instructions are OK.No need to apply any of the 3 internal forwarding techniques.");
System.out.println("Do you wish to continue?(1/0)");
choice=scr.nextInt();
}
while(choice==1);
}
}

/*OUTPUT
C:\Users\Aditya\Desktop\aditya>javac internal_forward.java
C:\Users\Aditya\Desktop\aditya>java internal_forward
Three Internal forwarding techniques:
1.Store Fetch Forwarding
2.Fetch Fetch Forwarding
3.Store Store Forwarding

Menu:
Registers: R1 R2 R3
Memory locations: M1 M2 M3
Sample instruction:MOV M1,R1

Enter the two intructions:
First Instruction:
Source: R1
Destination: M1

Second instruction:
Source: M1
Destination: R2

Your intructions are as follows:
MOV M1 R1
MOV R2 M1

Store Fetch Forwarding can be used
MOV M1 R1
MOV R2 R1
Do you wish to continue?(1/0)
1

Menu:
Registers: R1 R2 R3
Memory locations: M1 M2 M3
Sample instruction:MOV M1,R1

Enter the two intructions:
First Instruction:
Source: M2
Destination: R1

Second instruction:
Source: M2
Destination: R2

Your intructions are as follows:
MOV R1 M2
MOV R2 M2

Fetch Fetch Forwarding can be used
MOV R1 M2
MOV R2 R1
Do you wish to continue?(1/0)
1

Menu:
Registers: R1 R2 R3
Memory locations: M1 M2 M3
Sample instruction:MOV M1,R1

Enter the two intructions:
First Instruction:
Source: R1
Destination: M3

Second instruction:
Source: R3
Destination: M3

Your intructions are as follows:
MOV M3 R1
MOV M3 R3

Store Store Forwarding can be used
MOV M3 R3
Do you wish to continue?(1/0)
1

Menu:
Registers: R1 R2 R3
Memory locations: M1 M2 M3
Sample instruction:MOV M1,R1

Enter the two intructions:
First Instruction:
Source: R1
Destination: M2

Second instruction:
Source: M1
Destination: R3

Your intructions are as follows:
MOV M2 R1
MOV R3 M1
Your instructions are OK.No need to apply any of the 3 internal forwarding techniques.
Do you wish to continue?(1/0)
0
*/

VIEW OUR SPECIAL PAGE FOR SEM 7 STUDENTS - sem 6 java codes

Wednesday, 13 February 2013

Decision Tree Algorithm:(Classification Problem Java Code)

Java Program for Decision Tree Algorithm.

import java.util.*;
//Aim: To implement Decision Tree algorithm in java
class tree
{
public double hd;
public double p;
char ch;
String parent;
tree(char c,int x)
{
ch=c;
if(x==1)
parent="outlook";
else if(x==2)
parent="temperature";
else if(x==3)
parent="humidity";
else if(x==4)
parent="windy";
}
} 
class d_tree
{
static char outlook[]={'S','S','O','R','R','R','O','S','S','R','S','O','O','R'};
static char temperature[]={'B','B','B','M','C','C','C','M','C','M','M','M','B','M'};
static char humidity[]={'H','H','H','H','N','N','N','H','N','N','N','H','N','H'};
static char windy[]={'F','T','F','F','F','T','T','F','F','F','T','T','F','T'};
static char class1[]={'N','N','P','P','P','N','P','N','P','P','P','P','P','N'};
static double G1,G2,G3,G4;
static double HD;
static double play=9.0/14.0;
static double nplay=5.0/14.0;
static double temp1,temp2;
static int row=0,column=0;
static char classify[][]=new char[10][10];

static tree cal_hd(tree t,int choice)
{
double count1=0,count2=0;
if(choice==1)
{for(int i=0;i<14;++i)
{if(t.ch==outlook[i] && class1[i]=='P')
++count1;
else
if(t.ch==outlook[i] && class1[i]=='N')
++count2;
}}

if(choice==2)
{for(int i=0;i<14;++i)
{if(t.ch==temperature[i] && class1[i]=='P')
++count1;
else
if(t.ch==temperature[i] && class1[i]=='N')
++count2;
}}

if(choice==3)
{for(int i=0;i<14;++i)
{if(t.ch==humidity[i] && class1[i]=='P')
++count1;
else
if(t.ch==humidity[i] && class1[i]=='N')
++count2;
}}

if(choice==4)
{for(int i=0;i<14;++i)
{if(t.ch==windy[i] && class1[i]=='P')
++count1;
else
if(t.ch==windy[i] && class1[i]=='N')
++count2;
}}

temp1=count1/(count1+count2);
temp2=count2/(count1+count2);
t.p=(count1+count2)/14;

if(temp1==0 || temp2==0)
t.hd=0;
else
t.hd=temp1*(Math.log(1/temp1)/Math.log(10))+temp2*(Math.log(1/temp2)/Math.log(10));

return t;
}

static int check_if_equal(char ca[][],int cnt)
{
int count1=0,count2=0,count3=0;
char c1=ca[0][0],c2=ca[0][1],c3=ca[0][2];

for(int i=0;i<cnt;++i)
{
if(ca[i][0]==c1)
++count1;

if(ca[i][1]==c2)
++count2;

if(ca[i][2]==c3)
++count3;
}

if(count1==cnt)
return 0;
else
if(count2==cnt)
return 1;
else
if(count3==cnt)
return 2;
else
return -1;
}

static void compute(char ch)
{
char ca1[][]=new char[10][10];
char ca2[][]=new char[10][10];
char ca3[][]=new char[10][10];
int cnt1=0;
int cnt2=0;
for(int i=0;i<14;++i)
{
if(outlook[i]==ch)
{
ca1[cnt1][0]=temperature[i];
ca1[cnt1][1]=humidity[i];
ca1[cnt1][2]=windy[i];
ca1[cnt1][3]=class1[i];
++cnt1;
}
}

int check1=0,check2=0;

for(int i=0;i<cnt1;++i)
{
if(ca1[i][3]=='P')
++check1;
else
if(ca1[i][3]=='N')
++check2;
if(check1==cnt1)
{
classify[row][column++]=ch;
classify[row][column++]='P';
System.out.print("--------->PLAY");
return;
}
else
if(check2==cnt1)
{
classify[row][column++]=ch;
classify[row][column++]='N';
System.out.print("--------->NO PLAY");
return;
}
}

//end of for loop

/*System.out.println("The array containing outlook value ch");
for(int i=0;i<9;++i)
{
for(int j=0;j<9;++j)
{
System.out.print(" "+ca1[i][j]);
}
System.out.println();
}
*/



//The array containing outlook value ch and class1=P
cnt1=0;
for(int i=0;i<10;++i)
{
if(ca1[i][3]=='P')
{
ca2[cnt1][0]=ca1[i][0];
ca2[cnt1][1]=ca1[i][1];
ca2[cnt1][2]=ca1[i][2];
ca2[cnt1][3]=ca1[i][3];
++cnt1;
}
}

classify[row][column++]=ch;

int z=check_if_equal(ca2,cnt1);

//System.out.println("The value of Z is "+z);
if(z==0)
{
System.out.print("\n--------->TEMPERATURE("+ca2[0][0]+")--------->PLAY\n");
classify[row][column++]=ca2[0][0];
classify[row][column++]='P';
}
else
if(z==1)
{
System.out.print("\n--------->HUMIDITY("+ca2[0][1]+")--------->PLAY\n");
classify[row][column++]=ca2[0][1];
classify[row][column++]='P';
}
else
if(z==2)
{
System.out.print("\n--------->WINDY("+ca2[0][2]+")--------->PLAY\n");
classify[row][column++]=ca2[0][2];
classify[row][column++]='P';
}

/*
System.out.println("The array containing ch and play");
for(int i=0;i<9;++i)
{
for(int j=0;j<9;++j)
{
System.out.print(" "+ca2[i][j]);
}
System.out.println();
}
*/

//The array containing outlook value ch and class1=N
cnt1=0;
for(int i=0;i<10;++i)
{
if(ca1[i][3]=='N')
{
ca3[cnt1][0]=ca1[i][0];
ca3[cnt1][1]=ca1[i][1];
ca3[cnt1][2]=ca1[i][2];
ca3[cnt1][3]=ca1[i][3];
++cnt1;
}}

++row;
column=0;
classify[row][column++]=ch;
z=check_if_equal(ca3,cnt1);
if(z==0)
{
System.out.print("--------->TEMPERATURE("+ca3[0][0]+")--------->NO PLAY");
classify[row][column++]=ca3[0][0];
classify[row][column++]='N';
}
else
if(z==1)
{
System.out.print("--------->HUMIDITY("+ca3[0][1]+")--------->NO PLAY");
classify[row][column++]=ca3[0][1];
classify[row][column++]='N';
}
else
if(z==2)
{
System.out.print("--------->WINDY("+ca3[0][2]+")--------->NO PLAY");
classify[row][column++]=ca3[0][2];
classify[row][column++]='N';
}

/*System.out.println("The array containing ch and not play");
for(int i=0;i<9;++i)
{
for(int j=0;j<9;++j)
{
System.out.print(" "+ca3[i][j]);
}
System.out.println();
}
*/

}
public static void main(String args[])
{
Scanner scr=new Scanner(System.in);
HD=play*(Math.log(1/play)/Math.log(10))+nplay*(Math.log(1/nplay)/Math.log(10));
System.out.println("\nThe value of H(D) is "+HD);

tree sunny=new tree('S',1);
tree overcast=new tree('O',1);
tree rain=new tree('R',1);
tree hot=new tree('B',2); 
tree mild=new tree('M',2);
tree cool=new tree('C',2);
tree high=new tree('H',3); 
tree normal=new tree('N',3);
tree tru=new tree('T',4);
tree fal=new tree('F',4);

sunny=cal_hd(sunny,1);
overcast=cal_hd(overcast,1);
rain=cal_hd(rain,1);
hot=cal_hd(hot,2);
mild=cal_hd(mild,2);
cool=cal_hd(cool,2);
high=cal_hd(high,3);
normal=cal_hd(normal,3);
tru=cal_hd(tru,4);
fal=cal_hd(fal,4);

G1=HD-(sunny.p*sunny.hd+overcast.p*overcast.hd+rain.p*rain.hd);
G2=HD-(hot.p*hot.hd+mild.p*mild.hd+cool.p*cool.hd);
G3=HD-(high.p*high.hd+normal.p*normal.hd);
G4=HD-(tru.p*tru.hd+fal.p*fal.hd);

int gflag=0;

System.out.println("\nGain(D,Outlook)= "+G1 +"\nGain(D,Temperature)= "+G2+"\nGain(D,Humidity)= "+G3+"\nGain(D,Windy)= "+G4);
System.out.print("\nThe Splitting factor is ");
if(G1>G2 && G1>G3 && G1>G4)
System.out.println("Outlook");
else
if(G2>G1 && G2>G3 && G2>G4)
System.out.println("Temperature");
else
if(G3>G2 && G3>G1 && G3>G4)
System.out.println("Humidity");
else
if(G4>G2 && G4>G3 && G4>G1)
System.out.println("Windy");

System.out.println("\nThe Tree is as follows:-");
System.out.print("\nOUTLOOK(S)");
compute('S');
++row;
column=0;
System.out.print("\n\n\nOUTLOOK(O)");
compute('O');
++row;
column=0;
System.out.print("\n\n\nOUTLOOK(R)");
compute('R');

char input[]=new char[4];
String s; 

System.out.println("\nMenu:\n\nOutlook: Sunny=S Overcast=O Rainy=R\n\nTemperature: Hot=B Medium=M Cool=C\n\nHumidity: High=H Normal=N\n\nWindy: True=T False=F");

System.out.println("\n\nEnter your new tuple to be classified ");
System.out.print("\nOutlook(S/O/R)= ");
s=scr.nextLine();
input[0]=s.charAt(0);
System.out.print("\nTemperature(B/M/C)= ");
s=scr.nextLine();
input[1]=s.charAt(0);
System.out.print("\nHumidity(H/N)= ");
s=scr.nextLine();
input[2]=s.charAt(0);
System.out.print("\nWindy(T/F)= ");
s=scr.nextLine();
input[3]=s.charAt(0);

/* Display classify
for(int i=0;i<9;++i)
{
for(int j=0;j<9;++j)
{
System.out.print(" "+classify[i][j]);
}
System.out.println();
}
*/
System.out.print("Your input is ");
for(int i=0;i<4;++i)
System.out.print(" "+input[i]);
int inc1=0;
do
{
if(input[0]==classify[inc1][0])
{
if(classify[inc1][1]=='P')
   {
    System.out.println("\n\nTuple classified as PLAY");
    break;
   }
else
if(input[1]==classify[inc1][1] || input[2]==classify[inc1][1] || input[3]==classify[inc1][1])
{
   if(classify[inc1][2]=='P')
   {
   System.out.println("\n\nTuple classified as PLAY");
   break;
   }
   else
   if(classify[inc1][2]=='N')
   {
   System.out.println("\n\nTuple classified as NO PLAY");
   break;
   }
}
}
++inc1;
}
while(true);
}
}

/*OUTPUT1

C:\Users\Aditya\Desktop\aditya>java d_tree

The value of H(D) is 0.2830542780615224

Gain(D,Outlook)= 0.07427909717678749
Gain(D,Temperature)= 0.00879686881360553
Gain(D,Humidity)= 0.04570704031674405
Gain(D,Windy)= 0.014487679755121663

The Splitting factor is Outlook

The Tree is as follows:-

OUTLOOK(S)
--------->HUMIDITY(N)--------->PLAY
--------->HUMIDITY(H)--------->NO PLAY


OUTLOOK(O)--------->PLAY


OUTLOOK(R)
--------->WINDY(F)--------->PLAY
--------->WINDY(T)--------->NO PLAY
Menu:

Outlook: Sunny=S Overcast=O Rainy=R

Temperature: Hot=B Medium=M Cool=C

Humidity: High=H Normal=N

Windy: True=T False=F


Enter your new tuple to be classified

Outlook(S/O/R)= S

Temperature(B/M/C)= M

Humidity(H/N)= N

Windy(T/F)= T
Your input is  S M N T

Tuple classified as PLAY

------------------------------------------------------------------------

OUTPUT2

C:\Users\Aditya\Desktop\aditya>java d_tree

The value of H(D) is 0.2830542780615224

Gain(D,Outlook)= 0.07427909717678749
Gain(D,Temperature)= 0.00879686881360553
Gain(D,Humidity)= 0.04570704031674405
Gain(D,Windy)= 0.014487679755121663

The Splitting factor is Outlook

The Tree is as follows:-

OUTLOOK(S)
--------->HUMIDITY(N)--------->PLAY
--------->HUMIDITY(H)--------->NO PLAY


OUTLOOK(O)--------->PLAY


OUTLOOK(R)
--------->WINDY(F)--------->PLAY
--------->WINDY(T)--------->NO PLAY
Menu:

Outlook: Sunny=S Overcast=O Rainy=R

Temperature: Hot=B Medium=M Cool=C

Humidity: High=H Normal=N

Windy: True=T False=F


Enter your new tuple to be classified

Outlook(S/O/R)= S

Temperature(B/M/C)= M

Humidity(H/N)= H

Windy(T/F)= T
Your input is  S M H T

Tuple classified as NO PLAY

*/

VIEW OUR SPECIAL PAGE FOR SEM 7 STUDENTS - sem 6 java codes

Monday, 4 February 2013

Classification problem:Bayesian Classification(Java Code)

Java code for Bayesian Classification is as follows

import java.util.*;
class btheo
{
static char outlook[]={'S','S','O','R','R','R','O','S','S','R','S','O','O','R'};
static char temperature[]={'H','H','H','M','C','C','C','M','C','M','M','M','H','M'};
static char humidity[]={'P','P','P','P','N','N','N','P','N','N','N','P','N','P'};
static char windy[]={'F','T','F','F','F','T','T','F','F','F','T','T','F','T'};
static char class1[]={'N','N','P','P','P','N','P','N','P','P','P','P','P','N'};

static double prob[][]=new double[4][2];

static double pp=9.0/14.0;
static double npp=5.0/14.0;

static int flag=0;
static int flag1=0;

static double play_N=1;
static double notplay_N=1;

static void cal_N(int a)
{
  if(a==1)
  {
    for(int i=0;i<4;++i)
    play_N*=prob[i][0];

    play_N*=pp;
  //System.out.println("\nValue of N of play \n"+play_N);
  }
  else
  {
    for(int i=0;i<4;++i)
    notplay_N*=prob[i][1];

    notplay_N*=npp;
  //System.out.println("\nValue of N of No play \n"+notplay_N);
  }
}

static double cal_play_prob(char ch)
{
double prob=0;
double count=0;

if(flag==0)
{
for(int i=0;i<14;++i)
if(outlook[i]==ch && class1[i]=='P')
++count;

prob=count/9.0;

flag=1;
}
else if(flag==1)
{
for(int i=0;i<14;++i)
if(temperature[i]==ch && class1[i]=='P')
++count;

prob=count/9.0;

flag=2;
}
else if(flag==2)
{
for(int i=0;i<14;++i)
if(humidity[i]==ch && class1[i]=='P')
++count;

prob=count/9.0;

flag=3;
}
else
if(flag==3)
{
for(int i=0;i<14;++i)
if(windy[i]==ch && class1[i]=='P')
++count;

prob=count/9.0;
}
return prob;
}






static double cal_noplay_prob(char ch)
{
double prob=0;
double count=0;

if(flag1==0)
{
for(int i=0;i<14;++i)
if(outlook[i]==ch && class1[i]=='N')
++count;

prob=count/5.0;

flag1=1;
}
else if(flag1==1)
{
for(int i=0;i<14;++i)
if(temperature[i]==ch && class1[i]=='N')
++count;

prob=count/5.0;

flag1=2;
}
else if(flag1==2)
{
for(int i=0;i<14;++i)
if(humidity[i]==ch && class1[i]=='N')
++count;

prob=count/5.0;

flag1=3;
}
else
if(flag1==3)
{
for(int i=0;i<14;++i)
if(windy[i]==ch && class1[i]=='N')
++count;

prob=count/5.0;
}
return prob;
}
public static void main(String args[])
{
Scanner scr=new Scanner(System.in);
System.out.println("Table\n");
System.out.println("Outlook\t   Temperature\t    Humidity\t      Windy     \tClass");
for(int i=0;i<14;++i)
{
System.out.print(outlook[i]+"\t\t"+temperature[i]+"\t\t"+humidity[i]+"\t\t"+windy[i]+"\t\t"+class1[i]);
System.out.println();
}
System.out.println("Menu:\nOutlook: Sunny=S Overcast=O Rain=R\tTemperature: Hot=H Mild=M Cool=C\n");
System.out.println("Humidity: Peak=P Normal=N\t\tWindy: True=T False=F\n\nYour input should belong to one of these classes.\n");
System.out.println("class1: Play=P   class2:Not Play=NP");
System.out.println("\nEnter your input: example. t={rain,hot,peak,false} input will be R,H,P,F");
String s=scr.nextLine();
char ch;
int count=0;
for(int i=0;i<8;i+=2)
{
ch=s.charAt(i);
prob[count][0]=cal_play_prob(ch);
prob[count][1]=cal_noplay_prob(ch);
++count;
}

cal_N(1);
cal_N(2);

double pt=play_N+notplay_N;

double prob_of_play=0;
double prob_of_noplay=0;

prob_of_play=play_N/pt;
prob_of_noplay=notplay_N/pt;

System.out.println("\nProbability of play "+prob_of_play);
System.out.println("\nProbability of NO play "+prob_of_noplay );

if(prob_of_play>prob_of_noplay)
System.out.println("\nThe new tuple classified under \"PLAY\" category.Hence there will be play!!!");
else
System.out.println("\nThe new tuple classified under \"NO PLAY\" category.Hence there will be NO play.");

}
}

/* output

C:\Users\Aditya\Desktop\aditya>javac btheo.java

C:\Users\Aditya\Desktop\aditya>java btheo
Table

Outlook    Temperature      Humidity          Windy             Class
S               H               P               F               N
S               H               P               T               N
O               H               P               F               P
R               M               P               F               P
R               C               N               F               P
R               C               N               T               N
O               C               N               T               P
S               M               P               F               N
S               C               N               F               P
R               M               N               F               P
S               M               N               T               P
O               M               P               T               P
O               H               N               F               P
R               M               P               T               N
Menu:
Outlook: Sunny=S Overcast=O Rain=R      Temperature: Hot=H Mild=M Cool=C

Humidity: Peak=P Normal=N               Windy: True=T False=F

Your input should belong to one of these classes.

class1: Play=P   class2:Not Play=NP

Enter your input: example. t={rain,hot,peak,false} input will be R,H,P,F
R,H,P,F

Probability of play 0.3665689149560117

Probability of NO play 0.6334310850439884

The new tuple classified under "NO PLAY" category.Hence there will be NO play.

*/

VIEW OUR SPECIAL PAGE FOR SEM 7 STUDENTS - sem 6 java codes

Computer Engineering Made Easy

Pages

Thursday, 28 February 2013

K-means Clustering Algorithm: Java Code

Friday, 22 February 2013

Internal Forwarding Techniques(Java Code):Store Fetch,Fetch Fetch,Store Store Forwarding

Wednesday, 13 February 2013

Decision Tree Algorithm:(Classification Problem Java Code)

Monday, 4 February 2013

Classification problem:Bayesian Classification(Java Code)

Popular Posts

Blog Archive