Ejemplo para ast.NodeTransformer que muta una ecuación

Question

Esta es la continuación de mi última pregunta. Quiero analizar una ecuación y trabajar en lo que obtengo. Lo que quiero hacer es básicamente aleatorizarlo para que obtenga una nueva ecuación, que también tiene que ser una función válida. Esto se usará en un algoritmo genético.

Aquí es donde comienzo:

class Py2do(ast.NodeTransformer): 
def __init__(self): 
    self.tree=[] 
def generic_visit(self, node): 
    print type(node).__name__ 
    self.tree.append(type(node).__name__) 
    ast.NodeVisitor.generic_visit(self, node) 
    depth=3 
    s = node.__dict__.items() 
    s = " ".join("%s %r" % x for x in sorted(node.__dict__.items())) 
    print("%s%s\t%s" % (depth, str(type(node)), s)) 
    for x in ast.iter_child_nodes(node): 
     print (x, depth) 

def visit_Name(self, node): 
    # print 'Name :', node.id 
    pass 

def visit_Num(self, node): 
    print 'Num :', node.__dict__['n'] 

def visit_Str(self, node): 
    print "Str :", node.s 

def visit_Print(self, node): 
    print "Print :" 
    ast.NodeVisitor.generic_visit(self, node) 

def visit_Assign(self, node): 
    print "Assign :" 
    ast.NodeVisitor.generic_visit(self, node) 

def visit_Expr(self, node): 
    print "Expr :" 
    ast.NodeVisitor.generic_visit(self, node) 





if __name__ == '__main__': 
    node = ast.parse("res= e**(((-0.5*one)*((delta_w*one/delta*one)**2)))") 
    import ast_pretty 
    print ast.dump(node) 
    pprintAst(node) 
    v = Py2do() 
    v.visit(node) 
    print v.tree 

Lo que yo quiero salir es algo como esto:

res= e**(delta*((one/delta_w*one)**2))) 

u otra ecuación aleatoria válida de algún tipo. Esto se usará en un programa Fortran, por lo que sería bueno si la ecuación resultante también se puede transferir a Fortran. Por favor comente su código y proporcione una prueba de prueba/unidad de prueba.

Answer 1

¿Qué estás tratando de hacer? Buscar la permutación correcta de una ecuación puede ser fácil pero requiere mucho tiempo (n! Posibilidades), pero generar nuevas y optimizar las que usan un algoritmo genético es imposible porque no es un problema de optimización ... Por ejemplo, x^0.00 y x^0.01 son fundamentales diferentes. Además, no puede optimizar para el operador adecuado, simplemente no funcionará. Lo siento.

Aunque, la situación no es tan mala. Buscar la función correcta es una tarea extremadamente común. Ahora estoy asumiendo que no conoces la función, pero conoces un par de puntos de las mediciones (de todos modos, lo habrías necesitado para calcular la aptitud en tu algoritmo genético, ¿no?). Ahora puede usar Lagrange para obtener un polinomio que pase esos puntos dados. Hay dos buenos ejemplos en el medio del artículo de wikipedia, y lagrange es bastante fácil de implementar (supongo que 1< 10 líneas de código). También tenga en cuenta que tiene la capacidad de mejorar la precisión del polinomio simplemente agregando más puntos de referencia.

Answer 2

Así que la entrada y la salida de son Fortran? ¿Y quieres usar expresiones/declaraciones arbitrarias de Fortran? (Incluyendo rebanadas de matriz, ...?) Fortran es un lenguaje bastante complejo; leerlo requiere más o menos un analizador completo.

Tal vez usted desea utilizar una herramienta de transformación de programas que ya se puede manipular directamente Fortran. Tal herramienta leería el código de Fortran, construiría un AST, le permitirá "aleatorizarlo" usando un conjunto de transformaciones elegidas al azar, y luego regenerará el código Fortran válido.

Nuestro DMS Software Reengineering Toolkit con su Fortran front end se puede utilizar directamente para esto.

EDITAR Ago 26 de 2011: OP confirma que quiere "evolucionar" (transformar) código Fortran real. Vale la pena señalar que la construcción de un analizador de Fortran real (como la creación de analizadores sintácticos para cualquier otro lenguaje real) es bastante difícil; nos llevó meses y nuestras herramientas son realmente bueno en la definición de programas de análisis (que hemos hecho unos 40 idiomas y una variedad de dialectos utilizando DMS). Probablemente no sea una buena idea para él construir su propio analizador real de Fortran, al menos no si quiere continuar con su vida o su tarea real.

podría ser posible para OP para limitar el código Fortran a un subconjunto muy restringida, y construir un analizador sintáctico para eso.