CN111930373A - Method and device for efficiently creating quantitative transaction strategy based on flow chart - Google Patents
Method and device for efficiently creating quantitative transaction strategy based on flow chart Download PDFInfo
- Publication number
- CN111930373A CN111930373A CN202010820312.2A CN202010820312A CN111930373A CN 111930373 A CN111930373 A CN 111930373A CN 202010820312 A CN202010820312 A CN 202010820312A CN 111930373 A CN111930373 A CN 111930373A
- Authority
- CN
- China
- Prior art keywords
- strategy
- logic
- policy
- callback
- callback function
- 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.)
- Pending
Links
Images
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/34—Graphical or visual programming
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The invention discloses a method and a device for efficiently creating a quantitative transaction strategy based on a flow chart, wherein the method comprises the following steps: step S1, receiving a strategy creating request, automatically generating a highly packaged strategy code template, combining and serially connecting logic flows in the strategy callback function according to the operation of a user aiming at the packaged strategy callback function, and linking each logic flow and judgment through a conditional statement and a recursive statement to finally realize the specific logic of the callback function; step S2, when receiving the conversion request, converting the graphic strategy logic into strategy code completely by analyzing the logic flow and the connection statement; and step S3, transmitting the strategy file converted into the strategy code to a local test platform or an on-line test platform to obtain a test result, thereby realizing the establishment of the whole quantitative transaction strategy.
Description
Technical Field
The invention relates to the technical field of software development, in particular to a method and a device for efficiently creating a quantitative transaction strategy based on a flow chart.
Background
The cross-domain of software technology and business is a cross-domain of programmatic trading, which generally requires related developers to have a certain coding basis and a sufficiently deep understanding of business logic. At present, although a part of the code learning cost can be reduced by encapsulating a common API, a trader or a quantization engineer must encounter the problem of basic coding in the process of writing a strategy, which leads to logic problems and syntax errors in strategy writing, and consumes a large amount of time for learning and processing various errors encountered in the coding process, thereby increasing the learning cost and consuming a large amount of research and development efforts.
Therefore, in order to help traders or quantitative engineers save time in policy development and reduce learning cost and simultaneously enable policy creation and testing to be performed quickly, it is actually necessary to create an efficient interface-based user-friendly policy creation method to reduce difficulty in learning and policy writing threshold, so that more users can participate in the method, and traders and quantitative engineers are also prompted to concentrate on implementation of trading logic.
Disclosure of Invention
In order to overcome the defects of the prior art, the present invention provides a method and an apparatus for efficiently creating a quantitative trading strategy based on a flowchart, so that a trader or a quantitative engineer can quickly and easily pay attention to the core logic of the strategy, the threshold of constructing the strategy is lowered, and the benign development of a programmed trading market is promoted.
To achieve the above object, the present invention provides a method for efficiently creating a quantitative transaction policy based on a flowchart, comprising the following steps:
step S1, receiving a strategy creating request, automatically generating a highly packaged strategy code template, combining and serially connecting logic flows in the strategy callback function according to the operation of a user on a graphical interface aiming at the packaged strategy callback function, and linking each logic flow and judgment through a conditional statement and a recursive statement to realize the specific logic of each strategy callback function;
step S2, when receiving the conversion request, converting the graphic strategy logic into strategy code completely by analyzing the logic flow and the connection statement;
and step S3, transmitting the strategy file converted into the strategy code to a local test platform or an on-line test platform to obtain a test result, thereby realizing the establishment of the whole quantitative transaction strategy.
Preferably, the step S1 further includes:
step S100, receiving a strategy creation request, and automatically generating a highly packaged strategy code template;
and S101, selecting the needed strategy callback functions according to requirements, and filling strategy logics in the callback functions one by using a graphical interface aiming at each needed callback function.
Preferably, in step S101, logic flows are combined and serially connected in each policy callback function in a dragging manner, and the specific logic flows and decisions of each policy callback function are implemented by linking each logic flow with a conditional statement and a recursive statement
Preferably, after step S101, the method further includes the following steps:
after each strategy callback function strategy logic is edited, whether each callback function logic contains syntax errors is verified.
Preferably, the policy callback function refers to a class of Strategy.
Preferably, the policy callback function includes, but is not limited to, a market condition callback (on _ receive _ marker), a received K-line data callback (on _ receive _ ohlc), a market transaction callback (on _ receive _ transaction), an order confirmation callback (on _ submit _ accepted), an order rejection callback (on _ submit _ rejected), a cancel single success callback (on _ order _ cancelled), a cancel single rejection callback (on _ cancel _ rejected), an order complete transaction callback (on _ order _ executed), an order partial transaction callback (on _ order _ partial _ executed), and a heartbeat timing callback (on _ receive _ heart).
Preferably, in step S2, after the submitted graphical policy template is obtained, the graphical policy logic is converted into a retest executable policy code according to the programming syntax by parsing the logic flow and the join statement, and different policy file versions are generated according to the selected programming language, so as to adapt to the retest versions in different programming language environments.
In order to achieve the above object, the present invention further provides an apparatus for efficiently creating a quantitative transaction policy based on a flowchart, including:
the strategy logic implementation module is used for receiving a strategy creation request, automatically generating a highly packaged strategy code template, combining and serially connecting logic flows in the strategy callback function according to the operation of a user on a graphical interface aiming at the packaged strategy callback function, linking each logic flow and judgment through a conditional statement and a recursive statement, and finally implementing the specific logic of the strategy callback function;
the conversion module is used for completely converting the graphical strategy logic into the strategy code by analyzing the logic flow and the connection statement when receiving the conversion request;
and the return test module is used for transmitting the strategy file converted into the strategy code to a local return test platform or an online return test platform to obtain a return test result, so that the establishment of the whole quantitative transaction strategy is realized.
Preferably, the policy logic implementation module further comprises:
and the strategy code template generating unit is used for receiving the strategy creating request and automatically generating the highly packaged strategy code template.
And the policy logic filling unit is used for selecting the required policy callback functions according to requirements and filling the policy logic in the policy callback functions one by using a graphical interface aiming at each required callback function.
Preferably, the policy logic implementation module further comprises:
and the checking unit is used for checking whether grammar errors are contained in the strategy callback function logics after the strategy callback function strategy logics are edited.
Compared with the prior art, the method for efficiently creating the quantitative transaction strategy based on the flow chart completes strategy design by realizing strategy logics in each strategy callback function one by one, supports a graphical module dragging mode to complete specific logics in each strategy callback function, simultaneously combines the packaged retest logics including data reading logics, data conversion logics, flow control logics, matching logics and strategy logics, enables quantitative traders and users to easily define strategy flows and logic links and support code editing in each callback function at the same time only through graphical interfaces, finally uniformly converts the strategy flows and the codes into readable scripts through background conversion logics to complete retest editing, and greatly improves the efficiency of strategy development and iteration.
Drawings
FIG. 1 is a flow chart illustrating the steps of a method for efficiently creating a quantitative transaction strategy based on the flow chart of the present invention;
FIG. 2 is a schematic interface diagram of a newly created policy template in an embodiment of the present invention;
FIG. 3 is a schematic interface diagram of policy logic for populating a policy callback function in an embodiment of the present invention;
FIG. 4 is a flow chart of syntax checking in an embodiment of the present invention;
FIG. 5 is a system architecture diagram of an apparatus for efficiently creating a quantitative transaction policy based on a flowchart in accordance with the present invention;
FIG. 6 is a flowchart illustrating an implementation of efficiently creating a quantitative transaction policy based on the flowchart in an embodiment of the present invention;
fig. 7-8 are schematic diagrams of a process of populating policy logic of a policy callback function according to an embodiment of the present invention.
Detailed Description
Other advantages and capabilities of the present invention will be readily apparent to those skilled in the art from the present disclosure by describing the embodiments of the present invention with specific embodiments thereof in conjunction with the accompanying drawings. The invention is capable of other and different embodiments and its several details are capable of modification in various other respects, all without departing from the spirit and scope of the present invention.
FIG. 1 is a flow chart illustrating the steps of a method for efficiently creating a quantitative transaction policy based on the flow chart. As shown in FIG. 1, the method for efficiently creating a quantitative transaction policy based on a flowchart of the present invention comprises the following steps:
and step S1, receiving a strategy creating request, automatically generating a highly packaged strategy code template, combining and serially connecting logic flows in the strategy callback function according to the operation of a user aiming at the packaged strategy callback function, and linking each logic flow and judgment through a conditional statement and a recursive statement to finally realize the specific logic of the callback function. The operation of the user refers to a drag and drag operation on the graphical interface, and the content of the drag and drag includes but is not limited to: the flow step diagrams, the conditional statements/recursive statements, the data structures and the defined related backtesting APIs are different in operations required for different dragged contents, for example, if the dragged flow is a flow diagram, sequential logic of each flow diagram needs to be connected, if the dragged flow is a conditional statement or a recursive statement, the contents in the statements need to be defined, and if the dragged flow is a data structure, data of that type needs to be selected, and other APIs.
Specifically, step S1 further includes:
and step S100, receiving a strategy creation request, and automatically generating a highly packaged strategy code template.
That is, after the user clicks the "new policy template", the policy template appears on the graphical interface, the left side of the graphical interface is the "code edit box", the middle is the "policy flow chart", and the right side is the "parameter definition", as shown in fig. 2, when the user uses the middle "policy flow chart" to fill the policy logic through the flow chart, the left code is updated in real time according to the user operation flow chart.
And S101, selecting the needed strategy callback functions according to requirements, and filling strategy logics in the callback functions one by one according to the graphical interface aiming at each needed callback function.
That is, a plurality of encapsulated policy callback functions are preset in the system, and after a user selects a newly-created policy template to automatically generate a highly encapsulated policy code template, the user can select a required policy callback function according to requirements. Although the callback function structure is packaged, which logic needs to be processed in each callback function needs to be further defined, different policy logics can be completely different in the same callback function, therefore, in the invention, aiming at the packaged policy callback functions, a user can combine and serially connect logic flows in a graphical interface in a dragging mode in each policy callback function, and link each logic flow and judgment through a conditional statement and a recursive statement to realize the specific logic of callback function, specifically, firstly, selecting the callback function needing to be edited, after selecting the callback function needing to be edited, performing dragging operation editing in each callback function, namely, realizing the policy logic of the callback function in each callback function through a dragging flow chart component, a conditional statement component, a recursive statement component, an API component and the like, the contents of the dragging include, but are not limited to, a flow step diagram, a conditional statement/recursive statement, a data structure and a defined related callback API, when one callback function is well defined, other callback functions can be defined, and when the logic of all the required callback functions is realized, the logic editing of the whole strategy is completed. That is, in the present invention, a user may further complete a policy logic by way of a graphical interface, and a policy logic flowchart may be automatically generated while completing a policy, and the policy logic implementation is visually demonstrated, as shown in fig. 3, the policy logic flowchart is a policy flowchart of a specific logic of an on _ receive _ markettdata callback function implemented by a dragging operation, and the two parts are mapping relationships in a code input box on the left side, and if there is a modification in the code input box on the left side, the modification in the code input box on the left side will affect a policy flowchart in the middle, and if there is a modification in the code input box on the left side, the modification in the code edit box on the left side will also affect a code in the code edit box on the left side, and the callback function definition is completed after filling. The policy callback functions have no logic relation and are completely driven by external events.
In the specific embodiment of the present invention, the encapsulated policy callback function refers to a class of stratgy, and implements functions of a market condition callback (on _ receive _ maker), a received K-line data callback (on _ receive _ ohlc), a market transaction callback (on _ receive _ transaction), an order confirmation callback (on _ submit _ accepted), an order rejection callback (on _ submit _ rejected), a withdrawal success callback (on _ order _ rejected), a withdrawal rejection callback (on _ cancel _ rejected), an order complete transaction (on _ order _ executed), an order partial transaction callback (on _ order _ partial _ executed), and a heartbeat timing callback (on _ accept _ heartbeat _ critical), and the policy terminal user implements a logic function according to requirements in the encapsulated policy functions.
Since the policy logic is executed synchronously in each callback function, the execution sequence of the defined flow chart is equal to the execution sequence of the defined code. In each flow module (including flow step diagram, conditional statement recursion statement, data structure and defined related backtesting API), code block logic can be defined, and the middle operation and implementation of each code block are in the order from top to bottom. The whole strategy logic writing can be completed by filling API components and conditional statements which need to be executed by a user, wherein the flow module refers to a flow step diagram, a conditional statement recursive statement, a data structure and a defined related backtesting API.
Preferably, after step S101, the method further includes the following steps:
after the strategy callback function strategy logics are realized, whether grammar errors exist in the callback function logics is checked.
In the invention, the grammar check is different according to different programming statements used by a background, generally, the grammar error of the strategy logic is checked according to the used programming language, and the error prompt of response is given in real time. Take python or java as an example, for example:
the integer a is defined to be 0,
defined in python:
a is 0 (grammar check is correct)
But is defined in java:
a is 0 (grammar check is error)
In the embodiment of the present invention, when the user completes all edits and clicks "output to file", a complete verification logic of the entire flow is triggered once, and a corresponding code file is formed after the verification logic is completed, and an implementation flow chart thereof is shown in fig. 4. In the invention, the check belongs to the check of a background, and the current mode is to judge whether the code grammar rule check written by a user passes or not, if so, the code passing the grammar check is converted into a graph in a mapping mode. This is similar to the checking in the IDE encoding environment, except that the code is finally represented in a possible graph (in the form of an internal rule mapping), which is not described in detail herein.
Step S2, when receiving the conversion request, completely converting the graphical policy logic into a policy code by parsing the logic flow and the join statement.
Specifically, when the end user finally completes all the policy graphic creation requests and submits, the transcoding step is entered. After a background of the system receives a graphical strategy template submitted by a user, parameters (graphical strategy logic) acquired from the foreground are converted into strategy codes which can be tested back and run according to programming syntax through analyzing a logic flow and a connection statement, and different strategy file versions are generated according to a selected programming language so as to adapt to the testing back versions in different programming language environments.
And step S3, transmitting the strategy file converted into the strategy code to a local test platform or an on-line test platform, and carrying out test observation results to complete the establishment of the whole quantitative transaction strategy.
After the code conversion is completed, a user can obtain a strategy file of a corresponding code mode, the strategy file subjected to code conversion can be uploaded to a local return test platform or an online return test platform in a manual or automatic mode, a return test observation result is carried out, and finally the establishment of the whole quantitative transaction strategy is completed.
FIG. 5 is a system architecture diagram of an apparatus for efficiently creating a quantitative transaction policy based on a flowchart according to the present invention. As shown in fig. 5, an apparatus for efficiently creating a quantitative transaction policy based on a flowchart according to the present invention includes:
the policy logic implementation module 501 is configured to receive a policy creation request, automatically generate a highly encapsulated policy code template, combine and serially connect logic flows in the policy callback function according to the operation of a user for the encapsulated policy callback function, join each logic flow and decision through a conditional statement and a recursive statement, and finally implement specific logic of the callback function. The operation of the user refers to a drag and drag operation on the graphical interface, and the content of the drag and drag includes but is not limited to: the flow step diagrams, the conditional statements/recursive statements, the data structures and the defined related backtesting API need different operations according to the different dragged contents, for example, if the dragged flow diagram is the flow diagram, the sequential logic of each flow diagram needs to be connected, if the dragged flow diagram is the conditional statement or the recursive statement, the contents in the statements need to be defined, if the dragged flow diagram is the conditional statement or the recursive statement, the data of the type needs to be selected and used, and other API need to be defined
Specifically, the policy logic implementation module 501 further includes:
and the strategy code template generating unit is used for receiving the strategy creating request and automatically generating the highly packaged strategy code template.
And the policy logic filling unit is used for selecting the needed policy callback functions according to the requirements and filling the policy logic in the callback functions one by one according to the graphical interface aiming at each needed callback function.
That is, a plurality of encapsulated policy callback functions are preset in the system, and after a user selects a newly-created policy template to automatically generate a highly encapsulated policy code template, the user can select a required policy callback function according to requirements. Although the callback function structure is packaged, which logic needs to be processed in each callback function needs to be further defined, different policy logics can be completely different in the same callback function, therefore, in the invention, aiming at the packaged policy callback functions, a user can combine and serially connect logic flows in a graphical interface in a dragging mode in each policy callback function, and link each logic flow and judgment through a conditional statement and a recursive statement to realize the specific logic of callback function, specifically, firstly, selecting the callback function needing to be edited, after selecting the callback function needing to be edited, performing dragging operation editing in each callback function, namely, realizing the policy logic of the callback function in each callback function through a dragging flow chart component, a conditional statement component, a recursive statement component, an API component and the like, the contents of the dragging include, but are not limited to, a flow step diagram, a conditional statement/recursive statement, a data structure and a defined related callback API, when one callback function is well defined, other callback functions can be defined, and when the logic of all the required callback functions is realized, the logic editing of the whole strategy is completed. That is, in the present invention, a user may further complete a policy logic by way of a graphical interface, and a policy logic flowchart is automatically generated while completing a policy, and the implementation of the policy logic is visually demonstrated, as shown in fig. 3, a code input box on the left side may be manually input by the user, or dragged by an editing box in the middle, where the two parts are mapping relationships, and if there is a modification in the code input box on the left side, the modification in the code input box on the left side will affect a policy flowchart in the middle, and if there is a modification in the policy flowchart in the middle, the modification in the code editing box on the left side will also affect a code in the code editing box on the left side, and the callback function. The policy callback functions have no logic relation and are completely driven by external events.
In the specific embodiment of the present invention, the encapsulated policy callback function refers to a class of stratgy, and implements functions of a market condition callback (on _ receive _ maker), a received K-line data callback (on _ receive _ ohlc), a market transaction callback (on _ receive _ transaction), an order confirmation callback (on _ submit _ accepted), an order rejection callback (on _ submit _ rejected), a withdrawal success callback (on _ order _ rejected), a withdrawal rejection callback (on _ cancel _ rejected), an order complete transaction (on _ order _ executed), an order partial transaction callback (on _ order _ partial _ executed), and a heartbeat timing callback (on _ accept _ heartbeat _ critical), and the policy terminal user implements a logic function according to requirements in the encapsulated policy functions.
Preferably, the policy logic implementation module 501 further comprises:
and the checking unit is used for checking whether grammar errors are contained in the callback function logics after the strategy callback function strategy logics are edited.
The conversion module 502 is configured to, when receiving a conversion request, completely convert the graphical policy logic into a policy code by parsing the logic flow and the join statement.
Specifically, when the end user finally completes all the policy graphic creation requests and submits, the transcoding step is entered. After a background of the system receives a graphical strategy template submitted by a user, parameters (graphical strategy logic) acquired from the foreground are converted into strategy codes which can be tested back and run according to programming syntax through analyzing a logic flow and a connection statement, different strategy file versions are generated according to a selected programming language, and the strategy codes are suitable for testing back versions in different programming language environments.
And the retest module 503 is configured to transmit the policy file converted into the policy code to a local retest platform or an online retest platform, and perform retest observation to complete creation of the entire quantitative transaction policy.
After the code conversion is completed, a user can obtain a strategy file of a corresponding code mode, the strategy file subjected to code conversion can be uploaded to a local return test platform or an online return test platform in a manual or automatic mode, a return test observation result is carried out, and finally the establishment of the whole quantitative transaction strategy is completed.
Examples
As shown in fig. 6, in the present embodiment, the process of creating the quantitative trading strategy is as follows:
step 1, the user selects a new strategy template, and the system automatically generates a highly encapsulated strategy code template, as shown in fig. 2.
Step 2, the user selects a required callback function according to the purpose of the strategy to be written, for example, as shown in fig. 7, drags a "MarkData" market quotation input module to a central flow chart edit box, and selects a contract with the input market quotation being "Symbol";
step 3, the user fills policy logic in the callback function one by using a graphical interface for each required callback function, for example, dragging a "callback test API" module, selecting the APIs "get _ best _ bid _ price" and "get _ best _ offer _ price" to a middle flowchart edit box and butting the two flowcharts to the arrow head end, defining two input variables as "best _ bid" and "best _ ask" respectively, and defining that the two APIs respectively take the value of "Symbol", as shown in fig. 8; by analogy, dragging the "conditional statement" module and the "API order placement" statement module, etc., and defining the condition, order placement elements, etc., to obtain the result shown in fig. 3.
And 4, after the strategy logic of each callback function is edited, the system checks whether grammar errors are contained in the logic of each callback function.
And 5, after the verification is finished, the system completely converts the graphical strategy logic into a strategy code, so that the editing of the transaction strategy is finished.
After the method is used, the trader is quantized only to write the part 1 of the strategy logic, and the code amount is reduced by at least 80%.
Generally speaking, the time spent by a debugger is proportional to the amount of code, and assuming that 80% of the amount of code is reduced, it is guaranteed that 80% of the time spent for debugging the entire flow is reduced. The time for writing all the logic originally is about one week, the time can be shortened to be within 1 day after the method is used, the threshold of using the user is greatly reduced by the graphical interface and the dragging module, the learning cost is reduced, and the code editing can be supported to completely support the use scenes and the use habits of each user.
To sum up, the method for efficiently creating a quantitative transaction policy based on a flow chart completes policy design by realizing policy logic in each policy callback function one by one, supports a graphical module dragging mode to complete specific logic in each policy callback function, and combines the packaged retest logic including data reading logic, data conversion logic, flow control logic, matching logic and policy logic, so that quantitative traders and users can easily define the link between policy flows and logic only through a graphical interface, simultaneously supports code editing in each policy callback function, and finally uniformly converts the policy flows and the codes into readable program scripts through background conversion logic to complete retest editing, so that the traders only need to care about what is done after a market event occurs, instead of what needs to be done to process the market events, the parts outside the business logic can be no longer concerned, and the efficiency of strategy development and iteration is greatly improved.
The foregoing embodiments are merely illustrative of the principles and utilities of the present invention and are not intended to limit the invention. Modifications and variations can be made to the above-described embodiments by those skilled in the art without departing from the spirit and scope of the present invention. Therefore, the scope of the invention should be determined from the following claims.
Claims (10)
1. A method for efficiently creating a quantitative transaction strategy based on a flow chart comprises the following steps:
step S1, receiving a strategy creating request, automatically generating a highly packaged strategy code template, combining and serially connecting logic flows in the strategy callback function according to the operation of a user on a graphical interface aiming at the packaged strategy callback function, and linking each logic flow and judgment through a conditional statement and a recursive statement to realize the specific logic of each strategy callback function;
step S2, when receiving the conversion request, converting the graphic strategy logic into strategy code completely by analyzing the logic flow and the connection statement;
and step S3, transmitting the strategy file converted into the strategy code to a local test platform or an on-line test platform to obtain a test result, thereby realizing the establishment of the whole quantitative transaction strategy.
2. The method for efficiently creating a quantitative transaction strategy based on flow charts of claim 1, wherein the step S1 further comprises:
step S100, receiving a strategy creation request, and automatically generating a highly packaged strategy code template;
and S101, selecting the needed strategy callback functions according to requirements, and filling strategy logics in the callback functions one by using a graphical interface aiming at each needed callback function.
3. The method for efficiently creating a quantitative transaction strategy based on a flowchart of claim 2, wherein: in step S101, logic flows of the flow modules are combined and connected in series in a dragging manner inside each policy callback function, and the specific logic of each policy callback function is implemented by linking each logic flow and determination through a conditional statement and a recursive statement.
4. The method for efficiently creating a quantitative transaction strategy based on flow chart as claimed in claim 3, wherein after step S101, the method further comprises the following steps:
after each strategy callback function strategy logic is edited, whether each callback function logic contains syntax errors is verified.
5. The method for efficiently creating a quantitative transaction policy based on a flowchart of claim 4, wherein the policy callback function refers to a class of Strategy.
6. The method of claim 5, wherein the policy callback function includes, but is not limited to, a market status callback (on _ receive _ marktdata), a received K-line data callback (on _ receive _ ohlc), a market transaction callback (on _ receive _ transaction), an order confirmation callback (on _ submit _ accepted), an order rejection callback (on _ submit _ rejected), an order partial transaction callback (on _ order _ accepted), a heartbeat timing callback (on _ receive _ heartbeat _ rejection).
7. The method for efficiently creating a quantitative transaction strategy based on a flowchart of claim 1, wherein: in step S2, after the submitted graphical policy template is obtained, the graphical policy logic is converted into a retest executable policy code according to the programming syntax by parsing the logic flow and the join statement, and different policy file versions are generated according to the selected programming language, so as to adapt to retest versions in different programming language environments.
8. An apparatus for efficiently creating a quantitative transaction policy based on a flowchart, comprising:
the strategy logic implementation module is used for receiving a strategy creation request, automatically generating a highly packaged strategy code template, combining and serially connecting logic flows in the strategy callback function according to the operation of a user on a graphical interface aiming at the packaged strategy callback function, linking each logic flow and judgment through a conditional statement and a recursive statement, and finally implementing the specific logic of the strategy callback function;
the conversion module is used for completely converting the graphical strategy logic into the strategy code by analyzing the logic flow and the connection statement when receiving the conversion request;
and the return test module is used for transmitting the strategy file converted into the strategy code to a local return test platform or an online return test platform to obtain a return test result, so that the establishment of the whole quantitative transaction strategy is realized.
9. The apparatus for efficiently creating a quantitative transaction policy based on a flowchart of claim 8, wherein the policy logic implementation module further comprises:
and the strategy code template generating unit is used for receiving the strategy creating request and automatically generating the highly packaged strategy code template.
And the policy logic filling unit is used for selecting the required policy callback functions according to requirements and filling the policy logic in the policy callback functions one by using a graphical interface aiming at each required callback function.
10. The apparatus for efficiently creating a quantitative transaction policy based on a flowchart of claim 9, wherein the policy logic implementation module further comprises:
and the checking unit is used for checking whether grammar errors are contained in the strategy callback function logics after the strategy callback function strategy logics are edited.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010820312.2A CN111930373A (en) | 2020-08-14 | 2020-08-14 | Method and device for efficiently creating quantitative transaction strategy based on flow chart |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010820312.2A CN111930373A (en) | 2020-08-14 | 2020-08-14 | Method and device for efficiently creating quantitative transaction strategy based on flow chart |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN111930373A true CN111930373A (en) | 2020-11-13 |
Family
ID=73310376
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010820312.2A Pending CN111930373A (en) | 2020-08-14 | 2020-08-14 | Method and device for efficiently creating quantitative transaction strategy based on flow chart |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111930373A (en) |
Cited By (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112685043A (en) * | 2020-12-30 | 2021-04-20 | 平安普惠企业管理有限公司 | Asynchronous conversion method, device and equipment of callback function and readable storage medium |
| CN113254003A (en) * | 2021-07-19 | 2021-08-13 | 北京星火量化科技有限公司 | Editing method and system for quantitative transaction strategy |
| CN115053245A (en) * | 2021-09-24 | 2022-09-13 | 富途网络科技(深圳)有限公司 | Method and device for creating quantitative transaction strategy |
| WO2023123228A1 (en) * | 2021-12-30 | 2023-07-06 | 富途网络科技(深圳)有限公司 | Trading strategy backtesting method and apparatus, and storage medium |
| CN116501312A (en) * | 2023-04-03 | 2023-07-28 | 上海卡方信息科技有限公司 | Data processing method, device, equipment and readable storage medium |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20110072414A1 (en) * | 2009-09-20 | 2011-03-24 | Richard Dee Gardner | Method of using a diagram to create a program code |
| CN108984167A (en) * | 2018-07-10 | 2018-12-11 | 成都德承科技有限公司 | A kind of method built based on patterned sequencing logical transaction and product |
| CN110175917A (en) * | 2019-05-05 | 2019-08-27 | 中国工商银行股份有限公司 | The device and method of parameterized graphicsization processing |
-
2020
- 2020-08-14 CN CN202010820312.2A patent/CN111930373A/en active Pending
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20110072414A1 (en) * | 2009-09-20 | 2011-03-24 | Richard Dee Gardner | Method of using a diagram to create a program code |
| CN108984167A (en) * | 2018-07-10 | 2018-12-11 | 成都德承科技有限公司 | A kind of method built based on patterned sequencing logical transaction and product |
| CN110175917A (en) * | 2019-05-05 | 2019-08-27 | 中国工商银行股份有限公司 | The device and method of parameterized graphicsization processing |
Cited By (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112685043A (en) * | 2020-12-30 | 2021-04-20 | 平安普惠企业管理有限公司 | Asynchronous conversion method, device and equipment of callback function and readable storage medium |
| CN113254003A (en) * | 2021-07-19 | 2021-08-13 | 北京星火量化科技有限公司 | Editing method and system for quantitative transaction strategy |
| CN115053245A (en) * | 2021-09-24 | 2022-09-13 | 富途网络科技(深圳)有限公司 | Method and device for creating quantitative transaction strategy |
| WO2023044809A1 (en) * | 2021-09-24 | 2023-03-30 | 富途网络科技(深圳)有限公司 | Method and device for creating quantitative transaction strategy |
| WO2023123228A1 (en) * | 2021-12-30 | 2023-07-06 | 富途网络科技(深圳)有限公司 | Trading strategy backtesting method and apparatus, and storage medium |
| CN116501312A (en) * | 2023-04-03 | 2023-07-28 | 上海卡方信息科技有限公司 | Data processing method, device, equipment and readable storage medium |
| CN116501312B (en) * | 2023-04-03 | 2024-04-16 | 上海卡方信息科技有限公司 | Data processing method, device, equipment and readable storage medium |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN111930373A (en) | Method and device for efficiently creating quantitative transaction strategy based on flow chart | |
| CN110764753B (en) | Business logic code generation method, device, equipment and storage medium | |
| US20040103396A1 (en) | System for verification of enterprise software systems | |
| US8930337B2 (en) | Mapping dataset elements | |
| CN107273117B (en) | Programming-friendly agile code automatic generation system | |
| CN102411503B (en) | A kind of method and system of the dry running performing business process model when design in environment | |
| US20110283260A1 (en) | Quality assurance tools for use with source code and a semantic model | |
| US11550704B2 (en) | Methods, systems and computer program products for automated software testing | |
| CN107203473A (en) | The automatization test system and method for automatic expansion interface test case | |
| CN103164328A (en) | Method and device and system for regression testing of service function | |
| CN116127203B (en) | RPA service component recommendation method and system combining page information | |
| CN112464620A (en) | Implementation method and implementation system of financial rule engine | |
| Zhu et al. | A test automation solution on gui functional test | |
| Sánchez Gómez et al. | Towards an approach for applying early testing to smart contracts | |
| CN111176971A (en) | Code quality testing system and method based on UI automation | |
| CN113885844A (en) | Business service arranging method and related device | |
| WO2024001594A1 (en) | Operator development method and apparatus, operator processing method and apparatus, and electronic device, system and storage medium | |
| Dhiman | Reassessment of Software Development Life Cycle Models | |
| CN114116466B (en) | Unit test method, device and medium based on operation log | |
| CN111831547A (en) | Automatic interface test platform | |
| Weiß et al. | Towards establishing formal verification and inductive code synthesis in the PLC domain | |
| CN113703769B (en) | CLI command execution method and related device | |
| CN117032536B (en) | Method and device for quickly constructing OTX diagnostic sequence | |
| CN111708526B (en) | API writing method | |
| CN111208983B (en) | Use method of plug-in type expandable framework |
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 |