예제 #1
0
파일: candidate.py 프로젝트: liancheng/rose
def _transition_cost_combined(StateA, StateB):
    """Computes the storage consumption of a transition map.
    """
    involved_state_n = len(StateA.implemented_state_index_list()) + len(StateB.implemented_state_index_list())
    TM_A = StateA.transition_map
    TM_B = StateB.transition_map

    # Count the number of unique schemes and the total interval number
    interval_n = 0
    scheme_set = set()
    for begin, end, a_target, b_target in transition_map_tools.zipped_iterable(TM_A, TM_B):
        interval_n += 1
        TargetFactory.update_scheme_set(a_target, b_target, scheme_set)

    scheme_n = len(scheme_set)

    return __transition_cost(involved_state_n, interval_n, scheme_n)
예제 #2
0
def _transition_cost_combined(StateA, StateB):
    """Computes the storage consumption of a transition map.
    """
    involved_state_n = len(StateA.implemented_state_index_list()) + len(
        StateB.implemented_state_index_list())
    TM_A = StateA.transition_map
    TM_B = StateB.transition_map

    # Count the number of unique schemes and the total interval number
    interval_n = 0
    scheme_set = set()
    for begin, end, a_target, b_target in transition_map_tools.zipped_iterable(
            TM_A, TM_B):
        interval_n += 1
        TargetFactory.update_scheme_set(a_target, b_target, scheme_set)

    scheme_n = len(scheme_set)

    return __transition_cost(involved_state_n, interval_n, scheme_n)
예제 #3
0
파일: path.py 프로젝트: coderjames/pascal
    def match(self, TransitionMap, TargetDoorID, TriggerCharToTarget):
        """A single character transition 

                        TriggerCharToTarget --> DoorID

           has been detected. The question is, if the remaining transitions of
           the state match the skeleton of the current path. There might be a
           wild card, that is the character that is overlapped by the first
           single character transition.  As long as a transition map differs
           only by this single character, the wild card is plugged into the
           position.

           RETURNS: 
                int > 0, the character that the wild card shall take so
                         that the skeleton matches the TransitionMap.

                    - 1, if skeleton and TransitionMap match anyway and
                         no wild card plug is necessary.

                   None, if there is no way that the skeleton and the
                         TransitionMap could match.
        """
        wildcard_target = -1
        for begin, end, a_target, b_target in transition_map_tools.zipped_iterable(self.__transition_map,
                                                                                   TransitionMap):
            if a_target == b_target: continue    # There is no problem at all

            size = end - begin
            assert size > 0

            if size == 1:  
                if   b_target == TargetDoorID:        continue
                elif a_target == E_StateIndices.VOID: wildcard_target = b_target; continue
                else:                                 return None
            else:
                return None

        # Here: The transition maps match, but possibly require the use of a wildcard.
        return wildcard_target
예제 #4
0
파일: path.py 프로젝트: liancheng/rose
    def match(self, TransitionMap, TargetDoorID, TriggerCharToTarget):
        """A single character transition 

                        TriggerCharToTarget --> DoorID

        has been detected. The question is, if the remaining transitions of the
        state match the transition map of the current path. There might be a wild
        card, that is the character that is overlapped by the first single
        character transition.  As long as a transition map differs only by this
        single character, the wild card is plugged into the position.

        RETURNS: int > 0, the character that the wild card shall take so that the
                          path's transition map matches the TransitionMap.

                     - 1, if path's transition map and TransitionMap match anyway 
                          and no wild card plug is necessary.

                    None, if there is no way that the path's transition map and the
                          TransitionMap could match.
        """
        wildcard_target = -1
        for begin, end, a_target, b_target in transition_map_tools.zipped_iterable(self.__transition_map,
                                                                                   TransitionMap):
            if a_target == b_target: continue    # There is no problem at all

            size = end - begin
            assert size > 0

            if size == 1:  
                if   b_target == TargetDoorID:        continue
                elif a_target == E_StateIndices.VOID: wildcard_target = b_target; continue
                else:                                 return None
            else:
                return None

        # Here: The transition maps match, but possibly require the use of a wildcard.
        return wildcard_target
예제 #5
0
파일: state.py 프로젝트: liancheng/rose
def combine_maps(StateA, StateB):
    """RETURNS:

          -- Transition map = combined transition map of StateA and StateB.

          -- List of target schemes that have been identified.

       NOTE: 

       If the entries of both states are uniform, then a transition to itself
       of both states can be implemented as a recursion of the template state
       without knowing the particular states.

       EXPLANATION:
    
       This function combines two transition maps. A transition map is a list
       of tuples:

            [
              ...
              (interval, target)
              ...
            ]

       Each tuple tells about a character range [interval.begin, interval.end)
       where the state triggers to the given target. In a normal AnalyzerState
       the target is the index of the target state. In a TemplateState, though,
       multiple states are combined. A TemplateState operates on behalf of a
       state which is identified by its 'state_key'. 
       
       If two states (even TemplateStates) are combined the trigger maps
       are observed, e.g.

            Trigger Map A                    Trigger Map B
                                                                          
            [                                [
              ([0,  10),   DropOut)            ([0,  10),   State_4)
              ([10, 15),   State_0)            ([10, 15),   State_1)
              ([15, 20),   DropOut)            ([15, 20),   State_0)
              ([20, 21),   State_1)            ([20, 21),   DropOut)
              ([21, 255),  DropOut)            ([21, 255),  State_0)
            ]                                ]                           


       For some intervals, the target is the same. But for some it is different.
       In a TemplateState, the intervals are associated with MegaState_Target 
       objects. A MegaState_Target object tells the target state dependent
       on the 'state_key'. The above example may result in a transition map
       as below:

            Trigger Map A                   
                                                                          
            [     # intervals:   target schemes:                           
                  ( [0,  10),    { A: DropOut,   B: State_4, },
                  ( [10, 15),    { A: State_0,   B: State_1, },
                  ( [15, 20),    { A: DropOut,   B: State_0, },
                  ( [20, 21),    { A: State_1,   B: DropOut, },
                  ( [21, 255),   { A: DropOut,   B: State_0, },
            ]                                                           

       Note, that the 'scheme' for interval [12, 20) and [21, 255) are identical.
       We try to profit from it by storing only it only once. A template scheme
       is associated with an 'index' for reference.

       TemplateStates may be combined with AnalyzerStates and other TemplateStates.
       Thus, MegaState_Targets must be combined with trigger targets
       and other MegaState_Targets.

       NOTE:

       The resulting target map results from the combination of both transition
       maps, which may introduce new borders, e.g.
    
                     |----------------|           (where A triggers to X)
                          |---------------|       (where B triggers to Y)

       becomes
                     |----|-----------|---|
                        1       2       3

       where:  Domain:     A triggers to:     B triggers to:
                 1              X               Nothing
                 2              X                  Y
                 3           Nothing               Y

    -----------------------------------------------------------------------------
    Transition maps of TemplateState-s function based on 'state_keys'. Those state
    keys are used as indices into TemplateMegaState_Targets. The 'state_key' of a given
    state relates to the 'state_index' by

        (1)    self.state_index_sequence[state_key] == state_index

    where 'state_index' is the number by which the state is identified inside
    its state machine. Correspondingly, for a given TemplateMegaState_Target T 

        (2)                   T[state_key]

    gives the target of the template if it operates for 'state_index' determined
    from 'state_key' by relation (1). The state index list approach facilitates the
    computation of target schemes. For this reason no dictionary
    {state_index->target} is used.
    """
    transition_map_tools.assert_adjacency(StateA.transition_map,
                                          TotalRangeF=True)
    transition_map_tools.assert_adjacency(StateB.transition_map,
                                          TotalRangeF=True)

    MegaState_Target.init(
    )  # Initialize the tracking of generated MegaState_Target-s
    factory = TargetFactory(StateA, StateB)
    result = []
    for begin, end, a_target, b_target in transition_map_tools.zipped_iterable(
            StateA.transition_map, StateB.transition_map):
        target = factory.get(a_target, b_target)
        result.append((Interval(begin, end), target))

    # Return the database of generated MegaState_Target objects
    mega_state_target_db = MegaState_Target.disconnect_object_db()
    # Number of different target schemes:
    scheme_n = 0
    for x in (key for key in mega_state_target_db.iterkeys()
              if isinstance(key, tuple)):
        scheme_n += 1
    return result, scheme_n
예제 #6
0
파일: state.py 프로젝트: liancheng/rose
def combine_maps(StateA, StateB):
    """RETURNS:

          -- Transition map = combined transition map of StateA and StateB.

          -- List of target schemes that have been identified.

       NOTE: 

       If the entries of both states are uniform, then a transition to itself
       of both states can be implemented as a recursion of the template state
       without knowing the particular states.

       EXPLANATION:
    
       This function combines two transition maps. A transition map is a list
       of tuples:

            [
              ...
              (interval, target)
              ...
            ]

       Each tuple tells about a character range [interval.begin, interval.end)
       where the state triggers to the given target. In a normal AnalyzerState
       the target is the index of the target state. In a TemplateState, though,
       multiple states are combined. A TemplateState operates on behalf of a
       state which is identified by its 'state_key'. 
       
       If two states (even TemplateStates) are combined the trigger maps
       are observed, e.g.

            Trigger Map A                    Trigger Map B
                                                                          
            [                                [
              ([0,  10),   DropOut)            ([0,  10),   State_4)
              ([10, 15),   State_0)            ([10, 15),   State_1)
              ([15, 20),   DropOut)            ([15, 20),   State_0)
              ([20, 21),   State_1)            ([20, 21),   DropOut)
              ([21, 255),  DropOut)            ([21, 255),  State_0)
            ]                                ]                           


       For some intervals, the target is the same. But for some it is different.
       In a TemplateState, the intervals are associated with MegaState_Target 
       objects. A MegaState_Target object tells the target state dependent
       on the 'state_key'. The above example may result in a transition map
       as below:

            Trigger Map A                   
                                                                          
            [     # intervals:   target schemes:                           
                  ( [0,  10),    { A: DropOut,   B: State_4, },
                  ( [10, 15),    { A: State_0,   B: State_1, },
                  ( [15, 20),    { A: DropOut,   B: State_0, },
                  ( [20, 21),    { A: State_1,   B: DropOut, },
                  ( [21, 255),   { A: DropOut,   B: State_0, },
            ]                                                           

       Note, that the 'scheme' for interval [12, 20) and [21, 255) are identical.
       We try to profit from it by storing only it only once. A template scheme
       is associated with an 'index' for reference.

       TemplateStates may be combined with AnalyzerStates and other TemplateStates.
       Thus, MegaState_Targets must be combined with trigger targets
       and other MegaState_Targets.

       NOTE:

       The resulting target map results from the combination of both transition
       maps, which may introduce new borders, e.g.
    
                     |----------------|           (where A triggers to X)
                          |---------------|       (where B triggers to Y)

       becomes
                     |----|-----------|---|
                        1       2       3

       where:  Domain:     A triggers to:     B triggers to:
                 1              X               Nothing
                 2              X                  Y
                 3           Nothing               Y

    -----------------------------------------------------------------------------
    Transition maps of TemplateState-s function based on 'state_keys'. Those state
    keys are used as indices into TemplateMegaState_Targets. The 'state_key' of a given
    state relates to the 'state_index' by

        (1)    self.state_index_sequence[state_key] == state_index

    where 'state_index' is the number by which the state is identified inside
    its state machine. Correspondingly, for a given TemplateMegaState_Target T 

        (2)                   T[state_key]

    gives the target of the template if it operates for 'state_index' determined
    from 'state_key' by relation (1). The state index list approach facilitates the
    computation of target schemes. For this reason no dictionary
    {state_index->target} is used.
    """
    transition_map_tools.assert_adjacency(StateA.transition_map, TotalRangeF=True)
    transition_map_tools.assert_adjacency(StateB.transition_map, TotalRangeF=True)

    MegaState_Target.init() # Initialize the tracking of generated MegaState_Target-s
    factory = TargetFactory(StateA, StateB)
    result  = []
    for begin, end, a_target, b_target in transition_map_tools.zipped_iterable(StateA.transition_map, 
                                                                               StateB.transition_map):
        target = factory.get(a_target, b_target)
        result.append((Interval(begin, end), target))

    # Return the database of generated MegaState_Target objects
    mega_state_target_db = MegaState_Target.disconnect_object_db()
    # Number of different target schemes:
    scheme_n = 0
    for x in (key for key in mega_state_target_db.iterkeys() if isinstance(key, tuple)):
        scheme_n += 1
    return result, scheme_n