Ingeniería de Software | Cálculo del Punto de Función (FP)

Function Point (FP) es un elemento de desarrollo de software que ayuda a aproximar el costo de desarrollo al principio del proceso. Puede medir la funcionalidad desde el punto de vista del usuario.

Punto de función de conteo (FP):

  • Paso 1:
    F = 14 * scale

    La escala varía de 0 a 5 según el carácter del Factor de Ajuste de Complejidad (CAF). La siguiente tabla muestra la escala:

    0 - No Influence
    1 - Incidental
    2 - Moderate
    3 - Average
    4 - Significant
    5 - Essential 
  • Paso 2: Calcular el factor de ajuste de complejidad (CAF).
    CAF = 0.65 + ( 0.01 * F )
  • Paso 3: Calcule el punto de función no ajustado (UFP).

    TABLA (Requerido)

    Unidades de función Bajo Promedio Alto
    IE 3 4 6
    EO 4 5 7
    ecualizador 3 4 6
    ILF 7 10 15
    FEI 5 7 10

    Multiplique cada punto de función individual por los valores correspondientes en la TABLA.

  • Paso 4: Calcular el punto de función.
    FP = UFP * CAF

Ejemplo:
dados los siguientes valores, calcule el punto de función cuando todos los factores de ajuste de complejidad (CAF) y los factores de ponderación sean promedio.

User Input = 50
User Output = 40
User Inquiries = 35
User Files = 6
External Interface = 4 

Explicación:

  • Paso-1: Como el factor de ajuste de complejidad es promedio (dado en cuestión), por lo tanto,
    scale = 3.
    F = 14 * 3 = 42 
  • Paso 2:
    CAF = 0.65 + ( 0.01 * 42 ) = 1.07 
  • Paso 3: como los factores de ponderación también son promedio (dado en cuestión), multiplicaremos cada punto de función individual por los valores correspondientes en la TABLA.
    UFP = (50*4) + (40*5) + (35*4) + (6*10) + (4*7) = 628 
  • Paso 4:
    Function Point = 628 * 1.07 = 671.96 

    Esta es la respuesta requerida.

El programa para calcular el punto de función es el siguiente: –

#include <bits/stdc++.h>
using namespace std;
   
// Function to calculate Function Point
void calfp(int frates[][3], int fac_rate)
{
   
    // Function Units
    string funUnits[5] = {
        "External Inputs",
        "External Outputs",
        "External Inquiries",
        "Internal Logical Files",
        "External Interface Files"
    };
   
    // Weight Rates
    string wtRates[3] = { "Low", "Average", "High" };
   
    // Weight Factors
    int wtFactors[5][3] = {
        { 3, 4, 6 },
        { 4, 5, 7 },
        { 3, 4, 6 },
        { 7, 10, 15 },
        { 5, 7, 10 },
    };
   
    int UFP = 0;
   
    // Calculating UFP (Unadjusted Function Point)
    for (int i = 0; i < 5; i++) {
   
        for (int j = 0; j < 3; j++) {
   
            int freq = frates[i][j];
   
            UFP += freq * wtFactors[i][j];
        }
    }
   
    // 14 factors
    string aspects[14] = {
        "reliable backup and recovery required ?",
        "data communication required ?",
        "are there distributed processing functions ?",
        "is performance critical ?",
        "will the system run in an existing heavily utilized operational environment ?",
        "on line data entry required ?",
        "does the on line data entry require the input transaction to be built over multiple screens or operations ?",
        "are the master files updated on line ?",
        "is the inputs, outputs, files or inquiries complex ?",
        "is the internal processing complex ?",
        "is the code designed to be reusable ?",
        "are the conversion and installation included in the design ?",
        "is the system designed for multiple installations in different organizations ?",
        "is the application designed to facilitate change and ease of use by the user ?"
    };
   
    /*
    Rate Scale of Factors
    Rate the following aspects on a scale of 0-5 :-
    0 - No influence 
    1 - Incidental 
    2 - Moderate 
    3 - Average 
    4 - Significant 
    5 - Essential 
    */
   
    int sumF = 0;
   
    // Taking Input of factors rate
    for (int i = 0; i < 14; i++) {
   
        int rate = fac_rate;
   
        sumF += rate;
    }
   
    // Calculate CFP
    double CAF = 0.65 + 0.01 * sumF;
   
    // Calculate Function Point (FP)
    double FP = UFP * CAF;
   
    // Output Values
    cout << "Function Point Analysis :-" << endl;
   
    cout << "Unadjusted Function Points (UFP) : " << UFP << endl;
   
    cout << "Complexity Adjustment Factor (CAF) : " << CAF << endl;
   
    cout << "Function Points (FP) : " << FP << endl;
}
   
// driver function
int main()
{
    int frates[5][3] = {
        { 0, 50, 0 },
        { 0, 40, 0 },
        { 0, 35, 0 },
        { 0, 6, 0 },
        { 0, 4, 0 }
    };
   
    int fac_rate = 3;
   
    calfp(frates, fac_rate);
   
    return 0;
}
Producción:

Function Point Analysis :-
Unadjusted Function Points (UFP) : 628
Complexity Adjustment Factor (CAF) : 1.07
Function Points (FP) : 671.96

Publicación traducida automáticamente

Artículo escrito por pp_pankaj y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *