def align(self, mt_xml_a, mt_xml_b):
        '''
            Assuming mt_xml_a and mt_xml_b are from the same template
            mt_xml_a : query
            mt_xml_b : retrieved
        '''
        mt_xml_tounify_a = deepcopy(mt_xml_a)
        mt_xml_tounify_b = deepcopy(mt_xml_b)

        level_unif_a = self.__unify(mt_xml_tounify_a, 1)
        level_unif_b = self.__unify(mt_xml_tounify_b, 2)

        #descendingly order
        level_unif_a = sorted(level_unif_a.iteritems(),
                              key=lambda dt: dt[0],
                              reverse=True)
        level_unif_b = sorted(level_unif_b.iteritems(),
                              key=lambda dt: dt[0],
                              reverse=True)

        #    print "A", mt_xml_a, [(k, etree.tostring(v)) for k, v in level_unif_a]
        #    print "B", mt_xml_b, [(k, etree.tostring(v)) for k, v in level_unif_b]
        #    print
        str_flattener = MathML2String()
        unif = UnifiableProlog("./unify.pl")

        for level_a, exp_a in level_unif_a:
            for level_b, exp_b in level_unif_b:
                #if etree.tostring(exp_a) == etree.tostring(exp_b):
                mt_str_a = str_flattener.convert(exp_a)
                mt_str_b = str_flattener.convert(exp_b)
                is_aligned = unif.is_unified(mt_str_a, mt_str_b)
                if is_aligned:
                    return True
        return False
Exemple #2
0
    def align(self, mt_str_a, mt_str_b):
        '''
            Assuming mt_xml_a and mt_xml_b are from the same template
            mt_xml_a : query
            mt_xml_b : retrieved
        '''
        mt_xml_a = etree.fromstring(self.__handle_qvar(mt_str_a))
        mt_xml_b = etree.fromstring(mt_str_b)
        mt_xml_tounify_a = deepcopy(mt_xml_a)
        mt_xml_tounify_b = deepcopy(mt_xml_b)

        level_unif_a = self.__get_subexps(mt_xml_tounify_a, 1)
        level_unif_b = self.__get_subexps(mt_xml_tounify_b, 2)

        #descendingly order
        level_unif_a = sorted(level_unif_a.iteritems(), key = lambda dt: dt[0], reverse = True)
        level_unif_b = sorted(level_unif_b.iteritems(), key = lambda dt: dt[0])
        
        str_flattener_a = MathML2String(1, True)
        str_flattener_b = MathML2String(2, False)

        unif = UnifiableProlog("./unify.pl")

#        print etree.tostring(mt_xml_tounify_a)
        mt_str_a, mapping_invalid, index_invalid = str_flattener_a.convert(etree.ElementTree(mt_xml_tounify_a), {}, 0)
#        print index_invalid, mapping_invalid
        for level_b, exps_b in level_unif_b:
            for exp_b in exps_b:
                mapping_invalid_b = deepcopy(mapping_invalid)
                mt_str_b, _, _ = str_flattener_b.convert(etree.ElementTree(exp_b), mapping_invalid_b, index_invalid)
                if mt_str_b == "": return None, False
                is_aligned = unif.is_unified(mt_str_a, mt_str_b)
                if is_aligned: 
                    return level_b, True
        return None, False
    def align(self, mt_xml_a, mt_xml_b):
        '''
            Assuming mt_xml_a and mt_xml_b are from the same template
            mt_xml_a : query
            mt_xml_b : retrieved
        '''
        mt_xml_tounify_a = deepcopy(mt_xml_a)
        mt_xml_tounify_b = deepcopy(mt_xml_b)

        level_unif_a = self.__unify(mt_xml_tounify_a, 1)
        level_unif_b = self.__unify(mt_xml_tounify_b, 2)

        #descendingly order
        level_unif_a = sorted(level_unif_a.iteritems(), key = lambda dt: dt[0], reverse = True)
        level_unif_b = sorted(level_unif_b.iteritems(), key = lambda dt: dt[0], reverse = True)
        
    #    print "A", mt_xml_a, [(k, etree.tostring(v)) for k, v in level_unif_a]
    #    print "B", mt_xml_b, [(k, etree.tostring(v)) for k, v in level_unif_b]
    #    print 
        str_flattener = MathML2String()
        unif = UnifiableProlog("./unify.pl")

        for level_a, exp_a in level_unif_a:
            for level_b, exp_b in level_unif_b:
                #if etree.tostring(exp_a) == etree.tostring(exp_b):
                mt_str_a = str_flattener.convert(exp_a)
                mt_str_b = str_flattener.convert(exp_b)
                is_aligned = unif.is_unified(mt_str_a, mt_str_b)
                if is_aligned: 
                    return True
        return False
Exemple #4
0
    def align(self, mt_str_a, mt_str_b):
        '''
            Assuming mt_xml_a and mt_xml_b are from the same template
            mt_xml_a : query
            mt_xml_b : retrieved
        '''
        mt_xml_a = etree.fromstring(self.__handle_qvar(mt_str_a))
        mt_xml_b = etree.fromstring(mt_str_b)
        mt_xml_tounify_a = deepcopy(mt_xml_a)
        mt_xml_tounify_b = deepcopy(mt_xml_b)

        level_unif_a = self.__get_subexps(mt_xml_tounify_a, 1)
        level_unif_b = self.__get_subexps(mt_xml_tounify_b, 2)

        #descendingly order
        level_unif_a = sorted(level_unif_a.iteritems(),
                              key=lambda dt: dt[0],
                              reverse=True)
        level_unif_b = sorted(level_unif_b.iteritems(), key=lambda dt: dt[0])

        str_flattener_a = MathML2String(1, True)
        str_flattener_b = MathML2String(2, False)

        unif = UnifiableProlog("./unify.pl")

        #        print etree.tostring(mt_xml_tounify_a)
        mt_str_a, mapping_invalid, index_invalid = str_flattener_a.convert(
            etree.ElementTree(mt_xml_tounify_a), {}, 0)
        #        print index_invalid, mapping_invalid
        for level_b, exps_b in level_unif_b:
            for exp_b in exps_b:
                mapping_invalid_b = deepcopy(mapping_invalid)
                mt_str_b, _, _ = str_flattener_b.convert(
                    etree.ElementTree(exp_b), mapping_invalid_b, index_invalid)
                if mt_str_b == "": return None, False
                is_aligned = unif.is_unified(mt_str_a, mt_str_b)
                if is_aligned:
                    return level_b, True
        return None, False
from unify_prolog import UnifiableProlog

up = UnifiableProlog("./unify.pl")
assert (up.is_unified("A^2+x", "C+x"))
assert (up.is_unified("A+x", "C+d") is False)
assert (up.is_unified("(msup(A,2)+mfrac(msqrt(B),C))", "(msup(E,2)+D)"))
assert (up.is_unified("(msup(A,2)+mfrac(msqrt(B),C))", "(E+D)"))
from unify_prolog import UnifiableProlog

up = UnifiableProlog("./unify.pl")
assert(up.is_unified("A^2+x", "C+x"))
assert(up.is_unified("A+x", "C+d") is False)
assert(up.is_unified("(msup(A,2)+mfrac(msqrt(B),C))", "(msup(E,2)+D)"))
assert(up.is_unified("(msup(A,2)+mfrac(msqrt(B),C))", "(E+D)"))