| 
 1 | 
  
 |  | 
| 
 2 | 
  
 |  | 
| 
 3 | 
  
 |  | 
| 
 4 | 
  
 |  | 
| 
 5 | 
  
 |  | 
| 
 6 | 
  
 |  | 
| 
 7 | 
  
 |  | 
| 
 8 | 
  
 |  | 
| 
 9 | 
  
 |  | 
| 
 10 | 
  
 |  | 
| 
 11 | 
  
 |  | 
| 
 12 | 
  
 |  | 
| 
 13 | 
  
 |  | 
| 
 14 | 
  
 |  | 
| 
 15 | 
  
 |  | 
| 
 16 | 
  
 |  | 
| 
 17 | 
  
 |  | 
| 
 18 | 
  
 |  | 
| 
 19 | 
  
 |  | 
| 
 20 | 
  
 |  | 
| 
 21 | 
  
 |  | 
| 
 22 | 
  
 |  | 
| 
 23 | 
  
 |  | 
| 
 24 | 
  
 |  | 
| 
 25 | 
  
 |  | 
| 
 26 | 
  
 |  | 
| 
 27 | 
  
 |  | 
| 
 28 | 
  
 | package org.sat4j.minisat.orders; | 
| 
 29 | 
  
 |  | 
| 
 30 | 
  
 | import java.util.ArrayList; | 
| 
 31 | 
  
 | import java.util.Collections; | 
| 
 32 | 
  
 |  | 
| 
 33 | 
  
 | import org.sat4j.minisat.core.ILits; | 
| 
 34 | 
  
 | import org.sat4j.minisat.core.ILits23; | 
| 
 35 | 
  
 |  | 
| 
 36 | 
  
 |  | 
| 
 37 | 
  
 |  | 
| 
 38 | 
  
 |  | 
| 
 39 | 
  
 |  | 
| 
 40 | 
  
 |  | 
| 
 41 | 
  
 |  | 
| 
 42 | 
  
 |  | 
| 
 43 | 
  
 |  | 
| 
 44 | 
  
 | public class JWOrder extends VarOrder { | 
| 
 45 | 
  
 |  | 
| 
 46 | 
  
 |     private static final long serialVersionUID = 1L; | 
| 
 47 | 
  
 |  | 
| 
 48 | 
  
 |     private ILits23 lits; | 
| 
 49 | 
  
 |  | 
| 
 50 | 
 475778573
 |     private int computeWeight(int var) {
 | 
| 
 51 | 
 475778573
 |         final int p = (var << 1);
 | 
| 
 52 | 
 475778573
 |         int pos2 = lits.nBinaryClauses(p);
 | 
| 
 53 | 
 475778573
 |         int neg2 = lits.nBinaryClauses(p ^ 1);
 | 
| 
 54 | 
 475778573
 |         int pos3 = lits.nTernaryClauses(p);
 | 
| 
 55 | 
 475778573
 |         int neg3 = lits.nTernaryClauses(p ^ 1);
 | 
| 
 56 | 
 475778573
 |         return (pos2 * neg2 * 100 + pos2 + neg2) * 5 + pos3 * neg3 * 10 + pos3
 | 
| 
 57 | 
  
 |                 + neg3; | 
| 
 58 | 
  
 |     } | 
| 
 59 | 
  
 |  | 
| 
 60 | 
  
 |     class Temp implements Comparable<Temp> { | 
| 
 61 | 
  
 |         private int id; | 
| 
 62 | 
  
 |  | 
| 
 63 | 
  
 |         private int count; | 
| 
 64 | 
  
 |  | 
| 
 65 | 
 25475
 |         Temp(int id) {
 | 
| 
 66 | 
 25475
 |             this.id = id;
 | 
| 
 67 | 
 25475
 |             count = computeWeight(id >> 1);
 | 
| 
 68 | 
  
 |         } | 
| 
 69 | 
  
 |  | 
| 
 70 | 
 76834
 |         public int compareTo(Temp t) {
 | 
| 
 71 | 
 76834
 |             if (count == 0) {
 | 
| 
 72 | 
 49
 |                 return Integer.MAX_VALUE;
 | 
| 
 73 | 
  
 |             } | 
| 
 74 | 
 76785
 |             if (t.count == 0) {
 | 
| 
 75 | 
 10
 |                 return -1;
 | 
| 
 76 | 
  
 |             } | 
| 
 77 | 
 76775
 |             return t.count - count;
 | 
| 
 78 | 
  
 |         } | 
| 
 79 | 
  
 |  | 
| 
 80 | 
 0
 |         @Override
 | 
| 
 81 | 
  
 |         public String toString() { | 
| 
 82 | 
 0
 |             return "" + id + "(" + count + ")";
 | 
| 
 83 | 
  
 |         } | 
| 
 84 | 
  
 |     } | 
| 
 85 | 
  
 |  | 
| 
 86 | 
  
 |      | 
| 
 87 | 
  
 |  | 
| 
 88 | 
  
 |  | 
| 
 89 | 
  
 |  | 
| 
 90 | 
  
 |  | 
| 
 91 | 
 103
 |     @Override
 | 
| 
 92 | 
  
 |     public void setLits(ILits lits) { | 
| 
 93 | 
 103
 |         super.setLits(lits);
 | 
| 
 94 | 
 103
 |         this.lits = (ILits23) lits;
 | 
| 
 95 | 
  
 |     } | 
| 
 96 | 
  
 |  | 
| 
 97 | 
  
 |      | 
| 
 98 | 
  
 |  | 
| 
 99 | 
  
 |  | 
| 
 100 | 
  
 |  | 
| 
 101 | 
  
 |  | 
| 
 102 | 
 103
 |     @Override
 | 
| 
 103 | 
  
 |     public void init() { | 
| 
 104 | 
 103
 |         super.init();
 | 
| 
 105 | 
 103
 |         ArrayList<Temp> v = new ArrayList<Temp>(order.length);
 | 
| 
 106 | 
  
 |  | 
| 
 107 | 
 103
 |         for (int i = 1; i < order.length; i++) {
 | 
| 
 108 | 
 25475
 |             Temp t = new Temp(order[i]);
 | 
| 
 109 | 
 25475
 |             v.add(t);
 | 
| 
 110 | 
  
 |         } | 
| 
 111 | 
 103
 |         Collections.sort(v);
 | 
| 
 112 | 
  
 |          | 
| 
 113 | 
 103
 |         for (int i = 0; i < v.size(); i++) {
 | 
| 
 114 | 
 25475
 |             Temp t = v.get(i);
 | 
| 
 115 | 
 25475
 |             order[i + 1] = t.id;
 | 
| 
 116 | 
 25475
 |             int index = t.id >> 1;
 | 
| 
 117 | 
 25475
 |             varpos[index] = i + 1;
 | 
| 
 118 | 
 25475
 |             activity[t.id >> 1] = t.count;
 | 
| 
 119 | 
  
 |         } | 
| 
 120 | 
 103
 |         lastVar = 1;
 | 
| 
 121 | 
  
 |  | 
| 
 122 | 
  
 |     } | 
| 
 123 | 
  
 |  | 
| 
 124 | 
  
 |      | 
| 
 125 | 
  
 |  | 
| 
 126 | 
  
 |  | 
| 
 127 | 
  
 |  | 
| 
 128 | 
  
 |  | 
| 
 129 | 
 475753098
 |     @Override
 | 
| 
 130 | 
  
 |     protected void updateActivity(int var) { | 
| 
 131 | 
 475753098
 |         activity[var] = computeWeight(var);
 | 
| 
 132 | 
  
 |     } | 
| 
 133 | 
  
 |  | 
| 
 134 | 
 0
 |     @Override
 | 
| 
 135 | 
  
 |     public String toString() { | 
| 
 136 | 
 0
 |         return "Jeroslow-Wang static like heuristics updated when new clauses are learnt"; 
 | 
| 
 137 | 
  
 |     } | 
| 
 138 | 
  
 | } |