[procilege commit] r78 - in trunk/procilege/src: main/java/merisis/traitspace/impl main/java/merisis/util main/java/...
codesite...@google.com
Date: Thu Jun 14 01:13:20 2007
New Revision: 78
Modified:
trunk/procilege/src/main/java/merisis/traitspace/impl/SketchImpl.java
trunk/procilege/src/main/java/merisis/util/BitUtil.java
trunk/procilege/src/main/java/procilege/impl/PrivFormAnalysisImpl.java
trunk/procilege/src/test/java/procilege/test/PrivilegeCongruentTest.java
trunk/procilege/src/test/java/procilege/test/pal/AbstractPalTest.java
trunk/procilege/src/test/java/procilege/test/pal/RecursivePrivilegeTest.java
Log:
[Issue 34]Fixed the congruence of privilege.
Modified: trunk/procilege/src/main/java/merisis/traitspace/impl/SketchImpl.java
==============================================================================
--- trunk/procilege/src/main/java/merisis/traitspace/impl/SketchImpl.java (original)
+++ trunk/procilege/src/main/java/merisis/traitspace/impl/SketchImpl.java Thu Jun 14 01:13:20 2007
@@ -426,6 +426,9 @@
logger.finest(sb.toString());
}
+ if (traits == null)
+ return null;
+
traverse(traits);
if (focus == null || focus.isEmpty())
Modified: trunk/procilege/src/main/java/merisis/util/BitUtil.java
==============================================================================
--- trunk/procilege/src/main/java/merisis/util/BitUtil.java (original)
+++ trunk/procilege/src/main/java/merisis/util/BitUtil.java Thu Jun 14 01:13:20 2007
@@ -1,5 +1,8 @@
package merisis.util;
+import java.util.Collection;
+import java.util.Iterator;
+
import org.apache.solr.util.OpenBitSet;
public class BitUtil {
@@ -49,6 +52,37 @@
StringBuilder sb = new StringBuilder();
format(sb, bs, ",");
+ return sb.toString();
+ }
+
+ public static String toStringOfBitSetCollection(Collection<OpenBitSet> c) {
+
+ StringBuilder sb = new StringBuilder();
+ sb.append('{');
+
+ while (true) {
+
+ if (c == null)
+ break;
+
+ Iterator<OpenBitSet> itr = c.iterator();
+ if (itr.hasNext()) {
+ sb.append('{');
+ BitUtil.format(sb, itr.next(), ",");
+ sb.append('}');
+ }
+
+ while (itr.hasNext()) {
+ sb.append(',');
+ sb.append('{');
+ BitUtil.format(sb, itr.next(), ",");
+ sb.append('}');
+ }
+
+ break;
+ }
+ sb.append('}');
+
return sb.toString();
}
Modified: trunk/procilege/src/main/java/procilege/impl/PrivFormAnalysisImpl.java
==============================================================================
--- trunk/procilege/src/main/java/procilege/impl/PrivFormAnalysisImpl.java (original)
+++ trunk/procilege/src/main/java/procilege/impl/PrivFormAnalysisImpl.java Thu Jun 14 01:13:20 2007
@@ -1,5 +1,7 @@
package procilege.impl;
+import static merisis.util.BitUtil.toStringOfBitSetCollection;
+
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
@@ -143,8 +145,7 @@
if (pf2.isDirty)
expand(pf2);
- // because of the bitset, the two forms are parellel rigorously
-
+ // By the natural order of bitset, the two forms are parellel rigorously
// Although the parellel forms,
// check the cardinalities first in an economic intention
if (pf1.reducedFunctions.cardinality() != pf2.reducedFunctions
@@ -190,13 +191,32 @@
}
}
- // assert the entity equivalence being inavailable
- if (!isEntitySetEquivalent(f1EntGroup, f2EntGroup))
- return false;
+ if (logger.isLoggable(Level.FINEST)) {
+
+ logger.finest(String.format(
+ "proc of func %d, avail: %s == %s; inavail: %s == %s",
+ i, toStringOfBitSetCollection(t1EntGroup),
+ toStringOfBitSetCollection(t2EntGroup),
+ toStringOfBitSetCollection(f1EntGroup),
+ toStringOfBitSetCollection(f2EntGroup)));
+ }
// assert the entity equivalence being available
- if (!isEntitySetEquivalent(t1EntGroup, t2EntGroup))
+ if (!isEntitySetEquivalent(t1EntGroup, t2EntGroup)) {
+ if (logger.isLoggable(Level.FINEST)) {
+ logger.finest("the available proceses is not proofed!");
+ }
+ return false;
+ }
+
+ // assert the entity equivalence being inavailable
+ if (!f1EntGroup.isEmpty() && !f2EntGroup.isEmpty()
+ && !isEntitySetEquivalent(f1EntGroup, f2EntGroup)) {
+ if (logger.isLoggable(Level.FINEST)) {
+ logger.finest("the inavailable proceses is not proofed!");
+ }
return false;
+ }
i = pf1.reducedFunctions.nextSetBit(i + 1);
j = pf2.reducedFunctions.nextSetBit(j + 1);
@@ -205,14 +225,6 @@
return true;
}
- private void addSquare(Collection<OpenBitSet>[] s, int m, OpenBitSet elem) {
-
- if (s[m] == null)
- s[m] = new HashSet<OpenBitSet>();
-
- s[m].add(elem);
- }
-
private boolean isEntitySetEquivalent(Collection<OpenBitSet> m,
Collection<OpenBitSet> n) {
@@ -221,8 +233,9 @@
for (OpenBitSet s : m) {
a[i++] = BitUtil.toArray(s);
}
-
+
long[][] b = new long[m.size()][];
+ i = 0;
for (OpenBitSet s : n) {
b[i++] = BitUtil.toArray(s);
}
Modified: trunk/procilege/src/test/java/procilege/test/PrivilegeCongruentTest.java
==============================================================================
--- trunk/procilege/src/test/java/procilege/test/PrivilegeCongruentTest.java (original)
+++ trunk/procilege/src/test/java/procilege/test/PrivilegeCongruentTest.java Thu Jun 14 01:13:20 2007
@@ -2,79 +2,59 @@
import static org.junit.Assert.assertTrue;
-import org.junit.Before;
+import org.junit.Assert;
import org.junit.Test;
-import procilege.impl.DefaultProcilegeModule;
-import procilege.lang.PrivExprMergence;
import procilege.lang.PrivilegeForm;
-import procilege.lang.PrivilegeFormAnalysis;
import procilege.test.pal.AbstractPalTest;
-import com.google.inject.Guice;
-import com.google.inject.Inject;
-import com.google.inject.Injector;
-
public class PrivilegeCongruentTest extends AbstractPalTest {
@Test
public void checkCongruency() {
- PrivilegeForm pnf;
-
- z.tell("let da0 is DA");
- z.tell("let da0 is DA");
- z.tell("let da1 is DA");
- z.tell("let da2 is DA");
+ Assert.assertEquals(2L, nm("DA"));
+ Assert.assertEquals(3L, nm("DB"));
+ Assert.assertEquals(4L, nm("DC"));
+ Assert.assertEquals(5L, nm("da0"));
+ Assert.assertEquals(6L, nm("da1"));
+ Assert.assertEquals(7L, nm("da2"));
+ Assert.assertEquals(8L, nm("db0"));
+ Assert.assertEquals(9L, nm("db1"));
+ Assert.assertEquals(10L, nm("db2"));
+ Assert.assertEquals(11L, nm("p1"));
+ Assert.assertEquals(12L, nm("g1"));
+ Assert.assertEquals(13L, nm("p2"));
+ Assert.assertEquals(14L, nm("g2"));
- z.tell("let db0 is DB");
- z.tell("let db1 is DB");
- z.tell("let db2 is DB");
+ PrivilegeForm pnf;
- z.tell("let da2 is DC");
- z.tell("let db2 is DC");
+ tell("let da0 is DA");
+ tell("let da0 is DA");
+ tell("let da1 is DA");
+ tell("let da2 is DA");
+
+ tell("let db0 is DB");
+ tell("let db1 is DB");
+ tell("let db2 is DB");
- z.tell("p1 := (r + w + d)/DA");
+ tell("let da2 is DC");
+ tell("let db2 is DC");
- z.tell("g1 := r/da0");
+ tell("p1 := (r + w + d)/DA");
+ tell("g1 := r/da0");
-
- dumpHistory(0, 100);
-
- z.print(z.ln("p1"));
- z.print(z.ln("g1"));
+ tell("p2 := (r + w + d)/DC");
+ tell("g2 := r/(da2||db2)");
- PrivExprMergence m;
- m = new PrivExprMergence(null);
- m.mergePrivilege(z.ln("p1"));
- m.mergePrivilege(z.ln("g1"));
- pnf = pfa.privform(m);
- z.print(pnf, "p1*g1");
- z.print(z.ln("g1"));
- assertTrue(pfa.congruent(pnf, pfa.privform(z.ln("g1"))));
-
- z.tell("p2 := (r + w + d)/DC");
- z.tell("g2 := r/(da2||db2)");
-
- m = new PrivExprMergence(null);
- m.mergePrivilege(z.ln("p2"));
- m.mergePrivilege(z.ln("g2"));
- pnf = pfa.privform(m);
- z.print(pnf, "p2*g2");
- z.print(z.ln("g2"));
- assertTrue(pfa.congruent(pnf, pfa.privform(z.ln("g2"))));
- }
-
- @Inject
- private TestZero z;
-
- @Inject
- private PrivilegeFormAnalysis pfa;
-
- @Before
- public void initProcilege() {
- Injector guice = Guice.createInjector(new DefaultProcilegeModule(), TestZero.module());
+ dumpHistory(0, 100);
- guice.injectMembers(this);
+ // p1 * g1
+ pnf = pfa.privform(pvm(nn("p1"), nn("g1")));
+ assertTrue(pfa.congruent(pnf, pfa.privform(nn("g1"))));
+
+ // p2 * g2
+ pnf = pfa.privform(pvm(nn("p2"), nn("g2")));
+ assertTrue(pfa.congruent(pnf, pfa.privform(nn("g2"))));
}
}
Modified: trunk/procilege/src/test/java/procilege/test/pal/AbstractPalTest.java
==============================================================================
--- trunk/procilege/src/test/java/procilege/test/pal/AbstractPalTest.java (original)
+++ trunk/procilege/src/test/java/procilege/test/pal/AbstractPalTest.java Thu Jun 14 01:13:20 2007
@@ -10,6 +10,7 @@
import merisis.util.BitUtil;
import org.apache.solr.util.OpenBitSet;
+import org.junit.After;
import org.junit.Before;
import procilege.Procilege;
@@ -79,6 +80,7 @@
return new NameImpl(smr.sense(qn));
}
+
public void dumpHistory(int from, int to) {
@@ -109,6 +111,14 @@
TestZero.module());
guice.injectMembers(this);
+
+ mvm.give(nm("TC"));
+ mvm.stepin();
+ }
+
+ @After
+ public void aftercase() {
+ mvm.stepout();
}
/**
Modified: trunk/procilege/src/test/java/procilege/test/pal/RecursivePrivilegeTest.java
==============================================================================
--- trunk/procilege/src/test/java/procilege/test/pal/RecursivePrivilegeTest.java (original)
+++ trunk/procilege/src/test/java/procilege/test/pal/RecursivePrivilegeTest.java Thu Jun 14 01:13:20 2007
@@ -12,42 +12,35 @@
@Test
public void norm() {
- mvm.give(nm("TT"));
- try {
+ PrivExprComposition pfexpr;
- PrivExprComposition pfexpr;
-
- z.tell("p := p");
- pfexpr = pfa.normlize(z.ln("p"));
- z.printExpr(pfexpr);
- assertEquals(1, pfexpr.size());
- dumpHistory(0, 20);
- assertTrue(z.available(z.ln("p")));
-
- z.tell("p := p/p*[1==1]");
- pfexpr = pfa.normlize(z.ln("p"));
- z.printExpr(pfexpr);
- assertEquals(1, pfexpr.size());
- assertTrue(z.available(z.ln("p")));
-
- z.tell("p := a + p");
- pfexpr = pfa.normlize(z.ln("p"));
- z.printExpr(pfexpr);
- assertEquals(2, pfexpr.size());
- assertTrue(z.available(z.ln("p")));
-
- z.tell("p := a + q");
- z.tell("q := b + p");
- pfexpr = pfa.normlize(z.ln("p"));
- // pfexpr = pfa.normlize(z.ln("q"));
- z.printExpr(pfexpr);
- assertEquals(3, pfexpr.size());
- pfexpr = pfa.normlize(z.ln("q"));
- assertEquals(3, pfexpr.size());
- assertTrue(z.available(z.ln("q")));
-
- } finally {
- mvm.stepout();
- }
+ tell("p := p");
+ pfexpr = pfa.normlize(z.ln("p"));
+ z.printExpr(pfexpr);
+ assertEquals(1, pfexpr.size());
+ dumpHistory(0, 20);
+ assertTrue(z.available(z.ln("p")));
+//
+// z.tell("p := p/p*[1==1]");
+// pfexpr = pfa.normlize(z.ln("p"));
+// z.printExpr(pfexpr);
+// assertEquals(1, pfexpr.size());
+// assertTrue(z.available(z.ln("p")));
+//
+// z.tell("p := a + p");
+// pfexpr = pfa.normlize(z.ln("p"));
+// z.printExpr(pfexpr);
+// assertEquals(2, pfexpr.size());
+// assertTrue(z.available(z.ln("p")));
+//
+// z.tell("p := a + q");
+// z.tell("q := b + p");
+// pfexpr = pfa.normlize(z.ln("p"));
+// // pfexpr = pfa.normlize(z.ln("q"));
+// z.printExpr(pfexpr);
+// assertEquals(3, pfexpr.size());
+// pfexpr = pfa.normlize(z.ln("q"));
+// assertEquals(3, pfexpr.size());
+// assertTrue(z.available(z.ln("q")));
}
}