Changeset 418

Timestamp:

Jun 9, 2010 12:14:27 PM (14 years ago)

Author:

Anya Helene Bagge

Message:

• random generator for terms
• tests and axioms for term matching
• fix term matcher

Location:

trunk/MagnoliaPlugin/src/org/magnolialang/parsetree

Files:

• TestXaTree.java (added)
• XaTreeFactory.java (modified) (3 diffs)

trunk/MagnoliaPlugin/src/org/magnolialang/parsetree/XaTreeFactory.java

@@ -1 +1 @@
 package org.magnolialang.parsetree;
 
+import java.util.Random;
+
 import org.eclipse.imp.pdb.facts.IConstructor;
+import org.eclipse.imp.pdb.facts.IInteger;
 import org.eclipse.imp.pdb.facts.IList;
+import org.eclipse.imp.pdb.facts.IListWriter;
+import org.eclipse.imp.pdb.facts.IMap;
+import org.eclipse.imp.pdb.facts.IMapWriter;
+import org.eclipse.imp.pdb.facts.ITuple;
 import org.eclipse.imp.pdb.facts.IValue;
 import org.eclipse.imp.pdb.facts.IValueFactory;
@@ -11 +18 @@
 
 public class XaTreeFactory {
+        private static final int RANDOM_CHANCE_CONS = 35;
+        private static final int RANDOM_CHANCE_SEQ = 45;
+        private static final int RANDOM_CHANCE_LEAF = 100;
+        private static final int RANDOM_MAX_CHILDREN = 5;
         public static TypeStore ts = new TypeStore(
                         org.rascalmpl.values.uptr.Factory.getStore(),
@@ -89 +100 @@
                 return vf.constructor(Type_Child, vf.integer(index));
         }
+
+        public static IConstructor randomTree(Random random) {
+                return (IConstructor) randomTreeWithVars(random, 0, new UniqueGen("x"), 100, 1000);
+        }
+        
+        public static ITuple randomTreeWithVars(Random random, int varChance) {
+                return randomTreeWithVars(random, varChance, new UniqueGen("x"), 100, 5000);
+        }
+        
+        private static ITuple randomTreeWithVars(Random random, int varChance, UniqueGen gen, int maxDepth, int maxSize) {
+
+                IConstructor tree, varTree;
+                IMap env;
+                int r = (int) (random.nextInt(100)*((150.0-maxDepth)/100.0));
+                int size = 1;
+                IConstructor var = null;
+                
+                if(random.nextInt(100) < varChance) {
+                        var = termvar(gen.next(), "foo");
+                        varChance = 0;
+                }
+                
+                if(r < RANDOM_CHANCE_SEQ && maxDepth > 0) {
+                        
+                        //int num = (int) (RANDOM_MAX_CHILDREN*Math.pow(Math.abs(random.nextGaussian()), 2));
+                        //System.out.println(num);
+                        IListWriter lw1 = vf.listWriter(Type_XaTree);
+                        IListWriter lw2 = vf.listWriter(Type_XaTree);
+                        IMapWriter envw = vf.mapWriter(Type_TermVar, Type_XaTree);
+                        while(random.nextDouble() < 0.6 && maxSize > 0) {
+                                ITuple child = randomTreeWithVars(random, varChance, gen, maxDepth-1, maxSize-1);
+                                maxSize -= ((IInteger)child.get(3)).intValue();
+                                size += ((IInteger)child.get(3)).intValue();
+                                lw1.append(child.get(0));
+                                lw2.append(child.get(1));
+                                envw.putAll((IMap) child.get(2));
+                        }
+
+                        env = envw.done();
+                        if(r < RANDOM_CHANCE_CONS) {
+                                tree = cons("foo", "foo", lw1.done());
+                                varTree = cons("foo", "foo", lw2.done());
+                        }
+                        else {
+                                tree = seq("foo", lw1.done());
+                                varTree = seq("foo", lw2.done());
+                        }
+                }
+                else { // if(r < RANDOM_CHANCE_LEAF) {
+                        int num = random.nextInt(RANDOM_MAX_CHILDREN) + 1;
+                        StringBuffer s = new StringBuffer(num);
+                        for(int i = 0; i < num; i++)
+                                s.append((char)(random.nextInt('Z'-'A')+'A' + (random.nextBoolean() ? 0 : 'a'-'A')));
+                        tree = leaf(s.toString(), "foo");
+                        varTree =  leaf(s.toString(), "foo");
+                        env = vf.map(Type_TermVar, Type_XaTree);
+                        maxSize--;
+                }
+                
+                if(var != null) {
+                        env = env.put(var, varTree);
+                        varTree = var;
+                }
+                return vf.tuple(tree, varTree, env, vf.integer(size));
+        }
+        
+        
 }
+class UniqueGen {
+        String name;
+        int counter;
+        
+        public UniqueGen(String name) {
+                this.name = name;
+                this.counter = 0;
+        }
+        
+        String next() {
+                return name + counter++;
+        }
+}