EXPERIMENT-8

AIM:

Write a program to implement Class Point Method for effort estimation.
THEORY:
Object Points:
•
Function Related Metric for fourth Generation Languages
• Computation is Simpler as compared to FP



ALGORITHM:
• Object Point Computation is similar to Function Point computation.
• Compute the number of Screens and classify them as Simple,
medium and complex.
• Compute the number of reports and classify them as Simple,
medium and complex.
• Count the number of modules that have to be developed.
• Use weighted Matrices to sum the values above, taking into
account the reused code.

PROGRAM:


#include <bits/stdc++.h>
#include <windows.h>
using namespace std;

struct cl
{
int det,ret;

};

struct method
{
int det,ftr;
};

float findObjectPoint(cl external_classes[],cl internal_classes[],method

ms[],string comp_af,int nic,int nec,int nm)
{
float op,uop,af;

int ic=0,ec=0,s=0;
for(int k=0;k<nic;k++)
{
if(internal_classes[k].det>=1 && internal_classes[k].det<=19)
{
if(internal_classes[k].ret>=0 && internal_classes[k].ret<=1)
ic+=7;
else if(internal_classes[k].ret>=2 && internal_classes[k].ret<=5)
ic+=7;
 else
ic+=10;
}
else if(internal_classes[k].det>=20 && internal_classes[k].det<=50)
{
if(internal_classes[k].ret>=0 && internal_classes[k].ret<=1)
ic+=7;
else if(internal_classes[k].ret>=2 && internal_classes[k].ret<=5)
ic+=10;
else
ic+=15;
}
else
{
if(internal_classes[k].ret>=0 && internal_classes[k].ret<=1)
ic+=10;
else if(internal_classes[k].ret>=2 && internal_classes[k].ret<=5)
ic+=15;
else
ic+=15;

}
}

for(int k=0;k<nec;k++)
{
if(external_classes[k].det>=1 && external_classes[k].det<=19)
{
if(external_classes[k].ret>=0 && external_classes[k].ret<=1)
ec+=5;
else if(external_classes[k].ret>=2 && external_classes[k].ret<=5)
ec+=5;
else
ec+=7;
}
else if(external_classes[k].det>=20 && external_classes[k].det<=50)
{
if(external_classes[k].ret>=0 && external_classes[k].ret<=1)
ec+=5;
else if(external_classes[k].ret>=2 && external_classes[k].ret<=5)
ec+=7;
else
 ec+=10;
}
else
{
if(external_classes[k].ret>=0 && external_classes[k].ret<=1)
ec+=7;
else if(external_classes[k].ret>=2 && external_classes[k].ret<=5)
ec+=10;
else
ec+=10;

}
}

for(int k=0;k<nm;k++)
{
if(ms[k].det>=1 && ms[k].det<=4)
{
if(ms[k].ftr>=0 && ms[k].ftr<=1)
s+=3;
else if(ms[k].ftr==2)
s+=3;
else
s+=4;
}
else if(ms[k].det>=5 && ms[k].det<=15)
{
if(ms[k].ftr>=0 && ms[k].ftr<=1)
s+=3;
else if(ms[k].ftr==2)
s+=4;
else
s+=6;
}
else
{
if(ms[k].ftr>=0 && ms[k].ftr<=1)
s+=4;
else if(ms[k].ftr==2)
s+=6;
else
s+=6;
 }
}
uop = ic+ec+s;
int a;
transform(comp_af.begin(), comp_af.end(), comp_af.begin(), ::tolower);
if(comp_af.compare("no influence")==0)
a=0;
else if(comp_af.compare("incidental")==0)
a=1;
else if(comp_af.compare("moderate")==0)
a=2;
else if(comp_af.compare("average")==0)
a=3;
else if(comp_af.compare("significant")==0)
a=4;
else if(comp_af.compare("essential")==0)
a=5;

af = 0.65 + (0.01*(14*a));
op = uop*af;

return op;

int main()
{
system("color f0");
int nic,nec,nm;

cout<<" Enter number of internal classes : ";

cin>>nic;
cl internal_classes[nic];
for(int i=0;i<nic;i++)
{
cout<<" For Class "<<i+1<<" : "<<endl;
cout<<" Enter DET : ";
cin>>internal_classes[i].det;
cout<<" Enter RET : ";
cin>>internal_classes[i].ret;
}
 cout<<" Enter number of external classes : ";
cin>>nec;
cl external_classes[nec];
for(int i=0;i<nec;i++)
{
cout<<" For Class "<<i+1<<" : "<<endl;
cout<<" Enter DET : ";
cin>>external_classes[i].det;
cout<<" Enter RET : ";
cin>>external_classes[i].ret;
}

cout<<" Enter number of methods : ";

cin>>nm;
method ms[nm];
for(int i=0;i<nm;i++)
{
cout<<" For Method "<<i+1<<" : "<<endl;
cout<<" Enter DET : ";
cin>>ms[i].det;
cout<<" Enter FTR : ";
cin>>ms[i].ftr;
}

string comp_af;
cout<<" Enter complexity of adjustment factors : ";
cin>>comp_af;
cout<<endl;

float op =
findObjectPoint(external_classes,internal_classes,ms,comp_af,nic,nec,nm);
cout<<" The object point is : "<<op<<endl;

return 0;
}
OUTPUT:

RESULT:
The experiment helped us in successfully implementing object point analysis
method.

FINDING AND LEARNING:

• Multiple packets can be transmitted without waiting for
acknowledgement
• Piggybacking
• No limit of the size or sequence number required in this protocol
• The bandwidth may be wasted in some special situations