Information system modularization construction method based on capability package

Abstract

The invention belongs to the technical field of information system design, and discloses an information system modular construction method based on a capability package. The method comprises the steps of capability package design and disassembly, modular architecture design, dynamic combination and loading, and modular test and verification. A modular design idea is adopted, system functions are disassembled into independent capacity pack modules, and flexible combination of the modules is realized by using a combination mode. And through dynamic task demand matching, an optimal module combination scheme is generated, and dynamic recombination and expansion of the system are realized. According to the method, the system development period is remarkably shortened, the maintainability and expansibility of the system are improved, and the method is suitable for information system design and deployment in a multi-task environment.

Description

Technical Field

[0001] The present invention belongs to the technical field of information system design and intelligence technology, and particularly relates to a method for modular construction of an information system based on capability packages. Background Art

[0002] The information provided in this section is only background information related to the present disclosure and does not necessarily represent prior art.

[0003] When modern information systems face a highly complex battlefield environment and diverse mission requirements, they must possess extremely strong adaptability and flexibility. As the operational environment changes more rapidly, commanders need to be able to obtain critical information in real time and make decisions quickly, which places higher demands on the capabilities of information systems. However, many current information systems still adopt a tightly coupled architecture design, resulting in a high degree of dependence between various functional modules. Although this design approach may have a certain degree of integration in the initial stage of the system, its drawbacks gradually become apparent as mission requirements change.

[0004] The tightly coupled architecture increases the mutual dependence between modules, and any modification to one module may affect the functions of other modules. This not only increases the difficulty of system maintenance but also significantly extends the development cycle. In addition, the highly dependent module design also limits the scalability of the system. When adding new functions or modules, large-scale modifications to the existing system are often required, increasing the complexity and risk of implementation.

[0005] Facing a dynamic environment, traditional system architectures often lack sufficient flexibility. When commanders execute missions, they may face rapidly changing situations, which requires command information systems to be able to respond and adjust quickly. However, due to the inherent limitations of tightly coupled designs, traditional systems often cannot complete function adjustments or reorganizations within a short time, thereby affecting the timeliness and accuracy of decision-making. Summary of the Invention

[0006] Aiming at the deficiencies of the prior art, the present invention discloses a method for modular construction of an information system based on capability packages. By disassembling system functions into loosely coupled capability package modules and using the composite pattern to achieve dynamic combination of modules and customized deployment of tasks, problems such as long development cycles and poor scalability in existing systems are solved.

[0007] Object-oriented design patterns, especially the composite pattern, provide theoretical support for modular system design. By disassembling system functions into loosely coupled capability package modules and using the composite pattern to achieve dynamic combination of modules, the flexibility and scalability of the system can be significantly improved.

[0008] Step 1: Competence Package Design and Decomposition. Extract functions through requirements analysis, modularize the system functions into independent competence packages. Each competence package contains the attributes, methods, and dependencies of the system functions, and defines its interfaces and context in a unified metadata format.

[0009] Step 2: Modular Architecture Design. Build a modular architecture based on the composite pattern, define the loose coupling relationship between modules using a hierarchical tree structure, and achieve collaboration and function extension between modules through unified interfaces.

[0010] Step 3: Dynamic Composition and Loading. Dynamically compose modules according to the matching degree between task requirements and module functions, and achieve the rapid deployment and operation of modules through a configuration-driven loading method.

[0011] Step 4: Modular Testing and Verification. Ensure the correctness and efficiency of the modular system in collaborative operation by verifying the independence of modules, testing the integrity of the system, and evaluating the dynamic loading performance.

[0012] Furthermore, the specific steps of Step 1 include:

[0013] Step 1-1: Requirements Analysis. According to the combat mission requirements of the system, extract the function requirement list R, and decompose the function requirement list R into several sub-requirements {r1, r2, …, r m};

[0014] Step 1-2: Define Competence Package. Represent the function module in the system with the competence package P i , which contains the attribute set A i , the method set M i , and the dependency set D i :

[0015] P i = {A i , M i , D i};

[0016] Among them, i is the index number of the competence package, that is, the i-th competence package in the system, and its value range is 1 to n. A i is the attribute set of the module, such as function priority, required resources, etc.; M i is the function method set of the module, describing the specific functions of the competence package; D i is the inter-module dependency relationship, describing the context or external data support required by the module;

[0017] Step 1-3: Competence Package Metadata Description. Record the core information of the competence package in a unified metadata format. The core information includes function description, call interface, and resource requirements; the dependency relationship of the competence package is clearly marked through a standardized description format:

[0018] D i = {d i1 , d i2 , …, d ij}, d ij ∈ Dependencies;

[0019] where D i is the dependency set of the capability package P i , representing the external support required when the capability package executes tasks; d ij represents the j-th module on which the capability package P i depends; the Dependencies set is used to describe all the external modules or data sources on which the capability package P i depends, and its mathematical definition is:

[0020]

[0021] Furthermore, the specific steps of the modular architecture design in step 2 include:

[0022] Step 2-1: Define the module combination relationship, construct a tree-like hierarchical structure of the modules, and define the relationship between the parent module and the child module as:

[0023] F = {C1, C2, …, C n}, F ∈ C, C i ∈ C,

[0024] where F represents the parent module, which refers to a higher-level functional module that can call one or more child modules to complete more complex tasks; C i represents its child module, which is part of the parent module, executes more specific functions, and forms a hierarchical relationship with the parent module; the combination relationship between the parent module and the child module is recursive, and through multi-level child module expansion, a tree-like hierarchical module architecture is formed;

[0025] Step 2-2: Design the module interface, design a unified interface for each module to define the interaction method between modules, and the description of the interface includes input parameter X, output result Y, and dependency relationship D:

[0026]

[0027] Step 2-3: Design the module execution logic. When the parent module calls the child module, it follows the top-down execution order and returns the result upward after completion. The execution logic of each module can be expressed as:

[0028] Y i = f(X i , D i ), i = 1, 2, …, n;

[0029] Among them, f() represents the functional implementation logic of the module;

[0030] Step 2-4: Optimize the module dependencies of the loose coupling architecture. By reducing the direct coupling degree of the modules, the mutual dependence between the modules is reduced. Use standardized interfaces to manage the input and output of the modules. The optimized coupling relationship satisfies:

[0031]

[0032] Among them, the Coupling() function calculates the coupling of the module.

[0033] Furthermore, the specific steps of dynamic composition and loading in Step 3 include:

[0034] Step 3-1: Match the requirements with the modules. Input the task requirement T, and match the functional requirement list R = {r1, r2,..., r m}; The function set provided by each module P i is F i = {f i1 , f i2 ,...}, and calculate the matching degree f(T, F i ):

[0035]

[0036] Among them, |R ∩ F i | represents how many functions in the function set F i meet the functional requirement list R, and |R| represents the number of function items in the functional requirement list, with a value of m.

[0037] Step 3-2: Module combination priority scoring. Based on the matching degree f(T, F i ) obtained in Step 3-1, combined with the performance indicators of the modules, calculate the priority score S of the module combination. The performance indicators include the execution time T i and the resource consumption C i :

[0038]

[0039] Among them, w1, w2, and w3 are weight factors, which are adjusted according to the actual scenario.

[0040] Step 3-3: Dynamic loading mechanism. Adopt a configuration-driven method to dynamically load modules according to the requirements.

[0041] Furthermore, the specific steps of dynamic loading in Step 3-3 include:

[0042] Step 3-3-1: Select module combination. According to the module combination priority score obtained in Step 3-2, select the module combination P with the highest priority from the module library. opt ={P1, P2, …, P n}.

[0043] Step 3-3-2: Load modules. According to the selected module combination in Step 3-3-1, load the modules and establish the context dependency relationships between the modules.

[0044] Step 3-3-3: Activate modules. After the modules are loaded, activate the selected modules and initialize the running environment.

[0045] Step 4: Modular testing and verification. Ensure the correctness and efficiency of the modular system during collaborative operation by verifying the independence of the modules, testing the integrity of the system, and evaluating the dynamic loading performance.

[0046] Step 4-1: Independence verification. Perform function verification on each module separately. The independence verification formula is:

[0047]

[0048] P i ∩P j represents the functional or resource intersection between the capability package P i and P j . If the intersection is empty then Independence(P i ) takes the value of 1, indicating that P i and P j are completely independent. If the intersection is not empty, then Independence(P i ) takes the value of 0, indicating that P i and P j are not completely independent.

[0049] Step 4-2: Integrity testing. Conduct overall verification on the combined modular system. The system integrity is evaluated by the following formula:

[0050]

[0051] Among them, Valid Outputs represents the valid outputs, referring to the number of task results that the system has successfully completed and meets the expectations. The calculation formula is as follows:

[0052]

[0053] N is the total number of tasks executed by the system, and O i is the output result of the i-th task (if the task is successfully completed, then Oi = 1, otherwise O i = 0), V i is the correctness determination factor for the i-th task (if the output meets the expectation, then V i = 1, otherwise V i = 0).

[0054]

[0055] Total Outputs represents the total output. Regardless of the task outcome, the O i value is 1 for all.

[0056] Step 4-3: Performance evaluation. Set the comprehensive performance score S perf , and verify the efficiency of the dynamic combination and loading mechanism, including the loading time T load , the execution time T exec , the resource consumption R total , and the calculation formula is as follows:

[0057]

[0058] where, T load is the module loading time, T exec is the task execution time, R total is the total resource consumption (including CPU, memory, and network bandwidth occupancy), and α, β, γ are weight factors used to adjust the importance of each indicator to meet specific task requirements.

[0059] Compared with the prior art, the present invention has the following beneficial effects:

[0060] Through the design and decomposition of the ability package, the construction of the modular architecture, and the dynamic combination and loading technology, the present invention realizes the independence, flexibility, and scalability of the functional modules of the information system, effectively overcoming the problems of long development cycle and high expansion difficulty caused by the tight coupling of modules in the traditional system. Through the unified ability package interface and the standardized metadata definition, the present invention significantly improves the reusability of the functional modules and the dynamic response ability of the system, enabling the system to quickly complete the module combination and deployment according to the task requirements, reducing the development time and improving the maintenance efficiency. By using the priority scoring mechanism and the dynamic loading technology, the present invention ensures the best matching between the task requirements and the functional modules, supporting the real-time adjustment and expansion of the system functions in complex environments. Compared with the prior art, the present invention significantly improves the command efficiency and the adaptability of the system in dynamic scenarios such as command and control and emergency management, and has important application value and broad promotion prospects. Description of the Drawings

[0061] The following further elaborates on the present invention in conjunction with the accompanying drawings and specific embodiments, and the above and / or other advantages of the present invention will become clearer.

[0062] Figure 1 It is a flowchart for decomposing the capability package.

[0063] Figure 2 It is a flowchart for dynamic composition and loading of the capability package.

[0064] Figure 3 It is a flowchart of the present invention. Specific Embodiments

[0065] The following further clarifies the present invention in conjunction with the accompanying drawings and specific examples. It should be understood that these examples are only used to illustrate the present invention and not to limit the scope of the present invention. After reading the present invention, various equivalent modifications made by those skilled in the art fall within the scope defined by the appended claims of this application.

[0066] Step 1: Capability package design and decomposition. Extract functions through requirements analysis, modularize the system functions into independent capability packages. Each capability package contains the attributes, methods, and dependencies of the system functions, and defines its interfaces and context in a unified metadata format.

[0067] Step 2: Modular architecture design. Build a modular architecture based on the composite pattern, define the loose coupling relationship between modules using a hierarchical tree structure, and achieve cooperation and function extension between modules through a unified interface.

[0068] Step 3: Dynamic composition and loading. Dynamically combine modules according to the matching degree between the task requirements and the module functions, and achieve the rapid deployment and operation of the modules through a configuration-driven loading method.

[0069] Step 4: Modular testing and verification. Ensure the correctness and efficiency of the modular system in collaborative operation by verifying the independence of the modules, testing the integrity of the system, and evaluating the dynamic loading performance.

[0070] Furthermore, the specific steps of Step 1 include:

[0071] Step 1-1: Requirements analysis. According to the combat mission requirements of the system, extract the function requirement list R, and decompose the function requirement list R into several sub-requirements {r1, r2, …, r m};

[0072] Step 1-2: Define the capability package. Use the capability package P i to represent the function module in the system, which includes the attribute set A i , method set M i , and dependency set D i:

[0073] P i = {A i , M i , D i};

[0074] Among them, i is the index number of the ability package, that is, the i-th ability package in the system, and its value range is 1 to n. A i is the attribute set of the module, such as function priority, required resources, etc.; M i is the function method set of the module, describing the specific functions of the ability package; D i is the inter-module dependency relationship, describing the context or external data support required by the module;

[0075] Step 1-3: Ability package metadata description, recording the core information of the ability package through a unified metadata format. The core information includes function description, call interface, and resource requirements; the dependency relationship of the ability package is clearly marked through a standardized description format:

[0076] D i = {d i1 , d i2 , …, d ij}, d ij ∈ Dependencies;

[0077] Among them, D i is the dependency set of the ability package P i , indicating the external support required when this ability package executes tasks; d ij represents the j-th module that the ability package P i depends on; the Dependencies set is used to describe all external modules or data sources that the ability package P i depends on, and its mathematical definition is:

[0078]

[0079] Furthermore, the specific steps of the modular architecture design in Step 2 include:

[0080] Step 2-1: Define the module combination relationship, construct a tree-like hierarchical structure of the modules, and define the relationship between the parent module and the child module as:

[0081] F = {C1, C2, …, C n}, F ∈ C, C i ∈ C;

[0082] Among them, F represents the parent module. The parent module refers to a higher-level functional module that can call one or more child modules to complete more complex tasks; C iIt represents its sub - modules, which are part of the parent module, perform more specific functions, and form a hierarchical relationship with the parent module; the combination relationship between the parent module and the sub - modules is recursive, and through multi - level sub - modules expansion, a tree - like hierarchical module architecture is formed.

[0083] Step 2 - 2: Design module interfaces. Design unified interfaces for each module to define the interaction method between modules. The description of the interface includes input parameter X, output result Y, and dependency relationship D:

[0084]

[0085] Step 2 - 3: Design module execution logic. When the parent module calls the sub - module, it follows the top - down execution order and returns the result upward after completion. The execution logic of each module can be expressed as:

[0086] Y i = f(X i ,D i ), i = 1, 2, …, n;

[0087] where f() represents the functional implementation logic of the module;

[0088] Step 2 - 4: Optimize the module dependencies of the loose - coupling architecture. By reducing the direct coupling degree of modules, the mutual dependence between modules is reduced, and standardized interfaces are used to manage the input and output of modules. The optimized coupling relationship satisfies:

[0089]

[0090] where the Coupling() function calculates the coupling of the module.

[0091] Furthermore, the specific steps of dynamic composition and loading in Step 3 include:

[0092] Step 3 - 1: Match requirements with modules. Input the task requirement T, and match the functional requirement list R = {r1, r2, …, r m}; the function set provided by each module P i is F i = {f i1 , f i2 , …}, and calculate the matching degree f(T, F i ):

[0093]

[0094] where |R ∩ F i | represents how many functions in the function set F i meet the functional requirement list R, |R| represents the number of function items in the functional requirement list, and the value is m.

[0095] Step 3-2: Module combination priority scoring. Based on the matching degree f(T,F i ), combined with the performance metrics of the modules, calculate the priority score S of the module combination. The performance metrics include execution time T i and resource consumption C i :

[0096]

[0097] where w1, w2, w3 are weight factors, which are adjusted according to the actual scenario.

[0098] Step 3-3: Dynamic loading mechanism. Adopt a configuration-driven method to dynamically load modules according to requirements.

[0099] Further, the specific steps of dynamic loading in Step 3-3 include:

[0100] Step 3-3-1: Select the module combination. According to the module combination priority score obtained in Step 3-2, select the module combination P with the highest priority from the module library opt ={P1, P2, …, P n}.

[0101] Step 3-3-2: Load the modules. Load the modules according to the selected module combination in Step 3-3-1, and establish the context dependency relationship between the modules.

[0102] Step 3-3-3: Activate the modules. After the modules are loaded, activate the selected modules and initialize the running environment.

[0103] Step 4: Modular testing and verification. Ensure the correctness and efficiency of the modular system in collaborative operation by verifying the independence of the modules, testing the integrity of the system, and evaluating the dynamic loading performance.

[0104] Step 4-1: Independence verification. Perform function verification on each module separately. The independence verification formula is:

[0105]

[0106] P i ∩P j represents the functional or resource intersection between the capability packages P i and P j . If the intersection is empty then Independence(P i ) takes the value of 1, indicating that P i and P jCompletely independent. If the intersection is not empty, then Independence(P i ) takes the value of 0, indicating that P i and P j are not completely independent.

[0107] Step 4-2: Integrity test. Conduct an overall verification on the combined modular system. The system integrity is evaluated by the following formula:

[0108]

[0109] Among them, Valid Outputs represents the valid outputs, referring to the number of task results that the system successfully completes and meets the expectations. The calculation formula is as follows:

[0110]

[0111] N is the total number of tasks executed by the system, O i is the output result of the i-th task (if the task is successfully completed, then O i =1, otherwise O i =0), V i is the correctness determination factor of the i-th task (if the output meets the expectations, then V i =1, otherwise V i =0).

[0112]

[0113] Total Outputs represents the total outputs. Regardless of the task results, the O i value is 1.

[0114] Step 4-3: Performance evaluation. Set the comprehensive performance score S perf , and verify the efficiency of the dynamic combination and loading mechanism, including the loading time T load , the execution time T exec , and the resource consumption R total . The calculation formula is as follows:

[0115]

[0116] Among them, T load is the module loading time, T exec is the task execution time, R total is the total resource consumption (including CPU, memory, and network bandwidth occupancy). α, β, and γ are weight factors used to adjust the importance of each indicator to meet specific task requirements.

[0117] The present invention provides an idea and method for modular construction of an information system based on capability packages. There are many methods and ways to specifically implement this technical solution. The above description is only the preferred embodiment of the present invention. It should be noted that for those of ordinary skill in the art in this technical field, without departing from the principle of the present invention, several improvements and refinements can be made, and these improvements and refinements should also be regarded as the protection scope of the present invention. Each component not clearly defined in this embodiment can be implemented using existing technologies.

Claims

1. A modular construction method for an information system based on capability packages, characterized in that It includes the following steps: Step 1: Ability package design and decomposition. Extract functions through requirements analysis, modularize the system functions into independent ability packages. The ability package contains the attributes, methods, and dependencies of the system functions. The ability package defines its interfaces and context in a unified metadata format; Step 2: Based on the ability packages extracted in Step 1, conduct modular design. Build a modular architecture based on the composite pattern, define the loose coupling relationship between modules using a hierarchical tree structure, and achieve collaboration and function extension between modules through the unified interfaces set in Step 1; Step 3: Based on the modular architecture defined in Step 2, dynamically combine and load modules. According to the matching degree between task requirements and module functions, use a priority scoring mechanism to dynamically combine modules, and achieve the rapid deployment and operation of modules through a configuration-driven loading method; Step 4: Based on the dynamic combination and loading implemented in Step 3, test and verify the modular system. The modular system verifies the independence of modules, tests the integrity of the system, and evaluates the dynamic loading performance during collaborative operation.

2. The method for modular construction of an information system based on an ability package according to claim 1, characterized in that The specific steps of the ability package design and decomposition in Step 1 include: Step 1-1: Requirement analysis. According to the operational mission requirements of the system, extract the functional requirement list R, and decompose the functional requirement list R into several sub-requirements {r1, r2, …, r m}; Step 1-2: Define an ability package, with ability package P i representing a functional module in the system, including an attribute set A i , a method set M i , and a dependency set D i : P i = {A i , M i , D i}; where i is the index number of the capability package, i.e., the i-th capability package in the system, with a value range of 1 to n, A i is the set of module attributes; M i is the set of functional methods of the module, describing the specific functions of the capability package; D i is the inter-module dependency relationship, describing the context or external data support required by the module; Step 1-3: Ability package metadata description. Record the core information of the ability package in a unified metadata format. The core information includes function description, call interface, and resource requirements. The dependency relationship of the ability package is clearly marked through a standardized description format: D i = {d i1 , d i2 , …, d ij}, d ij ∈ Dependencies; Among them, D i is the dependency set of the capability package P i , indicating the external support required when the capability package executes tasks; d ij represents the j-th module on which the capability package P i depends; The Dependencies set is used to describe all the external modules or data sources on which the capability package P i depends, and its mathematical definition is:

3. The method for modular construction of an information system based on capability packages according to claim 2, wherein The specific steps of the modular architecture design in Step 2 include: Step 2-1: Define the module combination relationship. Build a tree-like hierarchical structure of modules, and define the relationship between the parent module and the child module as: F = {C1, C2, …, C n}, F ∈ C, C i ∈ C, Among them, F represents the parent module. The parent module refers to a higher-level functional module that can call one or more sub-modules to complete more complex tasks; C i represents its sub-module, which is part of the parent module, performs more specific functions, and forms a hierarchical relationship with the parent module; the combination relationship between the parent module and the sub-module is recursive, and through multi-level sub-module expansion, a tree-like hierarchical module architecture is formed; Step 2-2: Design module interfaces. Design a unified interface for each module to define the interaction method between modules. The description of the interface includes input parameter X, output result Y, and dependency relationship D: Step 2-3: Design the module execution logic. When the parent module calls the child module, follow the top-down execution order and return the result upward after completion. The execution logic of each module can be expressed as: Y i = f(X i , D i ), i = 1, 2, …, n; where f() represents the function implementation logic of the module; Step 2-4: Optimize the module dependencies of the loose coupling architecture. By reducing the direct coupling degree of modules, reduce the mutual dependence between modules, and use standardized interfaces to manage the input and output of modules. The optimized coupling relationship satisfies: where the Coupling() function calculates the coupling of the module.

4. The method for modular construction of an information system based on capability packages according to claim 3, wherein The specific steps of the dynamic combination and loading in Step 3 include: Step 3-1: Match the requirements with the modules. Input the task requirement T, and match the functional requirement list R = {r1, r2, …, r m}; The function set provided by each module P i is F i = {f i1 , f i2 , …}, and calculate the matching degree f(T, F i ): Among them, |R∩F i | represents the function set F i indicates how many functions meet the function requirement list R, and |R| represents the number of function items in the function requirement list, with a value of m; Step 3-2: Module combination priority scoring. Based on the matching degree f(T,F i ) obtained in Step 3-1, combined with the performance indicators of the modules, calculate the priority score S of the module combination. The performance indicators include execution time T i and resource consumption C i : where w1, w2, w3 are weight factors, adjusted according to the actual scenario; Step 3-3: Dynamic loading mechanism. Adopt a configuration-driven method to dynamically load modules according to requirements.

5. The method for modular construction of an information system based on capability packages according to claim 4, wherein: The specific steps of the dynamic loading in Step 3-3 include: Step 3-3-1: Select the module combination. According to the module combination priority score obtained in Step 3-2, select the module combination P with the highest priority from the module library opt ={P1, P2, …, P n}; Step 3-3-2: Load modules. According to the selected module combination in Step 3-3-1, load the modules and establish the context dependency relationship between modules; Step 3-3-3: Activate modules. After the modules are loaded, activate the selected modules and initialize the running environment.

6. The method for modular construction of an information system based on capability packages according to claim 5, characterized in that The specific steps of the modular testing and verification in Step 4 include: Step 4-1: Independence verification. Conduct function verification on each module separately; Step 4-2: Integrity test, which conducts an overall verification for the combined modular system; Step 4-3: Performance evaluation, set the comprehensive performance score S perf , verify the efficiency of the dynamic combination and loading mechanism, including the loading time T load , execution time T exec , resource consumption R total , and the calculation formula is as follows: Among them, T load is the module loading time, T exec is the task execution time, R total is the total resource consumption, including CPU, memory, and network bandwidth occupancy. α, β, and γ are weight factors used to adjust the importance of each metric to meet specific task requirements.

7. The method for modular construction of an information system based on an ability package according to claim 6, wherein The independence verification described in Step 4-1 is specifically to use the independence verification formula for inspection, and the independence verification formula is: Among which P i ∩P j represents the functional or resource intersection between the capability package P i and P j . If the intersection is empty ( ), then the value of Independence(P i ) is 1, indicating that P i and P j are completely independent. If the intersection is not empty, then the value of Independence(P i ) is 0, indicating that P i and P j are not completely independent.

8. The method for modular construction of an information system based on capability packages according to claim 6, wherein The integrity test described in Step 4-2 is specifically to use the integrity verification formula for inspection, and the integrity verification formula is: Among them, Valid Outputs represents the valid outputs, which refers to the number of task results that the system has successfully completed and meets the expectations. The calculation formula is as follows: N is the total number of tasks executed by the system, O i is the output result of the i-th task. If the task is successfully completed, then O i = 1; otherwise, O i = 0. V i is the correctness determination factor of the i-th task. If the output meets the expectation, then V i = 1; otherwise, V i = 0. Total Outputs represents the total output, which is 1 regardless of whether the task is successful or not. O i The value is 1.

Images