CN116149624B - Model measurement method based on extended Lustre language - Google Patents
Model measurement method based on extended Lustre language Download PDFInfo
- Publication number
- CN116149624B CN116149624B CN202310185399.4A CN202310185399A CN116149624B CN 116149624 B CN116149624 B CN 116149624B CN 202310185399 A CN202310185399 A CN 202310185399A CN 116149624 B CN116149624 B CN 116149624B
- Authority
- CN
- China
- Prior art keywords
- metric
- model
- node
- measurement
- mbse
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/31—Programming languages or programming paradigms
- G06F8/311—Functional or applicative languages; Rewrite languages
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/34—Graphical or visual programming
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/35—Creation or generation of source code model driven
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computing Systems (AREA)
- Stored Programmes (AREA)
- Debugging And Monitoring (AREA)
Abstract
The invention relates to a model measurement method based on an extended Lustre language, and belongs to the field of software measurement. According to the invention, a model structure tree is designed according to the extended Lustre language, and a model structure tree corresponding to engineering can be generated through visual modeling; predefined metric elements are designed, comprising four aspects of model object metrics, operator object metrics, package object metrics and state machine object metrics, and a metric metadata dictionary is designed according to the metric elements; different measurement value calculation modes are designed according to different measurement elements; the model measurement module based on the extended Lustre language is successfully added in the OnModel modeling platform, and the measurement result is displayed through a table. The model measurement is carried out based on the extended Lustre language structure, the method designs a model structure tree and predefined measurement elements according to the extended Lustre language, designs different measurement value calculation modes aiming at different measurement elements, and finally realizes the application of model measurement in an OnModel modeling platform and displays measurement results.
Description
Technical Field
The invention belongs to the field of software measurement, and particularly relates to a model measurement method based on an extended Lustre language.
Background
In the traditional software development process, software metrics are an important method for improving the quality of software. In the development of software based on a model, a software design model is used as a basis for model driving development, and if the effectiveness of the software design model cannot be ensured, the software quality is influenced. Thus, model quality can be ensured by evaluating the complexity and effectiveness of the model through model measurement.
The invention aims at filling the blank of the domestic model-based software design tool, successfully develops an OnModel visual modeling tool based on the extended Lustre language, evaluates the complexity of a model through model measurement, and assists software developers and testers in carrying out quality evaluation.
Disclosure of Invention
First, the technical problem to be solved
The invention aims to solve the technical problem of providing a model measurement method based on an extended Lustre language, so as to solve the blank problem of the model measurement function of a visual modeling tool taking the extended Lustre language as a core in China and provide reference for a domestic related software development team.
(II) technical scheme
In order to solve the technical problems, the invention provides a model measurement method based on an extended Lustre language, which comprises the following steps:
s1: according to the extended Lustre language design model structure tree, a model is constructed by graphically dragging on canvas of a modeling tool, and a corresponding model structure tree is generated at the same time;
s2: designing a predefined metric element for model complexity analysis, and simultaneously designing a metric metadata dictionary for storing metric information and metric values;
s3: calculating the corresponding measurement values of different measurement elements according to the measurement elements checked by the user on the setting interface, and storing the corresponding measurement values into a measurement metadata dictionary;
s4: traversing the data dictionary, displaying the effective data items on the front end through a visualized chart, and locally storing the measurement file.
Further, the step S1 specifically includes:
s11: designing a model structure tree according to the extended Lustre language, wherein the model structure tree comprises a tree structure of a model and tree node content;
s12: a model is constructed by graphically dragging on a canvas of a modeling tool, and a corresponding model structure tree is generated.
Further, the step S11 specifically includes: the structural tree is modeled from the hierarchy of the grammar structure by expressing grammar rules through the Backus-Van (Backus Normal Form, BNF), the grammar includes four levels of engineering, packaging, operators and state machines.
Further, the engineering program part is an entry for expanding the Lustre language program, and also corresponds to a root node of the tree in the model structure tree;
the decls part in the child node package_del of the engineering node of the model structure tree comprises: packet node package_del, type node type_block, constant node const_block, sensor node sensor_block, and operator node user_op_decl; wherein the type node, the constant node and the sensor node are used as leaf nodes, and no child node exists; sub-nodes of the packet nodes form multi-level nesting; the operator node continues to extend according to the user_op_decl portion;
the operator node embodies a core computing part of the combination of data flow and control flow of the extended Lustre language, comprising: input port params, output port params, variable local_block and state machine state_machine; variable local_block is refined into a Local Variable leaf node Local Variable and a probe leaf node probe; the state machine node continues to extend according to the state_machine according to the grammar;
the state machine node includes: a state child node, namely a state_decl part; the state child node contains a transition grandchild node, the trans it section.
Further, the step S2 specifically includes:
s21: designing predefined metric elements, including four aspects of model object metrics, operator object metrics, package object metrics and state machine object metrics;
s22: the metric metadata dictionary is designed according to the metric elements.
Further, the step S21 specifically includes: designing 16 metrics from four aspects of model object metrics, operator object metrics, package object metrics, and state machine object metrics for complexity analysis of the model, comprising: MBSE_M001-MBSE_M016, wherein the metric elements of the model object metrics comprise: MBSE_M001-MBSE_M006 are respectively: total number of operators, total number of types, total number of constants, total number of sensors, total number of packages, and total number of canvas; the metric element of the packet object metric comprises: MBSE_M007 is: number of operators; the metric element of the operator object metric includes: MBSE_M008-MBSE_M013 are respectively: the number of input ports, the number of output ports, the number of probes, the number of local variables, the number of signals and the number of user operator instances; the metric element of the state machine object metric comprises: MBSE_M014-MBSE_M016 are: the number of states, the depth of the state machine, and the number of transitions.
Further, the fields of the metric metadata dictionary of step S22 include: project, configuration, date, category _name, meta_id, meta_ name, description, min, average, max, path, value.
Further, the step S3 specifically includes:
s31: different measurement value calculation modes are designed according to different measurement elements;
s32: and calculating the measurement value according to the measurement element checked by the user on the setting interface, and storing the corresponding measurement value into a measurement metadata dictionary.
Further, in the step S31, the metric calculation method includes: nested metric calculations for the same type of tree node, metric calculations for the tree node list, and maximum depth calculations for the nested state machine.
Further, metric elements covered by the nested metric calculation of the same type of tree nodes are MBSE_M001-MBSE_M006, MBSE_M014 and MBSE_M016, and the depth-first recursion method is adopted to calculate the metric values due to packet nesting of packets in the model objects; the metric element covered by the metric calculation of the tree node list is MBSE_M007-MBSE_M0013, and the length of the child node list is calculated; the metric covered by the maximum depth calculation of the nested state machine is MBSE_M015, and the calculation is performed by adopting a depth-first recursion method.
(III) beneficial effects
The invention provides a model measurement method based on an extended Lustre language, which has at least one or a part of the following advantages:
(1) According to the extended Lustre language, a model structure tree is designed, and a model structure tree corresponding to engineering can be generated through visual modeling;
(2) Predefined metric elements are designed, including four aspects of model object metrics, operator object metrics, package object metrics, and state machine object metrics, and a metric metadata dictionary is designed based on the metric elements.
(3) Different measurement value calculation modes are designed according to different measurement elements.
(4) The model measurement module based on the extended Lustre language is successfully added in the OnModel modeling platform, and the measurement result is displayed through a table.
The model measurement is carried out based on the extended Lustre language structure, the method designs a model structure tree and predefined measurement elements according to the extended Lustre language, designs different measurement value calculation modes aiming at different measurement elements, and finally realizes the application of model measurement in an OnModel modeling platform and displays measurement results.
Drawings
FIG. 1 is a flow chart of a model metrology method based on the extended Lustre language;
FIG. 2 is a model structure tree based on the extended Lustre language;
FIG. 3 is a model structure tree corresponding to an OnModel tool graphical modeling instance;
FIG. 4 is a metric set up in the OnModel modeling tool;
FIG. 5 is a visual illustration of model metrics in an OnModel modeling tool.
Detailed Description
To make the objects, contents and advantages of the present invention more apparent, the following detailed description of the present invention will be given with reference to the accompanying drawings and examples.
The invention relates to a model measurement method based on an extended Lustre language, which comprises the following steps: according to the extended Lustre language design model structure tree, a model is constructed by graphically dragging on canvas of a modeling tool, and a corresponding model structure tree is generated at the same time; designing a predefined metric element for model complexity analysis, and simultaneously designing a metric metadata dictionary for storing metric information and metric values; calculating the corresponding measurement values of different measurement elements according to the measurement elements checked by the user on the setting interface, and storing the corresponding measurement values into a measurement metadata dictionary; traversing the data dictionary, displaying the effective data items on the front end through a visualized chart, and locally storing the measurement file. The invention objectively designs the model object measurement, the operator object measurement, the package object measurement, the state machine object measurement and other measurement elements from a plurality of objects, and displays the measurement result through a table to assist software designers and testers in carrying out model complexity and model quality assessment.
In order to solve the technical problems, the invention provides a model measurement method based on an extended Lustre language, which comprises the following steps:
s1: and (3) according to the extended Lustre language design model structure tree, constructing a model by graphically dragging on a canvas of a modeling tool, and generating a corresponding model structure tree.
S2: designing a predefined metric element for model complexity analysis, and simultaneously designing a metric metadata dictionary for storing metric information and metric values;
s3: and calculating the measurement values corresponding to the different measurement elements according to the measurement elements checked by the user on the setting interface, and storing the corresponding measurement values into a measurement metadata dictionary.
S4: traversing the data dictionary, displaying the effective data items on the front end through a visualized chart, and locally storing the measurement file.
Further, the step S1 specifically includes:
s11: designing a model structure tree according to the extended Lustre language, wherein the model structure tree comprises a tree structure of a model and tree node content;
s12: a model is constructed by graphically dragging on a canvas of a modeling tool, and a corresponding model structure tree is generated.
Further, the step S2 specifically includes:
s21: designing predefined metric elements, including four aspects of model object metrics, operator object metrics, package object metrics and state machine object metrics;
s22: the metric metadata dictionary is designed according to the metric elements.
Further, the step S3 specifically includes:
s31: different measurement value calculation modes are designed according to different measurement elements;
s32: and calculating the measurement value according to the measurement element checked by the user on the setting interface, and storing the corresponding measurement value into a measurement metadata dictionary.
Example 1:
in an embodiment of the present disclosure, there is provided a model measurement method based on an extended Lustre language, in combination with fig. 1, the model measurement method including:
s1: and (3) according to the extended Lustre language design model structure tree, constructing a model by graphically dragging on a canvas of a modeling tool, and generating a corresponding model structure tree.
The S1 specifically comprises the following steps:
s11: designing a model structure tree according to the extended Lustre language, wherein the model structure tree comprises a tree structure of a model and tree node content;
the design of a common language expresses grammar rules by means of the Backus-Van (Backus Normal Form, BNF). In order to make the design of the model structure tree more fit to the expanded Lustre language, the model structure tree is designed from the hierarchy of the grammar structure, which contains four hierarchies from engineering, package, operators and state machine, respectively, the design of the model structure tree is explained below by explaining the design of the grammar.
(1) Engineering (program)
program::＝{{decls}}
decls::＝open path；
|package_decl
|type_block
|const_blcok
|sensor_block
|user_op_decl
The program part is an entry for the extended Lustre language program, and also corresponds to the root node of the tree in the model structure tree. The root node starts from the engineering package, package_decl in the decls section.
(2) Bags (package)
package_del::＝package[[visibi l i ty]]ID{{decls}}end
The child nodes that may be included in the engineering nodes of the model structure tree include packet nodes (package_del), type nodes (type_block), constant nodes (const_block), sensor nodes (sensor_block), and operator nodes (user_op_decl) as shown in the decls section in package_del. Wherein the type node, the constant node and the sensor node are used as leaf nodes, and no child node exists; the child nodes of the packet nodes are the same as the engineering packets, so that multi-level nesting is formed; the operator node continues to extend in accordance with the user op decl portion.
(3) Operator (Operator)
user_op_decl::＝op_kind interface_status ID[[s ize_decl]]params returns params{{where_decl}}[[spec_decl]]opt_body
opt_body::＝；
|equation；
|[[s ignal_block]]
[[local_block]]
let{{equat ion；}}tel[[；]]
equation::＝s imple_equation
|assert
|emission
|control_block return
control_block::＝state_machine
|clocked_block
The operator nodes of the model structure tree embody a core computing part for combining data flow and control flow of the extended Lustre language, and mainly comprise input ports (params), output ports (params), variables (local_block) and state machines (state_machine). The design of the model structure tree designs the params part before return as an Input port leaf node (Input) according to the semantics; the params part before return is designed as an Output port leaf node (Output); variable (local_block) is refined into Local Variable leaf nodes (Local Variable) and probe leaf nodes (probe); the state machine node continues to extend according to the state_machine according to the grammar.
(4) State Machine (State Machine)
state_machine::＝automaton[[ID]]{{state_decl}}+
state_decl::＝[[ini tial]][[final]]state ID
[[unless{{trans i t ion；}}+]]
data_def
[[unt i l{{trans it ion；}}
[[synchro[[actions]]fork；]]]]
data_def::＝equation；
The state machine node of the model structure tree mainly comprises a state child node, namely a state_decl part; the state child node contains a transition grandchild node, the trans it section. In summary, the designed model structure tree is shown in fig. 2.
S12: a model is constructed by graphically dragging on a canvas of a modeling tool, and a corresponding model structure tree is generated.
The model structure tree is constructed by graphically modeling with an OnModel tool, as shown in fig. 3.
S2: designing a predefined metric element for model complexity analysis, and simultaneously designing a metric metadata dictionary for storing metric information and metric values;
the step S2 specifically comprises the following steps:
s21: designing a predefined metric element, comprising: model object metrics, operator object metrics, package object metrics, and state machine object metrics;
to assist in quality assessment of software developers and testers, 16 metrics are designed from four aspects of model object metrics, operator object metrics, package object metrics, and state machine object metrics for complexity analysis of the model. The following table shows:
TABLE 1 model metrics and description
S22: the metric metadata dictionary is designed according to the metric elements.
The data dictionary is designed from both the engineering application type and the user readability, as shown in the following table.
S3: and traversing the model structure tree according to the metric elements checked by the user at the setting interface, calculating the metric values corresponding to the metric elements of each metric object, and storing the corresponding metric values into the metric element data dictionary.
The step S3 specifically comprises the following steps:
s31: different measurement value calculation modes are designed according to different measurement elements;
the calculation of the different metric values here falls into three categories: nested metric calculations for the same type of tree node, metric calculations for the tree node list, and maximum depth calculations for the nested state machine.
(1) The metric elements covered by the nested metric calculation method of the tree nodes of the same type are MBSE_M001-MBSE_M006, MBSE_M014 and MBSE_M016, and as the packets in the model object are nested, the metric values are calculated by adopting a depth-first recursion method, and the pseudo code is as follows:
(2) The metric element covered by the metric calculation method of the tree node list is MBSE_M007-MBSE_M0013, and only the length of the child node list is needed to be calculated.
(3) The metric covered by the maximum depth calculation method of the nested state machine is MBSE_M015, and the problem can be abstracted into the maximum depth problem of an N-ary tree, so that the calculation is performed by adopting a common depth-first recursion method, and the pseudo code is as follows:
s32: and calculating the measurement value according to the measurement element checked by the user on the setting interface, and storing the corresponding measurement value into a measurement metadata dictionary.
The corresponding metrology objects and metrology elements are checked by the OnModel tool setup interface, as shown in FIG. 4.
S4: traversing the data dictionary, displaying the effective data items on the front end through a visualized chart, and locally storing the measurement file.
After the model metric calculation is performed, the visual chart of the data dictionary is shown in fig. 5, and only a part of the chart is shown because the chart is too long.
The invention provides a model measurement method based on an extended Lustre language, which has at least one or a part of the following beneficial effects:
(1) According to the extended Lustre language, a model structure tree is designed, and a model structure tree corresponding to engineering can be generated through visual modeling;
(2) Predefined metric elements are designed, including four aspects of model object metrics, operator object metrics, package object metrics, and state machine object metrics, and a metric metadata dictionary is designed based on the metric elements.
(3) Different measurement value calculation modes are designed according to different measurement elements.
(4) The model measurement module based on the extended Lustre language is successfully added in the OnModel modeling platform, and the measurement result is displayed through a table.
The model measurement is carried out based on the extended Lustre language structure, the method designs a model structure tree and predefined measurement elements according to the extended Lustre language, designs different measurement value calculation modes aiming at different measurement elements, and finally realizes the application of model measurement in an OnModel modeling platform and displays measurement results.
The foregoing is merely a preferred embodiment of the present invention, and it should be noted that modifications and variations could be made by those skilled in the art without departing from the technical principles of the present invention, and such modifications and variations should also be regarded as being within the scope of the invention.
Claims (4)
1. A model measurement method based on an extended Lustre language, the method comprising the steps of:
s1: according to the extended Lustre language design model structure tree, a model is constructed by graphically dragging on canvas of a modeling tool, and a corresponding model structure tree is generated at the same time;
s2: designing a predefined metric element for model complexity analysis, and simultaneously designing a metric metadata dictionary for storing metric information and metric values;
s3: calculating the corresponding measurement values of different measurement elements according to the measurement elements checked by the user on the setting interface, and storing the corresponding measurement values into a measurement metadata dictionary;
s4: traversing the data dictionary, displaying the effective data items at the front end by using a visualized chart, and locally storing a measurement file;
the step S1 specifically includes:
s11: designing a model structure tree according to the extended Lustre language, wherein the model structure tree comprises a tree structure of a model and tree node content;
s12: constructing a model by graphically dragging on canvas of a modeling tool, and generating a corresponding model structure tree;
the step S11 specifically includes: through the Barceis normal expression grammar rule, a model structure tree is designed from the hierarchy of a grammar structure, and the grammar comprises four hierarchies of engineering, package, operators and a state machine;
the engineering program part is an entry for expanding the Lustre language program, and corresponds to a root node of the tree in the model structure tree;
the decls part in the child node package_del of the engineering node of the model structure tree comprises: packet node package_del, type node type_block, constant node const_block, sensor node sensor_block, and operator node user_op_decl; wherein the type node, the constant node and the sensor node are used as leaf nodes, and no child node exists; sub-nodes of the packet nodes form multi-level nesting; the operator node continues to extend according to the user_op_decl portion;
the operator node embodies a core computing part of the combination of data flow and control flow of the extended Lustre language, comprising: input port params, output port params, variable local_block and state machine state_machine; variable local_block is refined into a Local Variable leaf node Local Variable and a probe leaf node probe; the state machine node continues to extend according to the state_machine according to the grammar;
the state machine node includes: a state child node, namely a state_decl part; the state child node contains a transition child node, i.e., a transition portion;
the step S2 specifically includes:
s21: designing predefined metric elements, including four aspects of model object metrics, operator object metrics, package object metrics and state machine object metrics;
s22: designing a metric metadata dictionary according to the metric elements;
the step S21 specifically includes: designing 16 metrics from four aspects of model object metrics, operator object metrics, package object metrics, and state machine object metrics for complexity analysis of the model, comprising: MBSE_M001-MBSE_M016, wherein the metric elements of the model object metrics comprise: MBSE_M001-MBSE_M006 are respectively: total number of operators, total number of types, total number of constants, total number of sensors, total number of packages, and total number of canvas; the metric element of the packet object metric comprises: MBSE_M007 is: number of operators; the metric element of the operator object metric includes: MBSE_M008-MBSE_M013 are respectively: the number of input ports, the number of output ports, the number of probes, the number of local variables, the number of signals and the number of user operator instances; the metric element of the state machine object metric comprises: MBSE_M014-MBSE_M016 are: the number of states, the depth of the state machine, and the number of transitions;
the fields of the metric metadata dictionary of step S22 include: project, configuration, date, category _name, metric_id, metric_ name, description, min, average, max, path, value.
2. The model measurement method based on the extended Lustre language according to claim 1, wherein the step S3 specifically comprises:
s31: different measurement value calculation modes are designed according to different measurement elements;
s32: and calculating the measurement value according to the measurement element checked by the user on the setting interface, and storing the corresponding measurement value into a measurement metadata dictionary.
3. The model measurement method based on the extended Lustre language according to claim 2, wherein in step S31, the measurement value calculation method includes: nested metric calculations for the same type of tree node, metric calculations for the tree node list, and maximum depth calculations for the nested state machine.
4. The model metric method based on the extended Lustre language as claimed in claim 3, wherein the metric elements covered by the nested metric computation of the same type tree nodes are MBSE_M001-MBSE_M006, MBSE_M014 and MBSE_M016, and the metric values are computed by adopting a depth-first recursive method because the packets in the model object have packet nesting; the metric element covered by the metric calculation of the tree node list is MBSE_M007-MBSE_M0013, and the length of the child node list is calculated; the metric covered by the maximum depth calculation of the nested state machine is MBSE_M015, and the calculation is performed by adopting a depth-first recursion method.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310185399.4A CN116149624B (en) | 2023-02-21 | 2023-02-21 | Model measurement method based on extended Lustre language |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310185399.4A CN116149624B (en) | 2023-02-21 | 2023-02-21 | Model measurement method based on extended Lustre language |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN116149624A CN116149624A (en) | 2023-05-23 |
| CN116149624B true CN116149624B (en) | 2023-09-26 |
Family
ID=86358089
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202310185399.4A Active CN116149624B (en) | 2023-02-21 | 2023-02-21 | Model measurement method based on extended Lustre language |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116149624B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116150005B (en) * | 2023-01-16 | 2023-11-28 | 北京计算机技术及应用研究所 | Model form verification method based on extended Lustre language |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111338972A (en) * | 2020-03-30 | 2020-06-26 | 北京计算机技术及应用研究所 | Machine learning-based software defect and complexity incidence relation analysis method |
| CN111880784A (en) * | 2020-08-06 | 2020-11-03 | 中国人民解放军国防大学联合作战学院 | SIMSCRIPT language-oriented discrete event simulation graphical modeling method |
| CN114840196A (en) * | 2022-07-06 | 2022-08-02 | 中国汽车技术研究中心有限公司 | Modelica language model processing method, device and storage medium |
| CN115619264A (en) * | 2022-10-12 | 2023-01-17 | 中国航空综合技术研究所 | Aviation airborne software quality evaluation method based on software full life cycle |
Family Cites Families (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| DE102017212581A1 (en) * | 2017-07-21 | 2019-01-24 | Siemens Aktiengesellschaft | A method for dynamically expanding a domain-specific language of a graphical modeling tool |
| US10838717B2 (en) * | 2018-02-16 | 2020-11-17 | Accenture Global Solutions Limited | Representing a software application using extended reality |
-
2023
- 2023-02-21 CN CN202310185399.4A patent/CN116149624B/en active Active
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111338972A (en) * | 2020-03-30 | 2020-06-26 | 北京计算机技术及应用研究所 | Machine learning-based software defect and complexity incidence relation analysis method |
| CN111880784A (en) * | 2020-08-06 | 2020-11-03 | 中国人民解放军国防大学联合作战学院 | SIMSCRIPT language-oriented discrete event simulation graphical modeling method |
| CN114840196A (en) * | 2022-07-06 | 2022-08-02 | 中国汽车技术研究中心有限公司 | Modelica language model processing method, device and storage medium |
| CN115619264A (en) * | 2022-10-12 | 2023-01-17 | 中国航空综合技术研究所 | Aviation airborne software quality evaluation method based on software full life cycle |
Also Published As
| Publication number | Publication date |
|---|---|
| CN116149624A (en) | 2023-05-23 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US9639332B2 (en) | Applying coding standards in graphical programming environments | |
| US9612806B2 (en) | Verification of computer-executable code generated from a model | |
| Sabetzadeh et al. | Consistency checking of conceptual models via model merging | |
| US6965887B2 (en) | Rule processing methods for automating a decision and assessing satisfiability of rule-based decision diagrams | |
| US7587379B2 (en) | Method and system for capturing business rules for automated decision procession | |
| US20120254830A1 (en) | Verification of computer-executable code generated from a model | |
| US20070150429A1 (en) | Rule processing system | |
| US20090248385A1 (en) | Simplified data signal support for diagramming environment languages | |
| CN116149624B (en) | Model measurement method based on extended Lustre language | |
| Olszewska et al. | Tailoring complexity metrics for Simulink models | |
| Wang et al. | Change propagation analysis for system modeling using Semantic Web technology | |
| Voss et al. | Graph transformation in engineering design: An overview of the last decade | |
| Amálio | Generative frameworks for rigorous model-driven development | |
| Muise et al. | Fast d-DNNF Compilation with sharpSAT | |
| CN111581815B (en) | XML-based process model ontology construction method | |
| Miceli et al. | A metric based technique for design flaws detection and correction | |
| EP2718821B1 (en) | Verification of computer-executable code generated from a model | |
| Padawitz | Algebraic Model Checking | |
| Semeráth | Formal Validation and Model Generation for Domain-Specific Languages by Logic Solvers | |
| Kohler et al. | Formal aspects for semantic service modeling based on high-level petri nets | |
| Suresh | Model Analytics for ASML’s Data and Control Modeling Languages | |
| CN116382653A (en) | Constraint solving method of symbol execution system for vulnerability detection | |
| Ksystra et al. | On verifying reactive rules using rewriting logic | |
| Wang et al. | Process-Product-Resource based Requirement Model for Discrete Manufacturing Systems | |
| Kulkarnia et al. | A domain-specific language for model composition and verification of multidisciplinary models |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |