def toYicesTerms():

        retval = []

        for i in range(0, Configuration.bot_count):
            retval.append(
                Terms.eq(
                    Terms.application(YicesSignature.b_op,
                                      [YicesSignature.integer(i)]),
                    YicesSignature.thing_map[SymbolTable.bot_name(i)]))
            #sb.append(f'(assert (= (b {i}) b{i}))\n')

        for i in range(0, Configuration.pt2_count):
            x = i / Configuration.grid_dimension[1]
            y = i % Configuration.grid_dimension[1]
            retval.append(
                Terms.eq(
                    Terms.application(
                        YicesSignature.pt_op,
                        [YicesSignature.integer(x),
                         YicesSignature.integer(y)]),
                    YicesSignature.pt2_map[SymbolTable.pt2_name(i)]))

            #sb.append(f'(assert (= (pt {x} {y}) pt_{x}_{y}))\n')

        return retval
Esempio n. 2
0
    def toConstraintTerm(self, maxTimeStamp=None):

        if self.name == SymbolTable.MAXTIME:
            assert maxTimeStamp is not None
            yterm = Terms.get_by_name(SymbolTable.MAXTIME)
            assert yterm is not None
            return Terms.eq(yterm, YicesSignature.integer(maxTimeStamp))

        def constrainVariable(maxValue):
            if maxValue is not None:
                ymax = None
                if maxValue == SymbolTable.MAXTIME:
                    ymax = Terms.get_by_name(SymbolTable.MAXTIME)
                else:
                    ymax = YicesSignature.integer(maxValue)

                yterms = [ Terms.arith_leq_atom(YicesSignature.integer(0), self.yices_term),
                           Terms.arith_leq_atom(self.yices_term, ymax) ]
                return Terms.yand(yterms)
            return Terms.arith_leq_atom(YicesSignature.integer(0), self.yices_term)

        if self.vartype.name == SymbolTable.TIME:
            return constrainVariable(SymbolTable.MAXTIME)
        if self.vartype.name == SymbolTable.STAGE:
            return constrainVariable(Configuration.stage_count - 1)
        if self.vartype.name == SymbolTable.NAT:
            if self.yices_type == SymbolTable.BINDEX:
                return constrainVariable(Configuration.bot_count - 1)
            if self.yices_type == SymbolTable.OBINDEX:
                return constrainVariable(Configuration.obs_count - 1)
            if self.yices_type == SymbolTable.XAXIS:
                return constrainVariable(Configuration.grid_dimension[0] - 1)
            if self.yices_type == SymbolTable.YAXIS:
                return constrainVariable(Configuration.grid_dimension[1] - 1)
        return None
    def model2term(model):
        termlist = []
        #do the times
        for tvar in YicesSignature.get_vars(SymbolTable.TIME):
            ytvar = tvar.yices_term
            ytval = model.get_value_as_term(ytvar)
            termlist.append(Terms.arith_eq_atom(ytvar, ytval))

        #do the points
        for ptvar in YicesSignature.get_vars(SymbolTable.PT2):
            ytvar = ptvar.yices_term
            ytval = model.get_value(ytvar)
            termlist.append(Terms.eq(ytvar, ytval))

        #do the stages
        # FIXME:  more stuff needed here

        return Terms.yand(termlist)