Exemple #1
0
def grow_domain(domain_states, transitions, depth, validity_test=None):
    """
    Returns domain_states grown by depth along transitions.
    
    Resulting states are filtered by the validity_test. By default,
    only states without a negative coordinate are valid.
    """
    if numpy.size(domain_states) == 0:
        raise ValueError('there must be at least one state to expand')

    if validity_test is None:
        validity_test = non_neg_states

    expanded_states = domain_states
    for _ in xrange(depth):
        # expand support states by one along each state transition
        for transition in transitions:
            shifted_states = lexarrayset.shift(domain_states, transition)
            # filter invalid states (ie states with a negative coord)
            valid = validity_test(shifted_states)
            #import pdb
            #if numpy.sum(valid) != shifted_states.shape[1]:
            #    pdb.set_trace()
            shifted_states = shifted_states[:, valid]
            expanded_states = lexarrayset.union(expanded_states,
                                                shifted_states)
        domain_states = expanded_states

    return expanded_states, expanded_states, 0
Exemple #2
0
    def step(self, t, epsilon):
        """
        Advance solution to time ``t`` at the cost of at most ``epsilon`` error.
        """

        step_epsilon = self.solver.restore_point_error + epsilon
        number_of_states = numpy.size(self.domain_states, 1)
	
	step_fail_counter = 0
	
        while True:
            
            self.solver.step(t)
            p, p_sink = self.solver.y
            
            
            if (step_fail_counter !=0 and self.domain_expander.name == 'GORDE'):
				self.solver.set_restore_point()
				break
            
            if p_sink > step_epsilon:
            
            	step_fail_counter = step_fail_counter + 1
            	
            	if step_fail_counter == 1:
            	        	
                	self.domain_expander.Gtau = self.domain_expander.Gtau_default
                	
                	expanded_states, nabla, u = self.domain_expander.expand(
                    		domain_states = self.solver.restore_args['domain_states'],
                    		p = self.solver.restore_args['p_0'],
                    		p_sink = p_sink,
                    		t = t
                	)
                else:
                	#print(" Failed first run ")
                	self.domain_expander.Rtau = self.domain_expander.Gtau
                	self.domain_expander.Gtau = self.domain_expander.Gtau**(10**(-2))
                	some_expanded_states, nabla, u = self.domain_expander.expand(
                		domain_states = nabla,
                		p = u,
                		t = t
                	)
                	
                	# Need to add the new states to the expanded_states.
                	
                	expanded_states = lexarrayset.union(some_expanded_states,expanded_states)
                	
                # we need to translate the dense p, defined wrt to
                # an enum of the domain states, to a dense p wrt to
                # an enum of these new expanded domain states

                # get the domain states that p_0 is defined over

                if True:
                	p_0 = self.solver.restore_args['p_0']
                	p_0_domain = self.solver.restore_args['domain_enum'].states(
                    		numpy.arange(len(p_0)),
                	)
                # define the new state enum for the expanded domain
                
                expanded_enum = state_enum.StateEnum(expanded_states)
                # figure out the indices to store each domain state in
                # according to the new state enum
                domain_indices = expanded_enum.indices(p_0_domain)
                # make a new dense distribution
                expanded_p_0 = numpy.zeros(
                    (expanded_enum.size, ),
                    dtype = numpy.float
                )
                # copy the probabilities from p_0 across into the
                # correct indices of the expanded version of p_0
                expanded_p_0[domain_indices] = p_0
                # update fsp solver bookkeeping
                self.domain_states = expanded_states
                self.domain_enum = expanded_enum
                # check that expansion did in fact add some extra states
                if numpy.size(self.domain_states, 1) <= number_of_states:
                    lament = 'expansion did not increase size of domain'
                    raise ExpansionFailureError(lament)
                # restore solver to previous state, but use expanded domain
                self.solver.restore(
                    domain_states = self.domain_states,
                    domain_enum = self.domain_enum,
                    p_0 = expanded_p_0,
                )
            else:
            	self.solver.set_restore_point()
                break