# Software Engineering | Calculation of Function Point (FP)

The function offered by a software program is measured using the Function Point Analysis (FPA) method in software engineering. It aids in determining a software project's size and complexity.

A component of software development called Function Point (FP) aids in estimating the cost of development at an early stage. It may assess usability from the user's perspective.

A software system's functioning is quantified using Function Points (FP), a unit of measurement in FPA, based on five key elements:

User-initiated inputs, such as filling out a form or uploading a file, are called external inputs (EI).

User-initiated outputs that deliver data from the system include creating reports and presenting data on screens, both examples of external outputs (EO).

External Inquiries (EQ) are user-initiated requests for data from the system that frequently involve a mix of input and output, such as looking up data in a database.

Internal Logical Files (ILF) are user-recognizable data collections that the system maintains, like a database table.

The program and external systems share external interface files (EIF) to read or write data to a file on another system.

It would help if you did the following actions to determine the Function Point (FP) count for a software project:

Based on the needs and requirements of the program, determine and count the quantity of each of the five components (EI, EO, EQ, ILF, and EIF) described above.

Depending on features like the quantity of data components, user interactions, and processing logic, assign a complexity value to each component. Simple, average, and difficult are the three levels of complexity.

Calculate the Unadjusted Function Point (UFP) for each component type using the following weighting factors:

EI UFP = (Number of EIs) x (Weight for EI)

EO UFP = (Number of EOs) x (Weight for EO)

EQ UFP = (Number of EQs) x (Weight for EQ)

ILF UFP = (Number of ILFs) x (Weight for ILF)

EIF UFP = (Number of EIFs) x (Weight for EIF)

To determine the Total Unadjusted Function Points (TUFP), add the UFP values for each component type:

TUFP is equal to EI UFP, EO UFP, EQ UFP, ILF UFP, and EIF UFP.

Utilize a Technical difficulty Factor (TCF) based on numerous technical elements that could influence the difficulty of the project. A multiplier, the TCF normally ranges from 0.65 to 1.35.

TUFP x TCF = Adjusted Function Points (AFP)

Based on the environmental elements that can impact the project's complexity, apply an Environmental Complexity Factor (ECF). A multiplier, the ECF normally ranges from 0.85 to 1.36.

AFP = AFP x ECF stands for Adjusted Function Points.

The final adjusted Function Point count (AFP) gauges the software project's size and complexity. It can be used for cost and effort estimation and project planning. Remember that the precise weighting factors, complexity values, and multiplier ranges may change depending on the organisation and the Function Point analysis method.

Step 1

Counting Function Point (FP): F = 14 * scale

Scale ranges from 0 to 5 depending on the characteristics of the Complexity Adjustment Factor (CAF). Scale is displayed in the table below:

No Influence: 0

2 - Moderate 1 - Incidental

3 - Standard

4 - Important

5 - Crucial

Calculate the Complexity Adjustment Factor (CAF) in step two.

CAF = 0.65 + (0.01 * F)

Calculate the Unadjusted Function Point (UFP) in step three.

TABLE (Necessary)

Divide each function point by its corresponding value in the TABLE.

Calculate the function point (FP = UFP * CAF) in step four.

Example:

Given the following values, compute the function point when all complexity adjustment factors (CAF) and weighting factors are average.

User Input = 50

User Output = 40

User Inquiries = 35

User Files = 6

External Interface = 4

Explanation:

Step-1: As the complexity adjustment factor is average (given in question), hence,

scale = 3.

F = 14 * 3 = 42

Step-2:

CAF = 0.65 + ( 0.01 * 42 ) = 1.07

Step-3: As weighting factors are also average (given in question), we ll multiply each function point to corresponding values in the TABLE.

UFP = (50*4) + (40*5) + (35*4) + (6*10) + (4*7) = 628

Step-4:

Function Point = 628 * 1.07 = 671.96

Code:

Output:

```Enter the number of External Inputs (EI): 10
Enter the number of External Outputs (EO): 5
Enter the number of External Inquiries (EQ): 8
Enter the number of Internal Logical Files (ILF): 4
Enter the number of External Interface Files (EIF): 3
Enter the Technical Complexity Factor (TCF): 1.2
Enter the Environmental Complexity Factor (ECF): 1.1

Final Function Points (FFP): 162.36
```

Based on the Function Point Analysis method you are using, we define weighting factors for each of the component types (EI, EO, EQ, ILF, and EIF). These values can be changed as necessary.

We ask the user to enter the counts for each component type and the Technical Complexity Factor (TCF) and Environmental Complexity Factor (ECF) in our interface.

To obtain the Adjusted Function Points (AFP), we first calculate the Unadjusted Function Points (UFP) and then adjust them by the TCF.

Finally, we apply the ECF to the AFP to determine the Final Function Points (FFP).

We enter the counts for each component type (EI, EO, EQ, ILF, and EIF).

An environmental complexity factor (ECF) of 1.1 and a technical complexity factor (TCF) of 1.2 are entered.

Based on the supplied inputs and the predefined weighting factors, the program determines the Unadjusted Function Points (UFP), Adjusted Function Points (AFP), and Final Function Points (FFP).