Инструментальная среда имитационного моделирования

Instance inst = this.inst(i_const_name);

if(!inst.con.type.States.Contains(i_state)) {

error("для типа " + inst.con.type.name + " константы " + i_const_name

+ " не определено состояние " + i_state

);

}

State s = (State)inst.con.type.States[i_state];

inst.current_state = s;

}

*/

public void trans_chart_name(string i_name) {

if(context != Context.trans) {

error("trans_chart_name i_name=" + i_name

+ ": контекст не переход");

}

Transition trans = current_transition;

trans.chart_name = i_name;

}

public void state_chart_name(string i_state, string i_name) {

State st = state(i_state);

st.chart_name = i_name;

}

public void marking(string i_name) {

marking(i_name, null);

}

public void marking(string i_name, string i_par) {

context = Context.marking;

if(markings.Contains(i_name)){

error("marking "+i_name + " already used.");

}

Marking mark = new Marking(i_name);

if (i_par != null) {

if (i_par == "like") {

mark.like = true;

} else {

error("marking_begin " + i_name + ": режим может быть только like");

}

}

markings.Add(i_name, mark);

current_marking = mark;

}

public void marking_end(string i_name) {

if (current_marking.name != i_name) {

error("marking " + current_marking.name + ": "

+ " different name (" +i_name +") in marking_end.");

}

}

public void bound(string i_place, string i_type, string i_num) {

string bname = "bound("+i_place+","+i_type+","+i_num+")";

string pref = bname + ": ";

Bound b = new Bound(bname);

if(i_place != "*") {

if(!Places.Contains(i_place)) {

error(pref + "place " + i_place + " not found");

}

b.place = (Place)Places[i_place];

}

if(i_type != "*") {

if(!Types.Contains(i_type)) {

error(pref + "type " + i_type + " not found");

}

b.type = (Type)Types[i_type];

}

b.limit = Lib.nvl_int(i_num, 0);

if(b.limit <= 0) {

error(pref + "limit " + i_num + " не больше 0");

}

bound_list.Add(b);

}

}

}

26 Model_candidates.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Collections;

namespace Automata {

interface IModel {

}

partial class Model {

List<Step> Candidates = new List<Step>();

Hashtable applicants = new Hashtable();

List<Instance> app_list = new List<Instance>();

int champ_index = 0; // кандидат-победитель

int Exec_Mode;

public int get_exec_mode(){

return Exec_Mode;

}

public int get_champ_index() {

return champ_index;

}

public const int Exec_Mode_Consume = 1;

public const int Exec_Mode_Produce = 2;

public const int Exec_Mode_Stop = 3;

public bool do_pause = false;

public string pause_reason ="";

public List<string> get_candidates() {

List<string> ss;

if(Exec_Mode == Exec_Mode_Consume) {

ss = get_consumers();

if(ss != null) {

return ss;

}

if(move_time_point()){

Exec_Mode = Exec_Mode_Produce;

} else if(points_list.Count == 0) {

Exec_Mode = Exec_Mode_Stop;

return null;

//error("Полный финиш!");

} else {

// в пределах time_to нет завершающихся переходов

return null;

}

}

ss = get_producers();

if(ss != null){

return ss;

}

remove_time_point(t_current);

Exec_Mode = Exec_Mode_Consume;

return get_candidates();

}

bool time_to_on = false;

double time_to;

public void time_limit_on(Double i_time_to) {

time_to_on = true;

time_to = i_time_to;

}

public void time_limit_off() {

time_to_on = false;

}

public void set_t_current(Double i_time) {

t_current = i_time;

}

bool move_time_point(){

if(points_list.Count < 1) {

return false;

}

points_list.Sort();

double next_time = points_list[0];

if(time_to_on)

if(next_time > time_to) {

// t_current не меняется

return false;

}

t_current = next_time;

foreach(Instance inst in inst_list){

inst.move_timers(t_current);

}

return true;

}

public List<string> get_producers(){

Point p = (Point)points_hash[t_current];

if(p == null || p.steps.Count < 1) {

return null;

}

List<string> ss = new List<string>();

foreach(Step step in p.steps) {

ss.Add("t(" + step.start_time + ") n("+step.inst.n_last_trace+") " + step.title);

}

champ_index = 0; // первый попавшийся

return ss;

}

public List<string> get_consumers(){

log("====================NEXT_STEP================");

Candidates = new List<Step>();

applicants = new Hashtable();

app_list = new List<Instance>();

foreach(Instance inst in inst_list) {

// log("instance=" + inst.con.name);

if(inst.current_state == null) continue;

if (inst.place == null) continue;

log("instance=" + inst.con.name);

// Все инстансы, которые имеют какое-нибудь состояние

State state = inst.current_state;

log("---->state=" + state.name);

foreach(Transition trans in state.list_trans) {

log("------->trans "+trans.name+" to=" + trans.state_to.name);

// Все транзиции (переходы) из состоятельных инстансов

Step step = check_step(inst, trans);

/* timed_automata

* satisfy_time == -1, то step := null - переход стал невыполнимым

* либо сейчас выполняется (satisfy_time ==0)

* либо никогда не выполняется (satisfy_time == -1)

* либо м.б. выполнится через satisfy_time (надо еще будет проверять)

* */

double satisfy_time = -1;

if(step != null && trans.has_timed_constraints()) {

satisfy_time = inst.get_satisfy_time(trans);

log("------inst="+inst.con.name+"->satisfy_time=" + satisfy_time + " time=" + t_current);

if(satisfy_time == -1) {

step = null;

}

}

if(step != null) {

/* timed_automata

* здесь должны определить ожидаемое время удовлетворения

* констрейнта - тоже fire_time, для этого нужна информация

* о inst (там реальные таймеры).

* Возможные значения (satisfy_time):

* 0 - сейчас удовлетворяется

* t(>0) - через время t будет удовлетворяться

* -1 - сейчас не удовлетворяется, t(>0) определить не удалось

*

* */

double fire_time = t_current + trans.get_wait_time();

if(trans.has_timed_constraints() && satisfy_time >= 0.0) {

fire_time = t_current + satisfy_time;

}

log("------->fire_time=" + fire_time+ " time="+t_current);

// if(inst.check_charge_transition(trans, t_current, fire_time)) {

/* timed_automata

* для случая констрейнта is_ready_to_fire == true только если он

* удовлетворяется сейчас (sutisfy_time == 0)

*

* */

if(inst.is_ready_to_fire(trans, t_current, fire_time)) {

log("------->check_charge_ok");

Applicant app = null;

if(applicants.Contains(inst)) {

app = (Applicant)applicants[inst];

} else {

app = new Applicant(inst);

applicants.Add(inst, app);

app_list.Add(inst);

}

app.steps.Add(step);

Candidates.Add(step);

} else {

/* timed_automata

* если satisfy_time == -1, то ничего не делаем

* если satisfy_time == t (>0), то это t надо "зарядить"

*

*

* */

log("------->charge trans " + trans.name + " time=" + fire_time);

if(trans.has_timed_constraints()) {

discharge_transition(inst, trans);

}

if(inst.charge_transition(trans, fire_time)) {

log("------->add_fire_point " + fire_time);

add_fire_to_point(fire_time);

} else {

log("------->already charged!");

}

/*

Point p = find_add_point(fire_time);

p.fire_count++;

*/

}

} else {

/* timed_automata

* условия стали невыполнимыми, кончились ресурсы, (а если

* сбросился таймер?), => переход надо "разрядить"

* */

log(inst.con.name + ":" + inst.current_state.name );

foreach(Transition trn in inst.current_state.list_trans) {

log(" " + trn.name + " time="

+ inst.trans_fire_time[trn.id]

);

}

discharge_transition(inst,trans);

/*

double discharge_time = inst.trans_fire_time[trans.id];

log("discharge trans=" + trans.name + " id=" + trans.id

+ " discharge_time="+discharge_time

);

clear_fire_point(discharge_time);

inst.discharge_transition(trans);

*/

}

}

}

log_candidates();

if(Candidates.Count < 1) {

log("Не найдено ни одного кандидата");

return null;

}

champ_index = make_choice();

List<string> ss = new List<string>();

foreach(Step step in Candidates) {

ss.Add(step.title);

}

return ss;

}

void discharge_transition(Instance inst, Transition trans) {

double discharge_time = inst.trans_fire_time[trans.id];

log("discharge trans=" + trans.name + " id=" + trans.id

+ " discharge_time="+discharge_time

);

clear_fire_point(discharge_time);

inst.discharge_transition(trans);

}

void log_candidates() {

// show candidates

log("Список кандидатов:");

foreach(Instance inst in app_list) {

log("__Объект " + inst.con.name);

Applicant app = (Applicant) applicants[inst];

foreach(Step step in app.steps) {

log("____переход " + step.title);

log("\t input:");

foreach(Bind b in step.Binds.Values) {

log("\t " + b.term.port.name + " " + b.inst.place.name);

}

log("\t output:");

foreach(Outcome o in step.Outcomes) {

log("\t " + o.arc.port.name + " " + o.arc.p.name + " ==> " + o.term.res.name);

}

}

}

/*

foreach(Step step in Candidates) {

log("__объект " + step.title);

log("\t input:");

foreach(Bind b in step.Binds.Values) {

log("\t "+b.term.port.name + " " + b.inst.place.name);

}

log("\t output:");

foreach(Outcome o in step.Outcomes) {

log("\t "+o.arc.port.name + " " + o.arc.p.name+" ==> "+ o.term.res.name);

}

}

*/

}

Step check_step(Instance i_inst, Transition i_trans) {

Place place = i_inst.place;

Step step = new Step(i_inst,i_trans);

Boolean term_bind = false;

// проверяем все входные термы проверяемого перехода

foreach(Term term in i_trans.list_term_in) {

term_bind = false;

foreach(Arc arc in place.list_in) {

// все входные дуги проверяемого инстанса

if(term.port == arc.port) {

// дуга одного порта с данным входным термом

log("----------->term_in=" + term.port.name + " from place=" + arc.p.name

+" term.cv="+term.cv + " term.res.name="+ term.res.name

);

Place place_res = arc.p;

// откуда эта дуга (из какого места)- входная позиция

foreach(Instance inst_res in place_res.list_inst){

// все инстансы во входной позиции

if(step.Binds.Contains(inst_res)){

log("+++>"+"inst="+inst_res.con.name+" place="+place_res.name+" already used");

continue;

}

log("+++>" + "inst=" + inst_res.con.name + " place=" + place_res.name + " not used yet");

if(inst_res.flag == Instance.flag_busy) {

log("+++>" + "inst=" + inst_res.con.name + " place=" + place_res.name + " is busy");

continue;

}

log("+++>" + "inst=" + inst_res.con.name + " place=" + place_res.name + " is not busy");

/*

log("term.res_type=" + term.res.type);

log("inst_res.con.type=" + inst_res.con.type);

log("term.state=" + term.state);

log("ins_res.current_state=" + inst_res.current_state);

*/

if(term.cv == Term.c && (term.res.name).Equals(inst_res.con.name)

&& (term.state == null || term.state == inst_res.current_state)

|| term.cv == Term.v && term.res.type == inst_res.con.type

&& (term.state == null || term.state == inst_res.current_state)

) {

log("-------------->bind term_in.res=" + term.res.name);

if(term.cv == Term.v) {

if(step.Vars_in.Contains(term.res.name)) {

error("term_in port=" + term.port.name + ", var=" + term.res.name

+ ": переменная использована на вход более 1 раза");

}

}

Bind b = new Bind(term, inst_res, arc);

step.Binds.Add(inst_res, b);

if(term.cv == Term.v) {

step.Vars_in.Add(term.res.name, inst_res);

}

term_bind = true;

break;

}

}

}

}

if(!term_bind) {

log("Transition not bind!");

return null;

}

}

// проверяем все выходные термы

foreach(Term term in i_trans.list_term_out) {

term_bind = false;

foreach(Arc arc in place.list_out) {

if(term.port != arc.port) continue; // ищем другую дугу

log("----------->term_out=" + term.port.name + " to place=" + arc.p.name);

Place place_new = arc.p;

Outcome outcome = new Outcome(term,arc);

if(term.cv == Term.v) {

string v_name = term.res.name;

if(!step.Vars_in.Contains(v_name)) {

error("Term_out port=" + term.port.name + ", var=" + v_name

+ ": no input var");

}

Instance bind_inst = (Instance) step.Vars_in[v_name];

if(step.Vars_out.Contains(v_name)) {

error("Term_out port=" + term.port.name + ", var=" + v_name

+ ": использована на выход более 1 раза");

}

step.Vars_out.Add(term.res.name,bind_inst);

}

step.Outcomes.Add(outcome);

term_bind = true;

break;

}

if(!term_bind) {

log("Transition not outcome!");

return null;

}

}

return step;

}

Random r = new Random();

int make_choice() {

// выбираем объект

int n = app_list.Count;

// Random r = new Random();

int n_inst = r.Next(n); // определили объект случайным образом

log("выбран объект " + n_inst + " из " + n + ": " + app_list[n_inst].con.name);

// выбираем переход объекта номер n_inst

Instance inst = app_list[n_inst];

Applicant app = (Applicant)applicants[inst];

n = app.steps.Count;

int sum = 0;

foreach(Step step in app.steps) {

sum += step.trans.priority;

}

int r_prty = r.Next(sum);

int n_trans = -1;

Step champ_step = null;

foreach(Step step in app.steps) {

n_trans++;

champ_step = step;

if(r_prty <= step.trans.priority) {

break;

}

r_prty -= step.trans.priority;

}

log("выбран переход " + n_trans + " из " + n + ": " + app.steps[n_trans].title);

log("champ_step: " + champ_step.title);

// выбран переход n_trans !

champ_index = Candidates.IndexOf(champ_step);

log("champ_index=" + champ_index + ": " + Candidates[champ_index].title);

return champ_index;

}

}

}

27 Model_ChartInfo.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace Automata {

partial class Model {

public ChartInfo get_chin() {

ChartInfo chin = new ChartInfo();

string pos;

string state;

double time_from, time_to;

chin.x_max = t_current;

List<string> pos_list = new List<string>();

foreach (int n in n_trace_list){

Trace trace = (Trace)trace_hash[n];

//log("trace.com.name=" + trace.con.name);

if (trace.con.type.initial_state != null) {

pos = trace.con.name;

if (trace.place != null) {

pos += ":" + trace.place.name;

}

if(pos_list.IndexOf(pos)==-1){

log("pos_list.add " + pos + " indexof=" + pos_list.IndexOf(pos));

pos_list.Add(pos);

}

}

}

pos_list.Sort();

foreach (string s in pos_list) {

chin.add_position(s);

}

foreach(int n in n_trace_list) {

Trace trace = (Trace)trace_hash[n];

//log("trace.com.name=" + trace.con.name);

if(trace.con.type.initial_state != null) {

pos = trace.con.name;

if (trace.place != null){

pos += ":" + trace.place.name;

}

if(trace.state != null) {

state = trace.state.chart_name;

}else {// if(trace.trans != null) {

state = trace.trans.chart_name;

}

// chin.add_item(pos, state, trace.time_start, Math.Max(trace.time_finish, t_current));

// log("pos=" + pos + " state=" + state + " time_start=" + trace.time_start + " time_finifsh=" + trace.time_finish);

// chin.add_item(pos, state, trace.time_start, Math.Max(trace.time_start, trace.time_finish));

time_from = trace.time_start;

time_to = trace.time_finish;

if(time_to == -1) {

time_to = t_current;

}

chin.add_item(pos, state, time_from, time_to);

}

}

return chin;

}

}

}

28 Model_dot.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Collections;

namespace Automata {

partial class Model {

FormVisual frm_viz = null;

void wd(string ss) {

frm_viz.write_dot(ss);

}

struct StrKey {

public Instance inst;

public State state;

public int count;

}

public void show_automata_net(FormVisual i_frm_viz) {

frm_viz = i_frm_viz;

wd("digraph G {");

foreach(Instance inst in inst_list){

if(!inst.is_visual)continue;

string i_key = inst.con.name + inst.GetHashCode();

wd("subgraph cluster_" + i_key + " { style=filled; color=lightgrey;");

wd("node [style=filled];");

wd("label=\"" + inst.con.name+"("+inst.con.type.name+")\"");

foreach(State st in inst.con.type.list_states){

wd(i_key+st.name+"[label="+st.name);

if (inst.current_state == st) {

wd(" color = yellow");

}

wd("]; ");

}

foreach (State st in inst.con.type.list_states) {

foreach (Transition trans in st.list_trans) {

wd(i_key + st.name + " -> " + i_key + trans.state_to.name);

string ss_trans_color = "black";

foreach(Step step in Candidates){

if (step.inst == inst && step.trans == trans) {

ss_trans_color="green";

}

}

string ss_get = "";

foreach (Term term in trans.list_term_in) {

ss_get += (ss_get == "") ? "" : ",";

ss_get += term.port.name + "?" + term.res.name;

}

log("ss_get=" + ss_get);

string ss_put = "";

foreach (Term term in trans.list_term_out) {

ss_put += (ss_put == "") ? "" : ",";

ss_put += term.port.name + "!" + term.res.name;

}

string ss3 = "";

if (inst.current_step != null) {

if (inst.current_step.trans == trans) {

ss_trans_color = "red";

ss3 += "finish_time="+inst.current_step.finish_time;

}

}

if (st == inst.current_state) {

//ss3 += "current: ";

for (int i = 0; i < inst.trans_fire_time.Length; i++) {

if (i != trans.id) continue;

//ss3 += " i=" + i;

double d = inst.trans_fire_time[i];

if (d >= 0) {

ss3 += " fire_time=" + d;

if (!ss_trans_color.Equals("green")) {

ss_trans_color = "yellow";

}

}

}

}

ss3 = ""; // не нравится это время на картинке

string ss4 = "";

if (st.name != "") {

//ss4 = st.name;

}

string ss_constr = "";

foreach (Constraint constr in trans.list_constr) {

ss_constr += (ss_constr == "") ? "" : ",";

ss_constr += constr.title(true);

}

foreach (Register r in trans.list_reset) {

ss_constr += (ss_constr == "") ? "" : ",";

ss_constr += "reset("+r.name+")";

}

/*

log("ss2=" + ss2);

if (ss2 == "") {

log("ss2==\"\"");

} else {

log("ss2!=\"\"");

}

*/

wd("[color=" + ss_trans_color);

if (ss_get != "" || ss_put != "" || ss3 != "" || ss4 != ""

|| ss_constr != ""

) {

string ss = "";

ss += " ,label=<<TABLE border=\"0\" cellborder=\"0\"> <TR><TD>";

if (ss4 != "") {

ss += ss4 + "<br/>";

}

if (ss_get != "") {

ss += ss_get + "<br/>";

}

if (ss_put != "") {

ss += ss_put+"<br/>";

}

if (ss_constr != "") {

ss += ss_constr+"<br/>";

}

if (ss3 != "") {

ss += ss3 + "<br/>";

}

ss += " </TD></TR></TABLE>>";

wd(ss);

}

wd("]");

}

}

wd("}");

}

wd("}");

frm_viz.draw_graph();

}

public void show_system_net(FormVisual i_frm_viz) {

frm_viz = i_frm_viz;

wd("digraph G {");

foreach(Place p in m.p_list) {

wd("subgraph cluster_" + p.name+" { style=filled; color=lightgrey;");

// wd("node [style=filled,color=white];")

wd("node [style=filled];");

wd("label=" + p.name);

wd(" "+p.name +";");

Hashtable t = new Hashtable();

foreach(Instance inst in p.list_inst) {

string s_key = p.name+"_"+inst.con.name;

if(inst.current_state != null){

s_key += "_" + inst.current_state.name;

}

if(t.Contains(s_key)){

StrKey sk = (StrKey)t[s_key];

sk.count += 1;

t[s_key] = sk;

}else{

StrKey sk = new StrKey();

sk.inst = inst;

sk.state = inst.current_state;

sk.count = 1;

t.Add(s_key, sk);

}

}

// wd(" " + p.name + "_x [label=\"");

string[] colors = {"red","orange","yellow","green", "LightBlue","Blue"

,"Violet", "Aquamarine", "Brown", "Black","Aqua","Bisque"

,"Coral","BurlyWood"

};

foreach(string ss in t.Keys) {

StrKey sk = (StrKey)t[ss];

string color = "white";

if(sk.inst.con.type.id < colors.Count()) {

color = colors[sk.inst.con.type.id];

}

wd(" "+ss+" [label = \""+sk.inst.con.name

+(sk.state == null?"":":"+sk.state.name)

+(sk.count == 1?"":" ["+sk.count+"]") +"\" "

+" shape=box style=\"filled,rounded\""

+" color=\""+color+"\""

+" ]");

// wd(" " + ss +":"+i+"");

}

// wd("\"];");

wd("}");

foreach(Arc a in p.list_in) {

wd(a.p.name + "->" + a.p0.name + "[label=\""

+ a.port.name+ "\",color=\"#0000ff\"];");

}

foreach(Arc a in p.list_out) {

wd(a.p0.name + "->" + a.p.name + "[label=\"" + a.port.name + "\"];");

}

}

wd("}");

frm_viz.draw_graph();

}

}

}

29 Model_exec.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Collections;

namespace Automata {

partial class Model {

static MultyLanguage ml = MultyLanguage.get_MultyLanguage();

List<Double> points_list = new List<Double>();

Hashtable points_hash = new Hashtable();

Double t_current = 0.0; // текущее время

//double next_t_current = 0.0; // время следующего шага

List<int> n_trace_list = new List<int>();

public Hashtable trace_hash = new Hashtable();

int n_trace = 0; //текущий шаг

public void reset_model(){

t_current = 0.0;

// next_t_current = 0.0;

points_list = new List<Double>();

points_hash = new Hashtable();

n_trace = 0;

n_trace_list = new List<int>();

trace_hash = new Hashtable();

}

public Double get_t_current() {

return t_current;

}

public string get_step_info() {

string ss = "time=" + t_current + " n="+n_trace;

switch (Exec_Mode) {

case Model.Exec_Mode_Consume:

ss += ml["consume"]/*" потребление"*/;

break;

case Exec_Mode_Produce:

ss += ml["production"]/*" производство"*/;

break;

case Exec_Mode_Stop:

ss += ml["end"]/*" конец"*/;

break;

}

if (do_pause) {

ss += ml["Pause"]/*". Пауза: "*/ + pause_reason;

do_pause = false;

}

return ss;

}

/*

void execmain_proc2() {

List<Step> steps = get_steps_on_point(t_current);

foreach(Step step in steps) {

exec_finish(step);

}

remove_point(t_current);

do {

get_candidates();

if(Candidates.Count < 1) break;

int n_step = make_choice();

exec_start(n_step);

} while(true);

}

*/

Point find_add_point(double i_time) {

Point p = null;

if(points_hash.Contains(i_time)) {

p = (Point)points_hash[i_time];

} else {

p = new Point(i_time);

points_hash.Add(i_time, p);

points_list.Add(i_time);

}

return p;

}

void add_fire_to_point(double i_fire_time) {

Point p = find_add_point(i_fire_time);

p.fire_count++;

}

void add_step_to_point(Step i_step){

Double time = i_step.finish_time;

Point p = find_add_point(time);

/*

Point p = null;

if(points_hash.Contains(time)) {

p = (Point) points_hash[time];

} else {

p = new Point(time);

points_hash.Add(time, p);

points_list.Add(time);

}

*/

p.steps.Add(i_step);

}

void clear_fire_point(double i_time) {

Point p = (Point)points_hash[i_time];

log("clear_fire_point time=" + i_time + " point=" + p);

if(p == null) return;

p.fire_count--;

if(p.fire_count <= 0 && p.steps.Count == 0) {

remove_time_point(i_time);

}

}

void remove_time_point(double i_time) {

// Point p = (Point) points_hash[i_time];

points_list.Remove(i_time);

points_hash.Remove(i_time);

}

List<Step> get_steps_on_point(double i_time) {

if(points_hash.Contains(i_time)) {

Point p = (Point)points_hash[i_time];

return p.steps;

}

return null;

}

void trace(Instance inst, Step step) {

if(inst.n_last_trace != -1) {

Trace old_t = (Trace)trace_hash[inst.n_last_trace];

old_t.time_finish = t_current;

old_t.n_finish = n_trace;

}

if(inst.flag == Instance.flag_consumed) return;

if(inst.current_state == null && inst.current_step == null) return;

Trace new_t = new Trace();

new_t.con = inst.con;

new_t.place = inst.place;

new_t.step = step;

new_t.state = inst.current_state;

new_t.trans = (inst.current_step == null? null : inst.current_step.trans);

new_t.n_start = n_trace;

new_t.time_start = t_current;

new_t.time_finish = -1;

inst.n_last_trace = n_trace;

trace_hash.Add(n_trace, new_t);

n_trace_list.Add(n_trace);

n_trace++;

log_t(new_t.show());

check_marking();

check_bounds();

}

void exec_start(int n_step) {

// потребление

Step step = Candidates[n_step];

foreach(Bind b in step.Binds.Values) {

log("delete con=" + b.inst.con.name + " place=" + b.inst.place.name);

b.inst.flag = Instance.flag_consumed;

trace(b.inst, null);

if(b.term.cv == Term.c) { // если константа

delete_inst(b.inst);

} else if(b.term.cv == Term.v) { // если переменная

// инстанс теряет состояние и становится занят

b.inst.flag = Instance.flag_busy;

/* может можно сохранить состояние, чтобы его не обязательно было указывать

* при производстве ??

b.inst.current_state = null;

*/

// удаляем инстанс со старого места

Place place = b.inst.place;

place.list_inst.Remove(b.inst);

b.inst.place = null;

}

}

step.start_time = t_current;

double step_duration = step.trans.get_duration_time();

step.finish_time = t_current + step_duration;

// if (1 ==2 && step_duration == 0.0) { // никогда! т.е. завершение на этапе производства

// дезактивировать объект, обнулить состояние, установить переход

// Это нужно в обоих случаях, чтобы работала trace

step.inst.current_state = null;

//step.inst.current_trans = step.trans;

step.inst.current_step = step;

step.inst.flag = Instance.flag_busy;

trace(step.inst,step);

if (step_duration == 0.0) {

// если нулевая длительность, то сразу производство

exec_finish(step);

} else {

// step.inst.reset_enable_time();

// нет смысла - у inst нет состояния, когда появится - тогда reset

// создать закладку на проиводство в будущем

add_step_to_point(step);

}

}

void exec_finish(Step step) {

// производство

foreach(Outcome outcome in step.Outcomes) {

log("create con=" + outcome.term.res.name + " port=" + outcome.term.port.name

+ " place=" + outcome.arc.p.name

);

Instance new_inst = null;

if(outcome.term.cv == Term.c) {

place(outcome.arc.p.name);

if(outcome.term.state != null) {

new_inst = inst(outcome.term.res.name, outcome.term.state.name);

} else {

new_inst = inst(outcome.term.res.name);

}

} else if(outcome.term.cv == Term.v) {

new_inst = (Instance)step.Vars_in[outcome.term.res.name];

new_inst.place = outcome.arc.p;

new_inst.flag = Instance.flag_free;

if(outcome.term.state != null) {

new_inst.current_state = outcome.term.state;

}

new_inst.place.list_inst.Add(new_inst);

new_inst.reset_transitions(); // обнулить счетчики ожидания у новых

/* пусть счетчики остаются ???

inst.start_timers(t_current); // запустить таймеры

*/

}

trace(new_inst, null);

}

// установить новое состояние (активировать)

step.inst.current_state = step.trans.state_to; // новое состояние установилось

step.inst.current_step = null; // переход завершился

step.inst.flag = Instance.flag_free;

step.inst.reset_transitions(); // обнулить счетчика ожидания у активного

step.inst.reset_timers(step.trans,t_current); // сбросить таймеры (если на переходе есть сбросы)

trace(step.inst,step);

log(step.inst.con.name + " place=" + step.inst.place.name

+ " ==> " + step.inst.current_state.name);

}

public void exec_step() {

exec_step(get_champ_index());

log_t(".");

log_t(".");

for (int i = 0; i < m.trace_hash.Count; i++) {

Trace t = (Trace)m.trace_hash[i];

string ss = t.show();

log_t(ss);

}

}

public void exec_step(int n_step) {

if(Exec_Mode == Model.Exec_Mode_Consume) {

log("Execute consume step " + Candidates[n_step].title);

exec_start(n_step);

} else if(Exec_Mode == Model.Exec_Mode_Produce) {

//t_current = next_t_current;

Point p = (Point)points_hash[t_current];

Step step = p.steps[n_step];

log("Execute produce step " + step.title);

exec_finish(step);

p.steps.Remove(step);

}

}

void delete_inst(Instance i_inst) {

inst_list.Remove(i_inst);

i_inst.place.list_inst.Remove(i_inst);

}

}

}

30 Model_init.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace Automata {

partial class Model {

public static Model init() {

Model m = new Model("wandering philosophers");

try {

m.place("chair1");

m.place("chair2");

m.place("chair3");

m.place("chair4");

m.place("napkin23");

m.place("napkin34");

m.place("napkin12");

m.place("napkin41");

m.place("dish");

m.place("park");

m.arc_in("chair1", "napkin41", "getr");

m.arc_in("chair1", "napkin12", "getl");

m.arc_out("chair1", "napkin41", "putr");

m.arc_out("chair1", "napkin12", "putl");

m.arc_out("chair1", "park", "ToPark");

m.arc_in("chair1", "chair1", "Leave");

m.arc_out("chair1", "chair1", "put");

m.arc_in("chair2", "napkin12", "getr");

m.arc_in("chair2", "napkin23", "getl");

m.arc_out("chair2", "napkin12", "putr");

m.arc_out("chair2", "napkin23", "putl");

m.arc_out("chair2", "park", "ToPark");

m.arc_in("chair2", "chair2", "Leave");

m.arc_out("chair2", "chair2", "put");

m.arc_in("chair3", "napkin23", "getr");

m.arc_in("chair3", "napkin34", "getl");

m.arc_out("chair3", "napkin23", "putr");

m.arc_out("chair3", "napkin34", "putl");

m.arc_out("chair3", "park", "ToPark");

m.arc_in("chair3", "chair3", "Leave");

m.arc_out("chair3", "chair3", "put");

m.arc_in("chair4", "napkin34", "getr");

m.arc_in("chair4", "napkin41", "getl");

m.arc_out("chair4", "napkin34", "putr");

m.arc_out("chair4", "napkin41", "putl");

m.arc_out("chair4", "park", "ToPark");

m.arc_in("chair4", "chair4", "Leave");

m.arc_out("chair4", "chair4", "put");

m.arc_in("chair1", "dish", "eat");

m.arc_in("chair2", "dish", "eat");

m.arc_in("chair3", "dish", "eat");

m.arc_in("chair4", "dish", "eat");

m.arc_in("park", "park", "Leave");

m.arc_in("park", "chair1", "get1");

m.arc_in("park", "chair2", "get2");

m.arc_in("park", "chair3", "get3");

m.arc_in("park", "chair4", "get4");

m.arc_out("park", "chair1", "ToChair1");

m.arc_out("park", "chair2", "ToChair2");

m.arc_out("park", "chair3", "ToChair3");

m.arc_out("park", "chair4", "ToChair4");

m.type("fork");

m.dconst("f");

m.port("putr"); m.port("putl"); m.port("getr"); m.port("getl");

m.type("spag");

m.dconst("s");

m.port("eat");

m.type("free");

m.dconst("free");

m.port("put"); m.port("get1"); m.port("get2"); m.port("get3"); m.port("get4");

m.type("philosopher");

m.state("thinking"); // начальное состояние

m.port("Leave"); m.port("ToChair1"); m.port("ToChair2"); m.port("ToChair3"); m.port("ToChair4"); m.port("ToPark");

m.dconst("p1"); m.dconst("p2"); m.dconst("p3"); m.dconst("p4");

m.dvar("ph");

m.state_chart_name("LFolk_before_eating", "1folk");

m.state_chart_name("RFolk_before_eating", "1folk");

m.state_chart_name("RFolk_after_eating", "1folk");

m.state_chart_name("LFolk_after_eating", "1folk");

m.trans("eating", "eating", "do_eating"); m.trans_chart_name("eating");

m.priority("60"); m.duration("10");

m.term_in("eat", "s");

m.trans("eating", "LFolk_after_eating", "L_A"); m.trans_chart_name("put_folk");

m.priority("20"); m.duration("1");

m.term_out("putr", "f");

m.trans("eating", "RFolk_after_eating", "R_A"); m.trans_chart_name("put_folk");

m.priority("20"); m.duration("1");

m.term_out("putl", "f");

m.trans("thinking", "LFolk_before_eating", "L_B"); m.trans_chart_name("get_folk");

m.duration("2");

m.term_in("getl", "f");

m.trans("thinking", "RFolk_before_eating", "R_B"); m.trans_chart_name("get_folk");

m.duration("2");

m.term_in("getr", "f");

m.trans("thinking", "thinking", "do_thinking"); m.trans_chart_name("thinking");

m.duration("5");

m.trans("thinking", "thinking", "to_park"); m.trans_chart_name("walking");

m.duration("2");

m.term_in("Leave","ph","thinking");

m.term_out("put","free");

m.term_out("ToPark","ph","thinking");

m.trans("thinking", "thinking", "to_chair1"); m.trans_chart_name("walking");

m.duration("4");

m.term_in("get1","free");

m.term_in("Leave", "ph","thinking");

m.term_out("ToChair1", "ph", "thinking");

m.trans("thinking", "thinking", "to_chair2"); m.trans_chart_name("walking");

m.duration("4");

m.term_in("get2", "free");

m.term_in("Leave", "ph", "thinking");

m.term_out("ToChair2", "ph", "thinking");

m.trans("thinking", "thinking", "to_chair3"); m.trans_chart_name("walking");

m.duration("4");

m.term_in("get3", "free");

m.term_in("Leave", "ph", "thinking");

m.term_out("ToChair3", "ph", "thinking");

m.trans("thinking", "thinking", "to_chair4"); m.trans_chart_name("walking");

m.duration("4");

m.term_in("get4", "free");

m.term_in("Leave", "ph", "thinking");

m.term_out("ToChair4", "ph", "thinking");

m.trans("LFolk_before_eating","eating", "lets_eat1"); m.trans_chart_name("get_folk");

m.duration("1"); m.priority("80");

m.term_in("getr", "f");

m.trans("LFolk_before_eating", "thinking", "lets_think2"); m.trans_chart_name("put_folk");

m.duration("1"); m.priority("20");

m.term_out("putl", "f");

m.trans("RFolk_before_eating", "eating", "lets_eat1"); m.trans_chart_name("get_folk");

m.duration("1"); m.priority("80");

m.term_in("getl", "f");

m.trans("RFolk_before_eating", "thinking", "lets_think2"); m.trans_chart_name("put_folk");

m.duration("1"); m.priority("20");

m.term_out("putr", "f");

m.trans("LFolk_after_eating", "eating", "lets_eat2"); m.trans_chart_name("get_folk");

m.duration("2"); m.priority("20");

m.term_in("getr", "f");

m.trans("LFolk_after_eating", "thinking", "lets_think1"); m.trans_chart_name("put_folk");

m.duration("2"); m.priority("80");

m.term_out("putl", "f");

m.trans("RFolk_after_eating", "eating", "lets_eat2"); m.trans_chart_name("get_folk");

m.duration("3"); m.priority("20");

m.term_in("getl", "f");

m.trans("RFolk_after_eating", "thinking", "lets_think1"); m.trans_chart_name("put_folk");

m.duration("1"); m.priority("80");

m.term_out("putr", "f");

m.place("chair1"); m.inst("p1", "thinking");

m.place("chair2"); m.inst("p2", "thinking");

m.place("chair3"); m.inst("p3", "thinking");

m.place("chair4"); m.inst("p4", "thinking");

m.place("napkin12"); m.inst("f");

m.place("napkin23"); m.inst("f");

m.place("napkin34"); m.inst("f");

m.place("napkin41"); m.inst("f");

m.place("dish");

m.inst("s"); m.inst("s"); m.inst("s"); m.inst("s"); m.inst("s");

m.inst("s"); m.inst("s"); m.inst("s"); m.inst("s"); m.inst("s");

m.inst("s"); m.inst("s"); m.inst("s"); m.inst("s"); m.inst("s");

m.inst("s"); m.inst("s"); m.inst("s"); m.inst("s"); m.inst("s");

} catch (Exception e) {

error("ошибка: " + e.Message);

}

return m;

}

}

}

/*

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace Automata {

partial class Model {

public static Model init() {

Model m = new Model("Dinning philosophers");

try {

m.place("chair1");

m.place("chair2");

m.place("chair3");

m.place("chair4");

m.arc_in("chair3", "napkin23", "getr");

m.arc_out("chair3", "napkin23", "putr");

m.arc_in("chair3", "napkin34", "getl");

m.arc_out("chair3", "napkin34", "putl");

m.type("fork");

m.dconst("f");

m.port("putr"); m.port("putl"); m.port("getr"); m.port("getl");

m.type("spag");

m.dconst("s");

m.port("eat");

m.type("philosopher");

m.dconst("p1"); m.dconst("p2"); m.dconst("p3"); m.dconst("p4");

m.state("thinking"); // начальное состояние

m.trans("eating", "eating");

m.term_in("eat", "s");

// m.term_in("get","H2"); m.term_in("get","H2"); m.term_in("get","O2");

// m.term_out("put","H2O"); m.term_out("put","H2O");

m.trans("eating", "LFork");

m.priority("20"); m.duration("10", "12");

m.term_out("putr", "f");

m.trans("eating", "RFork");

m.term_out("putl", "f");

m.trans("thinking", "LFork");

m.term_in("getl", "f");

m.trans("thinking", "RFork");

m.term_in("getr", "f");

m.trans("LFork", "eating");

m.term_in("getr", "f");

m.trans("LFork", "thinking");

m.term_out("putl", "f");

m.trans("RFork", "eating");

m.term_in("getl", "f");

m.trans("RFork", "thinking");

m.term_out("putr", "f");

m.place("dish");

m.inst("s"); m.inst("s"); m.inst("s"); m.inst("s");

m.inst("s"); m.inst("s"); m.inst("s"); m.inst("s");

m.inst("s"); m.inst("s"); m.inst("s"); m.inst("s");

m.place("napkin12"); m.inst("f");

m.place("napkin23"); m.inst("f");

m.place("napkin34"); m.inst("f");

m.place("napkin41"); m.inst("f");

m.place("chair1"); m.inst("p1");

m.place("chair2"); m.inst("p2");

m.place("chair3"); m.inst("p3");

m.place("chair4"); m.inst("p4");

} catch (Exception e) {

error("ошибка: " + e.Message);

}

return m;

}

}

}

*/

31 Model_log.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Collections;

namespace Automata {

partial class Model {

public static int page_length = 900;

static double max_time;

public static int title_length = 50;

public static int gap = 30;

public bool log_total() {

if(t_current <= 0) {

log(ml["show_of_rezults"]/*"Показ итогов невозможен: t_current="*/ + t_current + ml["time_doesn't move"]/*" - время не продвинулось."*/);

return false;

}

log(ml["=REZULTS="]/*"==================== ИТОГИ ============="*/);

max_time = t_current;

StringBuilder sb;

sb = new StringBuilder(new string(' ', page_length));

for(int i = 0; i < page_length - gap; i += gap) {

double time_i = max_time / page_length * i;

sb.Insert(i, String.Format("|<-{0:f}сек.", time_i));

}

string fin = string.Format("max {0:f}сек.->|",max_time);

sb.Insert(page_length - fin.Length, fin);

string line_x = sb.ToString().Substring(0,page_length);

foreach (Const con in Constants.Values) {

if(con.type.list_states.Count <= 0) {

continue; // если у типа нет состояний, то нечего показывать

}

log("..");

int n = 0;

double time = 0;

sb = new StringBuilder(new string(' ',title_length));

sb.Insert(2, "============= Const " + con.name+" =============");

string title = sb.ToString().Substring(0, title_length);

string ss = title + line_x;

//log("ss.length=" + ss.Length);

log(ss);

foreach (State state in con.type.list_states) {

sb = new StringBuilder(new String(' ', page_length));

int st_n = 0;

double st_time = 0;

foreach (int n_trace in n_trace_list) {

Trace trace = (Trace) trace_hash[n_trace];

// foreach (Trace trace in trace_hash.Values) {

if (trace.con == con && trace.state == state) {

st_n++;

double time_finish = trace.time_finish;

if(time_finish == -1) time_finish = t_current;

if (time_finish > 0) {

st_time += time_finish - trace.time_start;

}

double d = page_length * trace.time_start/max_time;

int beg = (int)d;

d = page_length * (time_finish - trace.time_start) / max_time;

int len = (int) d;

sb.Insert(beg, new string(state.symbol, len));

}

}

string time_line = sb.ToString().Substring(0,page_length);

sb = new StringBuilder(new string(' ', title_length));

sb.Insert(0, "" + state.name + " (" + st_n + "; " + st_time+"сек.)");

title = sb.ToString().Substring(0, title_length);

log(title + time_line);

n += st_n;

time += st_time;

}

foreach (Transition trans in con.type.list_trans) {

sb = new StringBuilder(new String(' ', page_length));

int tr_n = 0;

double tr_time = 0;

foreach (int n_trace in n_trace_list) {

Trace trace = (Trace) trace_hash[n_trace];

// foreach (Trace trace in trace_hash.Values) {

if (trace.con == con && trace.trans == trans) {

tr_n++;

double time_finish = trace.time_finish;

if(time_finish == -1) time_finish = t_current;

if(time_finish > 0) {

tr_time += time_finish - trace.time_start;

}

double d = page_length * trace.time_start / max_time;

int beg = (int)d;

d = page_length * (time_finish - trace.time_start) / max_time;

int len = (int)d;

/*

log("n_start=" + trace.n_start + " time_start=" + trace.time_start

+ " time_fnish=" + time_finish);

log("beg=" + beg + " len=" + len);

*/

sb.Insert(beg, new string(trans.symbol, len));

// sb = new StringBuilder(sb.ToString().Substring(0,page_length));

}

}

string time_line = sb.ToString().Substring(0, page_length);

sb = new StringBuilder(new string(' ', title_length));

sb.Insert(0, "" + trans.name + " (" + tr_n + "; " + tr_time+"сек.)");

title = sb.ToString().Substring(0, title_length);

log(title + time_line);

/*

log("..trans: " + trans.state_from.name + " -> "

+ trans.state_to.name + " n=" + tr_n + " time=" + tr_time);

*/

n += tr_n;

time += tr_time;

}

log(ml["total_po_const"]/*"Итого по const "*/ + con.name+": n="+n+", time="+time+ml["sec"]/*"сек."*/);

}

return true;

}

public void log_trace() {

log_t(".");

log_t(".");

for (int i = 0; i < trace_hash.Count; i++) {

Trace t = (Trace)trace_hash[i];

string ss = t.show();

log_t(ss);

}

}

public void show_rezult(){

rez(ml["performance_time"]/*"Время выполнения "*/ + t_current + ml["number_of_steps"]/*", число шагов "*/+n_trace);

//Достижимость

if (test_marking) {

rez("");

rez(ml["r_reachability"]/*"Достижимость:"*/);

foreach (Object obj in markings.Values) {

Marking mark = (Marking)obj;

rez(ml[" Marking "]/*" Разметка "*/ + mark.name

+ ml["reached"]/*" достигнута "*/ + mark.count + ml["times"]/*" раз"*/);

}

}

//Ограниченность

if(test_bounds) {

rez("");

rez(ml["Boundedness:"]/*"Ограниченность:"*/);

foreach(Bound bound in bound_list) {

rez(ml["bound"]/*" Ограничение "*/ + bound.name + ": \t"

+ (bound.max_value <= bound.limit ? ml["yes"]/*"да"*/ : ml["no"]/*"нет"*/ )

+ " ("+bound.max_value+")"

);

}

}

//Наличие тупиковых ситуаций

if(true /* test_lock*/ ) {

rez("");

rez(ml["presence_od_deadlocks"]/*"Наличие тупиковых ситуаций: "*/

+ (m.Exec_Mode == Exec_Mode_Stop ? ml["yes"]/*"да"*/ : ml["no"]/*"нет"*/)

);

}

//Считаем переходы

List<Transition> list_trans = new List<Transition>();

int n_trans = 0;

foreach (Type typ in t_list) {

foreach (Transition trans in typ.list_trans) {

list_trans.Add(trans);

n_trans++;

}

}

int[] trans_count_arr = new int[n_trans];

//Считаем дуги

int n_arc=0;

List<Arc> list_arc = new List<Arc>();

foreach(Place p in p_list){

foreach(Arc a in p.list_in){

n_arc++;

list_arc.Add(a);

}

foreach(Arc a in p.list_out){

n_arc++;

list_arc.Add(a);

}

}

int[] arc_count_arr = new int[n_arc];

// Статистика по агентам, берется из трассировки trace_hash

Hashtable agents = new Hashtable();

AgentTotal agent_total = null;

foreach (int n in n_trace_list) {

Trace trace = (Trace)trace_hash[n];

Const con = trace.con;

double step_time = (trace.time_finish == -1.0 ? t_current : trace.time_finish)

- trace.time_start;

if (agents.Contains(con)) {

agent_total = (AgentTotal) agents[con];

} else {

agent_total = new AgentTotal();

agent_total.con = con;

agent_total.state_count_posible = con.type.list_states.Count;

agent_total.trans_count_posible = con.type.list_trans.Count;

foreach (State state in con.type.list_states) {

AgentStateTotal astot = new AgentStateTotal();

astot.state = state;

agent_total.states.Add(state, astot);

}

foreach (Transition trans in con.type.list_trans) {

AgentTransTotal attot = new AgentTransTotal();

attot.trans = trans;

agent_total.transes.Add(trans, attot);

}

agents.Add(con, agent_total);

}

if (trace.trans != null) {

int i_trans = list_trans.IndexOf(trace.trans);

trans_count_arr[i_trans]++;

if (trace.step != null) {

int i_arc;

foreach (Object obj in trace.step.Binds.Values) {

try {

Bind b = (Bind)obj;

i_arc = list_arc.IndexOf(b.arc);

arc_count_arr[i_arc]++;

} catch (Exception e) {

log("rezult arc count from Bind, e = " + e);

log("obj=" + obj);

}

}

foreach (Outcome outcome in trace.step.Outcomes) {

i_arc = list_arc.IndexOf(outcome.arc);

arc_count_arr[i_arc]++;

}

}

agent_total.unstate_count++;

agent_total.unstate_total_time += step_time;

AgentTransTotal trans_tot = null;

if (agent_total.transes.Contains(trace.trans)) {

trans_tot = (AgentTransTotal)agent_total.transes[trace.trans];

} else {

trans_tot = new AgentTransTotal();

trans_tot.trans = trace.trans;

agent_total.transes.Add(trace.trans, trans_tot);

}

trans_tot.count++;

trans_tot.total_time += step_time;

} else if(trace.state != null){

AgentStateTotal state_tot = null;

if(agent_total.states.Contains(trace.state)){

state_tot = (AgentStateTotal) agent_total.states[trace.state];

}else{

state_tot = new AgentStateTotal();

state_tot.state = trace.state;

agent_total.states.Add(trace.state, state_tot);

}

state_tot.count++;

state_tot.total_time += step_time;

}

}

bool liveness_trans = true;

bool liveness_arc = true;

foreach (int c in trans_count_arr) {

if (c == 0) liveness_trans = false;

}

foreach (int c in arc_count_arr) {

if (c == 0) liveness_arc = false;

}

rez("");

rez(ml["Liveness"]/*"Живость: "*/ + (liveness_trans ? ml["yes"]/*"да"*/ : ml["no"]/*"нет"*/));

for (int i = 0; i < list_trans.Count; i++) {

Transition trans = list_trans[i];

rez(ml[" Transition:"]/*" Переход: "*/+trans.state_from.type.name + "/" + trans.state_from.name

+":" + trans.name

+" \t\t"+trans_count_arr[i] + " "

+ (trans_count_arr[i] == 0 ? "(!!!)" : "")

);

}

rez("");

rez(ml["liveness_by_system_net_transition"]/*"Живость по переходам системной сети: "*/ + (liveness_arc ? ml["yes"]/*"да"*/ : ml["no"]/*"нет"*/));

for (int i = 0; i < list_arc.Count; i++) {

Arc arc = list_arc[i];

string dir = (arc.in_out == Arc.IN ? "<-" : "->");

rez(ml["Arc"]/*" Дуга: "*/ + arc.p0.name + dir + arc.port.name + dir + arc.p.name

+ ": \t\t" + arc_count_arr[i] + " "

+ (arc_count_arr[i] == 0 ? "(!!!)" : "")

);

}

// Статистика по агентам

foreach (Object obj in agents.Values) {

AgentTotal atot = (AgentTotal) obj;

foreach(Object obj2 in atot.states.Values){

AgentStateTotal astot = (AgentStateTotal)obj2;

if(astot.count > 0) atot.state_count_total++;

}

foreach (Object obj2 in atot.transes.Values) {

AgentTransTotal attot = (AgentTransTotal)obj2;

if(attot.count > 0) atot.trans_count_total++;

}

rez("");

rez(ml["Agent"]/*"Агент "*/ + atot.con.name);

rez(ml["number_of_states"]/*"===Количество состояний "*/ + atot.state_count_total

+ " / " + atot.state_count_posible);

foreach (Object obj2 in atot.states.Values) {

AgentStateTotal astot = (AgentStateTotal)obj2;

rez(ml["cond"]/*" Состояние "*/ + astot.state.name

+ ml["time_total"]/*": время общее "*/ + astot.total_time

+ml["average"]/*", среднее "*/ + astot.total_time / astot.count + ml["number"]/*", кол-во "*/ +astot.count

+ (astot.count == 0 ? " (!!!)" : "")

);

}

rez(ml["number_of_transitions"]/*"===Количество переходов "*/ + atot.trans_count_total

+ " / " + atot.trans_count_posible);

foreach (Object obj2 in atot.transes.Values) {

AgentTransTotal attot = (AgentTransTotal)obj2;

rez(ml["Transition"]/*" Переход "*/ + attot.trans.name

+ ml["time_total"]/*": время общее "*/ + attot.total_time

+ ml["average"]/*", среднее "*/ + attot.total_time / attot.count + ml["number"]/*", кол-во "*/ + attot.count

+ (attot.count == 0 ? " (!!!)" : "")

);

}

/*

rez(" Время в переходах: общее " + atot.unstate_total_time

+ ", среднее " + atot.unstate_total_time / atot.unstate_count

+ ", кол-во " + atot.unstate_count

);

*/

}

}

string dump;

void d(string ss){

dump += ss+"\r\n";

}

public string get_dump() {

dump = "";

d("t_current=" + t_current + " n_trace=" + n_trace);

string ss = "";

points_list.Sort();

foreach (double t in points_list) {

string s = "";

if(points_hash.Contains(t)) {

Point p = (Point)points_hash[t];

if(p.steps.Count > 0) {

s = "hash.steps.count=" + p.steps.Count;

}

}

ss += "(" + t +s+ ")";

}

d(ss);

foreach (Instance inst in inst_list) {

if(inst.current_state != null){

int len=inst.trans_fire_time.Length;

int trans_count = inst.con.type.list_trans.Count;

d(inst.con.name+":"+inst.current_state.name + " arr_len=" + len+" trans_count="+trans_count);

foreach(Transition trans in inst.current_state.list_trans) {

d(" " + trans.name + " time="

+ (trans.id>=len? "???" : ""+inst.trans_fire_time[trans.id])

);

}

}

if(inst.current_step != null) {

Step step = inst.current_step;

d(inst.con.name + "->" + step.trans.name+ " start=" + step.start_time

+ " finish="+step.finish_time

);

}

}

return dump;

}

}

}

32 Model_marking.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Collections;

namespace Automata {

partial class Model {

bool test_marking = false;

bool test_bounds = false;

bool test_stop = false;

bool test_lock = true;

public void set_test_marking(bool i_value) {

test_marking = i_value;

}

public void set_test_stop(bool i_value) {

test_stop = i_value;

}

public void set_test_bounds(bool i_value) {

test_bounds = i_value;

}

public void set_test_lock(bool i_value) {

test_lock = i_value;

}

public void fix_marking(){

foreach (Object obj in markings.Values) {

Marking mark = (Marking)obj;

mark.hash = make_mark_hash(mark.places,null);

string ss = "marking("+mark.name+"): like="+mark.like

+" hash=";

foreach(int h_item in mark.hash){

ss += "("+h_item+")";

}

log(ss);

}

context = Context.nil;

}

int[] make_mark_hash(Hashtable places, Hashtable like_places){

List<int> hash = new List<int>();

Hashtable sample = places;

if (like_places != null) sample = like_places;

foreach (Object obj in sample.Keys) {

Place p = (Place) places[(string)obj];

log("hash p.name=" + p.name);

foreach (Instance inst in p.list_inst) {

log("hash p.name=" + p.name+" inst="+inst.con.name);

int n = p.id * 10000 + inst.con.id * 100

+ (inst.current_state == null ? 0: inst.current_state.id+1);

hash.Add(n);

}

}

hash.Sort();

return hash.ToArray();

}

bool arr_eq(int[] a1, int[] a2) {

if (a1.Length != a2.Length) return false;

for (int i = 0; i < a1.Length; i++) {

if (a1[i] != a2[i]) return false;

}

return true;

}

void check_marking() {

if (!test_marking || markings.Count<1) return;

int[] total_hash = make_mark_hash(Places,null);

foreach (Object obj in markings.Values) {

Marking mark = (Marking)obj;

int[] current_hash = total_hash;

if (mark.like) {

current_hash = make_mark_hash(Places,mark.places);

}

if(arr_eq(current_hash,mark.hash)){

if ((n_trace - mark.last_eq_n_trace) > 1) {

mark.count++;

if (test_stop) {

do_pause = true;

pause_reason = "marking " + mark.name;

}

}

mark.last_eq_n_trace = n_trace;

}

}

}

void check_bounds() {

if(!test_bounds || bound_list.Count <1) return;

foreach(Bound bound in bound_list) {

bound.count = 0;

foreach(Instance inst in inst_list) {

if(

(bound.place == null || bound.place == inst.place)

&&

(bound.type == null || bound.type == inst.con.type)

) {

bound.count++;

}

}

}

foreach(Bound bound in bound_list) {

bound.max_value = Math.Max(bound.count, bound.max_value);

bound.min_value = Math.Min(bound.count, bound.min_value);

}

}

}

}

33 MultyLanguage.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Collections;

namespace Automata {

class Mess {

string str_rus, str_eng;

public Mess(string russian_text, string english_text){

str_rus = russian_text;

str_eng = english_text;

}

public string Str {

get {

if(MultyLanguage.current_language == MultyLanguage.Language.russian) {

return str_rus;

} else {

return str_eng;

}

}

}

}

class MultyLanguage {

public enum Language {russian, english};

public static Language current_language = Language.russian;

static MultyLanguage ml;

public static MultyLanguage get_MultyLanguage(){

if(ml == null){

ml = new MultyLanguage();

}

return ml;

}

static Mess m(string i_rus, string i_eng) {

return new Mess(i_rus, i_eng);

}

public Mess msg_btn_visual = m("Визуализация", "Visualization");

public Mess msg_btn_chart = m("Временная диаграмма", "Time chart");

public Mess msg_btn_trace = m("Трассировка", "Trace");

public Mess msg_btn_rezult = m("Результаты анализа", "Analysis results");

public Mess cb_chart = m("Диаграмма", "Diagram");

public Mess cb_log = m("Журнал", "Log");

<...