Wi! Mi is a tool for creating knowledge models with an unlimited number of links, parameters and relationships, with a logical conclusion. You can download this constructor from the official site .
Unfortunately, I did not find an adequate tutorial on this program, not counting the video tutorial on youtube . Therefore, I decided to write it myself.

purpose

I initially decided to set myself a specific application task:

“There is an N organization that has a hardware repair service. Number of employees 3 people. The intensity of the receipt of equipment - 2 customers per hour. And the intensity of service is equal to 2. The hourly payment of an employee is 8 USD / hour. The loss of service from the customer in the queue is 10 cu / hour. It is necessary to calculate the total costs of the company. "

Theory

Before describing the process of solving this problem, I will conduct a brief excursion on the theory on which this program is based. Wi! Mi is based on the mivar approach to the description and formalization of any type of knowledge. This approach is based on creating an evolutionary multidimensional dynamic space of a unified presentation of data and rules. In other words, it turns out that the mivar approach summarizes common approaches - for example, such as cognitive maps and ontologies.

Creating a model

For simplicity, I broke all the data on the input and output, so it was easier to navigate.
')
Model Input:

• The intensity of the arrival of equipment lambda;
• Service intensity Mu;
• Employee payment s;
• Losses of the company in case of idle Ub;
• Number of employees K.

Model output:

• Download one Ro employee;
• Customers in line Q;
• Total costs of the company Cp.

It is worth noting that the program has a button for changing the language, which allows changing the interface language to English / Russian at any stage of model creation. Unfortunately, in many programs there is no such possibility (this lyrical digression is a painful problem).

Let's return to the creation of the model. Create two classes, “Model Input Data” and “Model Output Data”. To do this, click the button "Add object" and select its type "Class".



We set a class name and we write its description. Then you need to add parameters to our class. To do this, click on "Add parameter", and in the window that opens, enter the necessary data - the name and type. It is worthwhile to enter the description, but this is not a required parameter - it just makes it easier to navigate the model and understand what this or that object is for.



After we create two classes and fill them with objects, we get the following form:



Next, we need to create relationships between objects. To do this, go to the tab "Relationships", click "Add relationship" and select the type "Formula".



We introduce the formula for loading one employee Ro = lambda / (Mu * K) and click on the button “Analyze the formula”. The program will automatically determine the input and output parameters. Similar actions are done with the formula for the number of customers in the queue
Q = (K * Math.pow (Ro, K + 1)) / (1 - Math.pow (Ro, K)) and with total costs of the company Cp = K * S + Ub * Q.



Now you need to create rules. To do this, click on "Add rule" and select the type "Simple rule".



Next, choose the relationship with which we will work. By selecting it, we bind the corresponding parameter to each object. It should be noted that the relation can be represented in the form of other values ​​(x = y + z) - the main thing is that it repeats the structure of the formula. This is convenient when several rules are attached to a relation. Since the model is small, for simplicity I used values ​​that are identical to the parameters.



After we have created all the relationships and tied the rules to them, we get the following view:



The creation of the model is complete. Now you need to check it out. To do this, go to the tab "Smart Calculator". Let's open root and our two classes. We will enter data from our condition and tick off the parameters that need to be obtained.



The program made the calculation and issued an algorithm solution.

№ 0
:
:
lambda=2;
Mu=2;
K=3;
:
Ro = lambda / (Mu * K)
: Ro=0.333333333333333;
------------------------------------
№ 1
:
:
K=3;
Ro=0.333333333333333;
:
Q = (K * Math.pow(Ro,K+1)) / (1 - Math.pow(Ro,K))
: Q=0.0384615384615384;
------------------------------------
№ 2
:
:
K=3;
S=8;
Ub=10;
Q=0.0384615384615384;
:
Cp = K * S + Ub * Q
: Cp=24.3846153846154;
------------------------------------


You can also click on the “Show decision graph” checkbox. The entire algorithm will be visualized as a graph.



In general, the tool is very simple - even in the implementation of interfaces. However, for a person who does not want or does not know how to program (and if he can program, then Wi! Mi has special “Complicated” relationships that allow writing them in JavaScript), or doesn’t want to understand how to work with this “thing” - A great option. I also wanted to say that all models are saved in .XML format.



In fact, it remains to write your own interface, parse this data - and we will get our full-fledged program. Personally, it was convenient for me to use this constructor to quickly build logic.