def addNewProduction(self):
     """
     Adds a new empty production.
     """
     newProduction = ParametricProduction()
     newProduction.setGlobals(self.globalDefines)
     self.productions.append(newProduction)
     return newProduction
 def iterate_loop(self, N):
     if N is None: N = self.niterations
     currentParametricString = ParametricString.copyFrom(self.axiom) # We create a copy so to not modify the axiom
     #self.axiom.evaluateDefines()
     #print(self)
     #print(self.globalDefines)
     for i in range(N):
         if self.verbose: print("\nStep " + str(i+1))
         currentParametricString.resetConversions()
         # All productions are applied in parallel
         for prod in self.productions:
             if self.verbose: print("Rule: " + str(prod))
             result = prod.check(currentParametricString,self.rnd)
             #print("Rule evaluates: " +  str(result))
             if result:  currentParametricString = prod.convert(currentParametricString)
         if self.verbose: print("String at step " + str(i+1) + " is " + str(currentParametricString))
         ParametricProduction.resetStochasticState()
     currentParametricString.evaluateDefines()
     return currentParametricString
    print("\nCreation")
    pl = ParametricLSystem(verbose=True)

    print("\nAdd define")
    pl.addGlobalDefine("a",1)
    print(pl.globalDefines)

    print("\nOverride define")
    pl.overrideGlobalDefine("a",2)
    print(pl.globalDefines)

    print("\nSet axiom")
    pl.setAxiomFromString("A")
    print(pl)

    print("\nAdd production: from string")
    pl.addProductionFromString("F:*->FA")
    print(pl)

    print("\nAdd production: from existing")
    pp = ParametricProduction()
    pp.parseString('F:*->FF')
    pl.addExistingProduction(pp)
    print(pl)

    print("\nCheck all global defines")
    pl.printGlobalDefinesStatus()

    print("\nFinish testing  ParametricLSystem")