Value Modifiers for Flexible Constraint Verification in MATLAB
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional computing environments require users to develop code in programming languages like C++, C, or Fortran, which can be inefficient for tasks in disciplines such as mathematics, science, and engineering, and lack flexible testing mechanisms for code validation against constraints.
Innovation Solution
A technical computing environment (TCE) using a dynamically-typed programming language like MATLAB, which includes a testing component that utilizes value modifiers to customize the presentation of tested values to constraints, allowing for flexible verification of code functionality through modifiers such as AnyElementOf, enabling determination of whether any element of an array satisfies a constraint.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If conventional programming languages (C++, C, Fortran) are used for code development, then code can be executed, but the development efficiency and ease of use are reduced
Solution Approach 1:
The patent changes the fundamental parameters of the programming language by implementing dynamic typing instead of static typing. This allows variables to change their data types during execution, enabling more flexible and intuitive code writing that closely mirrors mathematical notation, thereby improving ease of operation and development efficiency.
Solution Approach 2:
The patent replaces the mechanical/conventional programming approach with a more abstract mathematical notation-based system. The testing framework substitutes traditional rigid constraint checking with a more flexible modifier-based verification system that can adapt to different data structures and validation requirements.
2Adaptability or versatility
If conventional testing mechanisms are used, then code can be validated, but the flexibility to test against complex constraints is limited
Solution Approach 1:
The patent segments the constraint verification process into distinct components: modifiers that define what aspects of the output to test, constraints that specify the validation rules, and a testing framework that combines them. This segmentation allows flexible combination of modifiers and constraints to handle complex verification scenarios without increasing overall system complexity.
Solution Approach 2:
The patent introduces modifiers as intermediary objects between the code output and the constraints. Modifiers act as mediators that transform and prepare the output for constraint verification, enabling flexible testing of complex data structures like arrays and matrices against various constraints without direct complexity in the constraint system itself.
3Reliability
If static typing is used, then type safety is ensured, but the runtime performance and flexibility are reduced
Solution Approach 1:
The patent implements dynamic typing that allows variables to change their data types during runtime execution. This dynamic approach maintains type safety through runtime type checking while enabling greater flexibility and optimized performance by allowing the system to adapt to different data types as needed, rather than being constrained by fixed compile-time type declarations.
Data Source
AI summary
A device receives code generated via a technical computing environment (TCE), the code including a value to be tested, and receives a value modifier, a test case, and a constraint. The value modifier customizes a manner in which the value of the code is presented to the constraint for verification. The device also generates a test based on the value modifier, the test case, and the constraint, performs the test on the value of the code to generate a result, and outputs or stores the result.