Cocomo

LOC, COCOMO I & COCOMO II
Subject: Software Engineering Presented By:

Coordinator: Kamal Kishore (2012ca34)
Mr Anoj Kumar
Jyoti Shrivastava (2012ca52)
Kalyan Mondal (2012ca49)
Jyotsna Agnihotri (2012ca66)
Karishma Gupta(2012ca55)
Contents
Software Planning
LOC: Lines of Code
Function Point
Cost Estimation
Development Mode
COCOMO I
Basic COCOMO
Intermediate COCOMO
Detailed COCOMO
COCOMO II
Application Composition
Early Design Model
Post Architecture Model
References
SOFTWARE PLANNING
Software planning begins before technical work starts, continues as the software
Evolves from concept to reality, and culminates only when the software is retired.
Fig:- Activities during software project planning

Created by:- Kamal kishore(2012ca34) Ref :-software engineering by K.K.Agrawal, yogesh singh
LINES OF CODE(LOC)
A Line of code is any line of program text that is not a comment or

blank line, regardless of the number of statements or fragments on the
line. This specifically includes all lines containing program header,
declarations, and executable and non-executable statements.
While line of codes have their uses, their usefulness is limited for other
tasks like functionality, complexity, efficiency, etc.
FUNCTION POINT
Function point measures functionality which is a solution to the size
measurement problem.
It is decomposed into following functional units
Internal External
Inputs Outputs Enquiries Logical Interface
Files Files
FUNCTIONAL UNITS WITH WEIGHTING FACTORS
Functional units Low Average High
External Inputs 3 4 6
External Outputs 4 5 7
External Inquiries 3 4 5
Internal logical files (ILF) 7 10 15
External interface files (EIF) 5 7 10
The procedure for the calculation of UFP in mathematical form is given

below
5 3
UFP = WijUFP : Unadjusted Function Point i=1
j=1
Where i indicates the row and j indicates the column of table.
Wij : It is the entry of ith row and jth column of the table.
Zij: It is the count of the number of functional unit of type i that have been classified
as having the complexity corresponding to column j
An example
Consider a project with the following functional units: 50 user inputs,40 user
outputs, 35 user enquiries,6 user files,4 external interfaces.
Assume all complexity adjustment factors and weighting factors are average.
Compute the function points for the project. Suppose that program needs 70
LOC per FP. Find out the size of complete project.
Solution:
5 3
UFP = Wij
i=1 j=1
UFP= 50 * 4 + 40 * 5 + 35 * 4 + 6 * 10 + 4 * 7
= 200+200+140+60+28 = 628
CAF= (0.65 + )
=(0.65 + 0.01 (14 * 3 )) = 1.07
FP= UFP * CAF
=628 * 1.07 = 672
Size = FP * (LOC per FP) = 672 * 70 = 47040 LOC
Created by:- Kamal kishore(2012ca34) Ref :-software engineering by K.K.Agrawal, Yogesh Singh
Cost Estimation
Approximate judgement of the costs for a project. It
should be done throughout the entire life cycle.
Why we need?
To determine how much effort and time a software
project requires.
Important for making good management decisions.
It facilitates competitive contract bids.
It affect the planning and budgeting of a project.
Ref: Software Engineering By K.K.Aggarwal & Y. Singh Created by: Jyoti Shrivastava
Development Mode of S/W Projects
Mode Project Nature of Project Innovation Deadline
Size
Organic Typically Small size project, Little Not Tight

2-50 KLOC Experienced
developers.
Semi Typically Medium size project Medium Medium

Detached 50- and team.
300KLOC
Embedded Typically Large project, Real- Significant Tight

over time systems
300KLOC
Constructive Cost Model(COCOMO )
The COCOMO model is a single variable software
cost estimation model developed by Barry Boehm in
1981.
The model uses a basic regression formula, with
parameters that are derived from historical project data
and current project characteristics.
Hierarchy of Cocomo Model
1. Basic COCOMO model
2. Intermediate COCOMO model
3. Detailed COCOMO model
Basic COCOMO Model
It take the form:
Effort(E) = ab * (KLOC)bb(in Person-months)
DevelopmentTime(D) = cb * (E) db (in month)
Average staff size(SS) = E/D (in Person)
Productivity(P) = KLOC / E (in KLOC/Person-month)

Project ab bb cb db
Organic 2.4 1.05 2.5 0.38
Semidetached 3.0 1.12 2.5 0.35
Embedded 3.6 1.20 2.5 0.32
Person-Months
What is Person-Months ?
The area under the curve
Ref: Fundamentals of Software Engineering By Rajib Mall Created by: Jyoti Shrivastava
Basic cocomo: Example
A project size of 200KLOC is to be developed.S/W
development team has average experience on similar type
of projects.The project schedule is not very
tight.Calculate the effort and development time of the
project.
Ans: 200 KLOC implies semi-detached mode.
Hence, E= 3.0 * (200)1.12 = 1133.12 PM
D=2.5 * (1133.12)0.35 = 29.3 M
Avg. staff size(SS) = E/D
= 1133.12/29.3=38.67 Persons.
Productivity (P) = KLOC/E
= 200/1133.12=0.1765 KLOC/PM.
Intermediate COCOMO
Extension of Basic COCOMO
Why Use ?
Basic model lacks accuracy
Computes software development effort as a function of program
size and set of 15 Cost Drivers
Cost Driver: A multiplicative factor that determines the effort
required to complete the software project.
Why Cost Drivers?
Adjust the nominal cost of a project to the actual project
Environment.
For each Characteristics, Estimator decides the scale factor
Very Very Extra

Low Nominal High
Low High High
Ref: Software Engineering By K.K.Aggarwal & Y. Singh Created by: Kalyan Mondal
Cost Drivers
Product Required Software Reliability (RELY)

Database Size (DATA)
Attributes Product Complexity (CPLX)
Execution Time Constraint (TIME)

Computer Main Storage constraint (STOR)
Attributes

Virtual Machine volatility (VIRT)
Computer turnaround time (TURN)
Analyst Capability (ACAP)

Personnel

Application Experience (AEXP)
Programmer Capability (PCAP)
Attributes Virtual Machine Experience (VEXP)
Programming language Experience (LEXP)
Project Modern programming practices (MODP)

Use of Software tools (TOOL)
Attributes Required development schedule (SCED)
The Calculation
Multiply all 15 Cost Drivers to get Effort Adjustment
Factor(EAF)
E(Effort) = ab(KLOC)bb * EAF(in Person-Month)
D(Development Time) = cb(E)db (in month)
SS (Avg Staff Size) = E/D (in persons)
P (Productivity) = KLOC/E (in KLOC/Person-month)
Project ab bb cb db
Organic 3.2 1.05 2.5 0.38
Semidetached 3.0 1.12 2.5 0.35
Embedded 2.8 1.20 2.5 0.32
Intermediate COCOMO : Example
A new project with estimated 400 KLOC embedded system has to be

developed. Project manager hires developers of low quality but a lot of
experience in programming language. Calculate the Effort, Development
time, Staff size & Productivity.
Cost Very Low Nominal High Very Extra High
Drivers Low High
AEXP 1.29 1.13 1.00 0.91 0.82 --
LEXP 1.14 1.07 1.00 0.95 -- --
EAF = 1.29 * 0.95 = 1.22

400 LOC implies Embedded System
Effort = 2.8*(400)1.20 * 1.225 = 3712 * 1.22 = 4528 person-months
Development Time = 2.5 * (4528)0.32 = 2.5 * 14.78 = 36.9 months
Avg. Staff Size = E/D = 4528/36.9 = 122 persons
Productivity = KLOC/Effort = 400/4528 = 0.0884 KLOC/person-month
Detailed COCOMO
Detailed COCOMO = Intermediate COCOMO +
assessment of Cost Drivers impact on each phase.
Phases
1) Plans and requirements
2) System Design
3) Detailed Design
4) Module code and test
5) Integrate and test
Cost of each subsystem is estimated separately. This
reduces the margin of error.
The Calculation
Multiply all 15 Cost Drivers to get Effort Adjustment
Factor(EAF)
E(Effort) = ab(KLOC)bb * EAF(in Person-Month)
D(Development Time) = cb(E)db (in month)
Ep (Total Effort) = p * E (in Person-Month)

Dp (Total Development Time) = p * D (in month)
Detailed COCOMO : Example
Consider a project to develop a full screen editor. The major components
identified and their sizes are (i) Screen Edit 4K (ii) Command Lang
Interpreter 2K (iii) File Input and Output 1K (iv) Cursor movement
2K (v) Screen Movement 3K. Assume the Required software reliability
is high, product complexity is high, analyst capability is high &
programming language experience is low. Use COCOMO model to
estimate cost and time for different phases.
Size of modules : 4 + 2 + 1 + 2 + 3 = 13 KLOC [Organic]
Cost Very Low Nominal High Very Extra High
Drivers Low High
RELY 0.75 0.88 1.00 1.15 1.40 --
CPLX 0.70 0.85 1.00 1.15 1.30 1.65
ACAP 1.46 1.19 1.00 0.86 0.71
LEXP 1.14 1.07 1.00 0.95 -- --
EAF = 1.15 * 1.15 * 0.86 * 1.07 = 1.2169
Example (Contd.)
Initial Effort (E) = ab(KLOC)bb * EAF = 3.2*(12)1.05 * 1.2169
= 52.9 person-months
Initial Development Time = cb(E)db =2.5*(52.9)0.38 = 11.29 months
Phase value of p and p
Plan & System Detail Module Integration
Reqr Design Design code & test & Test
Organic Small p 0.06 0.16 0.26 0.42 0.16
Organic Small p 0.10 0.19 0.24 0.39 0.18
Phase wise effort & development time distribution
E D Ep (in person-months) Dp (in months)
Plan & Requirement 52.9 11.29 0.06*52.9 = 3.17 0.10*11.29=1.12
System Design 52.9 11.29 0.16*52.9=8.46 0.19*11.29=2.14
Detail Design 52.9 11.29 0.26*52.9=13.74 0.24*11.29=2.70
Module code & test 52.9 11.29 0.42*52.9=22.21 0.39*11.29=4.40
Integration & test 52.9 11.29 0.16*52.9=8.46 0.18*11.29=2.03
WHY COCOMO-II ?
The changes in s/w development techniques included a move
away from mainframe overnight batch processing to desktop-
based real-time turnaround.
These changes and others began to make applying the
original COCOMO model problematic.
The model is tuned to the life cycle practices of the 21st
century.
Ref: Software Engineering By K.K.Aggarwal & Y. Singh and csse website by : Jyotsna Agnihotri
Categories Identified By Cocomo II
End User Programming
Infrastructure Sector
Intermediate Sectors
1. Application Generators And Composition Aids
2. Application Composition Sector
3. System Integration
Stages Of Cocomo-II
Earlier Design
Post Architecture
Ref: Software Engineering By K.K.Aggarwal & Y. Singh by : Jyotsna Agnihotri

Assess Object
Counts
Classification Of
Complexity Levels
Assign Complexity
Weight To Each Object
Determine Object
Points
Compute New
Object Points
Calculation Of
Productivity Rate
Compute The Effort

In Person Months.
Assess object counts: Estimate the number of screens,
reports and 3 GL components that will comprise this application.
Classification of complexity levels:
We have to classify each object instance (depending on
values of its characteristics) into :-
o simple
o medium
o Difficult
Assign complexity weight to each object : The
weights are used for three object types :-
o screen
o report
o 3GL components

Determine object points: Add all the weighted object
instances to get one number and this known as object-point count.
Compute new object points: We have to estimate the
percentage of reuse to be achieved in a project. Depending on the
percentage reuse, the new object points (NOP) are computed.
Object Points * (100 - %reuse)

NOP = ---------------------------------------------
100
NOP are the object points that will need to be developed and differ
from the object point count because there may be reuse( percentage of
the Product development which is accomplished by exploiting the
existence of existing component's design-or-development effort).
Ref: Software Engineering By K.K.Aggarwal & Y. Singh&gilb.com by : Jyotsna Agnihotri

Calculation of productivity rate: The productivity
rate can be calculated as:
Productivity rate (PROD) = NOP/Person month
Compute the effort in Persons-Months: When

PROD is known, we may estimate effort in Person-
Months as:
NOP
Effort in PM = ------------
PROD

Example
Example: Consider a database application project with the
following characteristics:
The application has 4 screens with 4 views each and 7 data
tables for 3 servers and 4 clients.
The application may generate two report of 6 sections each
from 07 data tables for two server and 3 clients. There is
10% reuse of object points.
The developers experience and capability in the similar
environment is low. The maturity of organization in terms of
capability is also low. Calculate the object point count, New
object points and effort to develop such a project.

Solution :
Lets have a look on the tables for screens, for reports , for complexity
weights for each level
No. Of Views Total<4 Total<8 Total 8+
Contained in a (<2 servers (2-3 servers (>3 servers
screen <3 clients) 3-5 clients) >5 clients)
<3 Simple Simple Medium
3-7 Simple Medium Difficult
>8 Medium Difficult Difficult
No. Of Total<4 Total<8 Total 8+

Sections (<2 servers (2-3 servers (>3 servers
Contained in a <3 clients) 3-5 clients) >5 clients)
report
0 or 1 Simple Simple Medium
2 or 3 Simple Medium Difficult
4+ Medium Difficult Difficult
Object Type Simple Medium Difficult
Complexity Complexity Complexity
Screen 1 2 3
Report 2 5 8
3GL - - 10
This project comes under the category of application composition estimation

model.
Number of screens = 4 with 4 views each
Number of reports = 2 with 6 sections each
From Table we know that each screen will be of medium complexity and each
report will be difficult complexity.
Using Table of complexity weights, we may calculate object point count
= 4 x 2 + 2 x 8 = 24

Developers Experience PROD (NOP/PM)
And Capability
Very low 4
Low 7
Nominal 13
High 25
Very high 50
Using the formula NOP is calculated as:

NOP= 24 * (100-10)/100=21.6
Low value of productivity is given in above Productivity table = 7
Efforts in PM=NOP/PROD=21.6/7=3.086 PM

Early Design Model
Used in the early stages of a software project when very little
may be known about:
the size of the product to be developed,
the nature of the target platform,
the nature of the personnel to be involved in the project.
Uses Unadjusted Function Points (UFP) as the measure of size.
Based on a standard formula for COCOMO-II models:
Where
PMnominal = Effort of the project in person months
A = Constant representing the nominal productivity,
provisionally set to 2.5
B = Scale factor
Size = Software size
Created by- Karishma Gupta (2012CA55) Ref: Software Engineering By K.K. Aggarwal & Yogesh Singh
32
The Scaling Factors that COCOMO-II model uses for the
calculation of B are:
Precedentness (PREC)
Development flexibility (FLEX)
Architecture/ Risk Resolution (RESL)
Team Cohesion (TEAM)
Process maturity (PMAT)
Early design cost drivers

There are 7 early design cost drivers and are given below:
1. Product Reliability and Complexity (RCPX)

2. Required Reuse (RUSE)
3. Platform Difficulty (PDIF)
4. Personnel Capability (PERS)
5. Personnel Experience (PREX)
6. Facilities (FCIL)
7. Schedule (SCED)
33
Data for the Computation of B (Scalar Factor)
Scaling Factors Very Low Nominal High Very High Extra High
Low
Precedentness 6.20 4.96 3.72 2.48 1.24 0.00
Development 5.07 4.05 3.04 2.03 2.03 0.00
Flexibility
Architecture/ 7.07 5.65 4.24 2.83 1.41 0.00

Risk Resolution
Team Cohesion 5.48 4.38 3.29 2.19 1.10 0.00

Process 7.80 6.24 4.68 3.12 1.56 0.00
Maturity
Calculate the scalar factor B
If B=1.0, then Linear relationship b/w Effort & Size.
If B 1.0, then Non-Linear relationship b/w Effort & Size.
If B<1.0, then the rate of increase of effort decreases as the size of
the product increases.
If B>1.0, then the rate of increase of effort increases as the size of
the product increases.
B = 0.91 + 0.01 * (Sum of rating on scaling factors for the project)
When all the scaling factors of a project are rated as extra high,
then the best value of B= 0.91 (for COCOMO II.2000)
when all the scaling factors of a project are rated as very low,
Then the worst value of B= 1.23 (for COCOMO II.2000)
Hence, the value of B may vary from 0.91 to 1.23
Early Design Model: Example
Question: A software project of application generator category with estimated 50
KLOC has to be developed. The scale factor (B) has low precedentness, high
development flexibility and low team cohesion.
Other factors are nominal. The early design cost drivers like platform
difficult (PDIF) and Personnel Capability (PERS) are high and others are
nominal.
Calculate the Effort in person-months for the development of the project.
Early Design Extra Very Low Nominal High Very Extra

Cost Drivers Low Low High High
RCPX 0.73 0.81 0.98 1.0 1.30 1.74 2.38
RUSE - - 0.95 1.0 1.07 1.15 1.24
PDIF - - 0.87 1.0 1.29 1.81 2.61
PERS 2.12 1.62 1.26 1.0 0.83 0.63 0.50
PREX 1.59 1.33 1.12 1.0 0.87 0.71 0.62
FCIL 1.43 1.30 1.10 1.0 0.87 0.73 0.62
SCED - 1.43 1.14 1.0 1.0 1.0 -
36
Solution :
B = 0.91 + 0.01 * (Sum of rating on scaling factors for the project)
= 0.91 + 0.01 * (4.96 + 2.03 + 4.24 + 4.38 + 4.68)
= 0.91 + 0.01(20.29)=1.1129
= 2.5 * (50)1.1129 = 194.41 Person-months

here A=2.5 (for COCOMO II.2000) predefined
The 7 cost drivers are:
PDIF = high (1.29) PERS = high (0.83)

RCPX = nominal (1.0) RUSE = nominal (1.0)
PREX = nominal (1.0) FCIL = nominal (1.0)
SCEO = nominal (1.0)
= 194.41 * [1.29 x 0.83]

= 194.41 x 1.07
= 208.155 Person months
37
Post Architecture Model
Most detailed estimation model.
Used when a software life cycle architecture has been completed.
Used in the development and maintenance of software products
in the application generators, system integration or infrastructure
sectors.
Lines of Codes Counting Rules
Function Points
Cost Drivers
Where
EM : Effort multiplier which is the product of 17 cost drivers.
PMnominal = Effort of the project in person months.
38
Cost Drivers of Post Architecture
Required Software Reliability (RELY)
Product

Database Size (DATA)
Product Complexity (CPLX)
Attributes Documentation (DOCU)
Required Reusability (RUSE)
Computer Execution Time Constraint (TIME)

Platform Volatility (PVOL)
Attributes Main Storage constraint (STOR)
Analyst Capability (ACAP)

Personnel Continuity (PCON)
Personnel Programmer Experience (PEXP)
Attributes

Programmer Capability (PCAP)
Analyst Experience(AEXP)
Language & Tool Experience (LTEX)
Project Use of Software tools (TOOL)

Required development schedule (SCED)
Attributes Site Locations & Communications Technology b/w
sites (SITE)
39
Added Cost Drivers Deleted Cost Drivers
7 cost drivers 5 Cost Drivers
DOCU VIRT
RUSE TURN
VEXP
PVOL
LEXP
PLEX MODP
LTEX
PCON
SITE
17 Cost Drivers
Cost Very Low Low Nominal High Very High Extra High
Drivers
RELY 0.75 0.88 1.00 2.48 1.24 0.00
DATA 0.93 1.00 2.03 2.03 0.00
CPLX 0.75 0.88 1.00 2.83 1.41 0.00
RUSE 0.91 1.00 2.19 1.10 0.00
DOCU 0.89 0.95 1.00 3.12 1.56 0.00
TIME 1.00 1.11 1.31 1.67
STOR 1.00 1.06 1.21 1.57
PVOL 0.87 1.00 1.15 1.30
ACAP 1.50 1.22 1.00 0.83 0.67
PCAP 1.37 1.16 1.00 0.87 0.74
PCON 1.24 1.10 1.00 0.92 0.84
AEXP 1.22 1.10 1.00 0.89 0.81
PEXP 1.25 1.12 1.00 0.88 0.81
LTEX 1.22 1.10 1.00 0.91 0.84
TOOL 1.24 1.12 1.00 0.86 0.72
SITE 1.25 1.10 1.00 0.92 0.84 0.78
SCED 1.29 1.10 1.00 1.00 1.00
Schedule Estimation
Development time can be calculated using PMadjusted as a key
factor and the desired equation is:
Where
= constant, provisionally set to 3.67, B = Scaling factor
TDEVnominal = calendar time in months with a scheduled constraint
PMadjusted = Estimated effort in Person months (after adjustment)
Size Measurement
Size can be measured in any unit and the model can be calibrated
accordingly. However, COCOMO II details are:
I. Application composition model uses the size in object points.
II. The other two models use size in KLOC.
42
Post Architecture: Example
Ques: A software project of application generator category with estimated 50
KLOC has to be developed. The scale factor (B) has low precedentness, high
development flexibility and low team cohesion. The identified 17 Cost drivers are
high reliability (RELY), very high database size (DATA), high execution time
constraint (TIME),
very high analyst capability (ACAP), high programmers capability (PCAP).
The other cost drivers are nominal.
Calculate the effort in Person-Months for the development of the project.
Solution : Here B = 1.1129

PMnominal = 194.41 Person-months
= 194.41 x (1.15 x 1.19 x 1.11 x 0.67 x 0.87)

= 194.41 x 0.885
= 172.05 Person-months
43
Final Word
The models are just there to help, not
to make the management decisions
for you.
--Barry Boehm
Ref: https://cs.uwaterloo.ca/~apidduck/se362/Lectures/cocomo.pdf
References
Software Engineering (Third Edition) By K.K.Aggarwal &
Y. Singh
Fundamentals of Software Engineering (Third Edition)
By Rajib Mall
Software Engineering , 6th Edition By Ian Sommerville
Software Engineering (Sixth Edition) by Roger S.
Pressman
https://cs.uwaterloo.ca/~apidduck/se362/Lectures/coco
mo.pdf
Thank You

Cocomo

Uploaded by

Copyright:

Available Formats

Cocomo

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Cocomo

Uploaded by

Copyright:

Available Formats

LOC, COCOMO I & COCOMO II

Subject: Software Engineering Presented By:

Fig:- Activities during software project planning

A Line of code is any line of program text that is not a comment or

The procedure for the calculation of UFP in mathematical form is given

Organic Typically Small size project, Little Not Tight

Semi Typically Medium size project Medium Medium

Embedded Typically Large project, Real- Significant Tight

DevelopmentTime(D) = cb * (E) db (in month)

Average staff size(SS) = E/D (in Person)

Productivity(P) = KLOC / E (in KLOC/Person-month)

Very Very Extra

Product Required Software Reliability (RELY)

Execution Time Constraint (TIME)

Analyst Capability (ACAP)

Project Modern programming practices (MODP)

A new project with estimated 400 KLOC embedded system has to be

EAF = 1.29 * 0.95 = 1.22

Ep (Total Effort) = p * E (in Person-Month)

EAF = 1.15 * 1.15 * 0.86 * 1.07 = 1.2169

Ref: Software Engineering By K.K.Aggarwal & Y. Singh by : Jyotsna Agnihotri

Compute The Effort

Ref: Software Engineering By K.K.Aggarwal & Y. Singh by : Jyotsna Agnihotri

Object Points * (100 - %reuse)

Ref: Software Engineering By K.K.Aggarwal & Y. Singh&gilb.com by : Jyotsna Agnihotri

Productivity rate (PROD) = NOP/Person month

Compute the effort in Persons-Months: When

Ref: Software Engineering By K.K.Aggarwal & Y. Singh by : Jyotsna Agnihotri

Ref: Software Engineering By K.K.Aggarwal & Y. Singh by : Jyotsna Agnihotri

No. Of Total<4 Total<8 Total 8+

This project comes under the category of application composition estimation

Ref: Software Engineering By K.K.Aggarwal & Y. Singh by : Jyotsna Agnihotri

Using the formula NOP is calculated as:

Ref: Software Engineering By K.K.Aggarwal & Y. Singh by : Jyotsna Agnihotri

Early design cost drivers

1. Product Reliability and Complexity (RCPX)

Architecture/ 7.07 5.65 4.24 2.83 1.41 0.00

Team Cohesion 5.48 4.38 3.29 2.19 1.10 0.00

B = 0.91 + 0.01 * (Sum of rating on scaling factors for the project)

Early Design Extra Very Low Nominal High Very Extra

= 2.5 * (50)1.1129 = 194.41 Person-months

PDIF = high (1.29) PERS = high (0.83)

= 194.41 * [1.29 x 0.83]

Computer Execution Time Constraint (TIME)

Analyst Capability (ACAP)

Project Use of Software tools (TOOL)

Solution : Here B = 1.1129

= 194.41 x (1.15 x 1.19 x 1.11 x 0.67 x 0.87)

You might also like