Python Writer.set_chosen_input方法代码示例

# 需要导入模块: from writer import Writer [as 别名]
# 或者: from writer.Writer import set_chosen_input [as 别名]

#.........这里部分代码省略.........

            trace_elem = utils.swap_present_next(concrete_next_input)
            countertrace.append(utils.keep_only_present_inputs(trace_elem))

            # the new current_set_of_states is the set of next states (if
            # concrete_next_input is used as input):
            state_plus_input_ix_jx *= concrete_next_input
            next_states = state_plus_input_ix_jx * utils.sys_trans
            next_states = utils.swap_present_next(next_states)
            current_set_of_states = utils.keep_only_present(next_states)


        # If we are here, we found an input for every time step.
        repeat_index = self.get_index_of_superset_in_list(list_of_sets, \
                                                     current_set_of_states) + 1
        trace = InfiniteTraceOfBdds(utils, countertrace, repeat_index)

        return trace
        
    def print_trace(self, countertrace):
        """
        Prints a countertrace into the file
        ./spec_debug_results/countertrace.txt.

        @param countertrace: A sequence of inputs so that the system is forced
               to violate its specification.
        @type countertrace: L{InfiniteTraceOfBdds}
        """

        # write the inputs according to the countertrace:
        for input_bdd in countertrace.get_trace():
            for var in self.__utils.input_vars:
                symb = self.__utils.get_val_as_string(input_bdd, var, False)
                self.__writer.set_chosen_input(var.name, symb)
            self.__writer.start_next_time_step()

        # finally we define where the trace repeats:
        self.__writer.set_repeat_indices(countertrace.repeat_index, \
                                     countertrace.length_stem_plus_loop - 1)

        # and write the file:
        self.__writer.write_to_file("./spec_debug_results/countertrace.txt")
        self.__writer.clear()

    def is_graph_system_independent(self, graph_nodes):
        """
        Checks if the inputs in a graph are system independent.

        This method checks if the inputs in the graph computed by the class
        L{PathFinder} are system independent. If this is the case, a
        countertrace can be read directly from this graph. If the graph was
        generated from a countertrace, the inputs in this graph will always
        be system independent (i.e., independent of the moves of the system).

        This method is only used to check if the methods compute_countertrace
        and make_strategy_system_independent work correctly.

        @param graph_nodes: A set of graph nodes.
        @type graph_nodes: list<L{GraphNode}>
        @return: True if the graph is system independent, False otherwise
        @rtype: bool
        """

        # The first current state is the initial state:
        current_nodes = [graph_nodes[0]]
        current_nodes_bdd = graph_nodes[0].bdd

# 需要导入模块: from writer import Writer [as 别名]
# 或者: from writer.Writer import set_chosen_input [as 别名]

#.........这里部分代码省略.........
            # computing all possible next outputs:
            possible_next_outputs = next_input * self.__utils.sys_trans

            # we read the next output variables (entered by the user):
            (outvar_bdd, quit) = self._read_out_vars(possible_next_outputs)
            if quit:
                return
            next_state = possible_next_outputs * outvar_bdd

            # and assign the next state to current_state:
            next_state = self.__utils.swap_present_next(next_state)
            current_state = self.__utils.keep_only_present(next_state)
            step_count += 1

    def _print_current_state(self, current_state):
        """
        Prints the current state.

        This method prints the current state in the interactive game between
        the environment and the system to STDOUT. In addition to that, the
        state is written to the log file 'spec_debug_results/log.txt' with
        the help of the L{Writer}.

        @param current_state: The state to print.
        @type current_state: L{BDD}
        """

        print "current state:"

        # print the input variables:
        for in_var in self.__utils.input_vars:
            symb = self.__utils.get_val_as_string(current_state, in_var, False)
            print "current " + in_var.name + " is: " + symb
            self.__writer.set_chosen_input(in_var.name, symb)

        # print the output variables:
        for out_var in self.__utils.relevant_out_vars:
            symb = self.__utils.get_val_as_string(current_state, out_var, False)
            print "current " + out_var.name + " is: " + symb
            self.__writer.set_chosen_output(out_var.name, symb);

        # print the ix-variables:
        ix_value = self.__utils.get_decimal_ix_val(current_state, False)
        if ix_value != None:
            print "The environment tries to fulfill fairness condition nr",
            print str(ix_value) + " next";
            self.__writer.set_chosen_aux("ix", str(ix_value))
        else:
            print "The environment has not decided yet which fairness",
            print "condition it will try to reach next"
            self.__writer.set_chosen_aux("ix","?")

        # print the jx-variables:
        nr_changes = self.__utils.how_often_may_jx_change(current_state, \
                                                          self.__z_array)
        self.__writer.set_chosen_aux("jx changes", str(nr_changes))
        jx_value = self.__utils.get_decimal_jx_val(current_state, False);
        if jx_value != None:
            print "I try to keep the system from fulfilling fairness",
            print "condition nr: " + str(jx_value)
            print "I reserve the right to change my opinion on that at most",
            print str(nr_changes) + " times from now"
            self.__writer.set_chosen_aux("jx", str(jx_value))
        else:
            print "I have not decided yet which fairness condition of the",
            print "system I will try to evade";