use is_clockwise, is_counter_clockwise, Formula, use properties

Author: adrianliaw

pycuber/cube.py

@@ -445,7 +445,7 @@ def _single_layer(self, step):
             "E": ("UD", "LFRB"), 
             }[step.face]
         if len(movement) == 2: slice_, movement = movement
-        if step.is_inverse: movement = movement[::-1]
+        if step.is_counter_clockwise: movement = movement[::-1]
         if step.face not in "MSE":
             to_move = {c.copy() for c in self.at_face(step.face)}
         else:
@@ -491,7 +491,7 @@ def _other_rotations(self, step):
             }[step.face]
         for s in movement:
             step_ = Step(s)
-            if step.is_inverse: step_ = step_.inverse()
+            if step.is_counter_clockwise: step_ = step_.inverse()
             elif step.is_180: step_ = step_ * 2
             _single_layer(self, step_)
         return self

pycuber/formula.py

@@ -40,16 +40,16 @@ class Step(object):
     U'
 
     You can check if it's clockwise (ex: U), counter-clockwise (ex: U'), or 180 degrees (ex: U2)
-    >>> r.is_standard
+    >>> r.is_clockwise
     True
-    >>> r.is_inverse
+    >>> r.is_counter_clockwise
     False
     >>> r.is_180
     False
 
-    >>> u_prime.is_standard
+    >>> u_prime.is_clockwise
     False
-    >>> u_prime.is_inverse
+    >>> u_prime.is_counter_clockwise
     True
     >>> u_prime.is_180
     False
@@ -98,19 +98,21 @@ def __init__(self, name):
         try:
             if len(name) >= 2 and name[1] == "w":
                 name = name[0].lower() + name[2:]
+            if "i" in name:
+                name = name.replace("i", "'")
             if name[1:] == "2'":
                 name = name[0] + "2"
             if name[0] in "LUFDRBMSElufdrbxyz":
                 if name[1:] in ["", "'", "2"]:
-                    self.name = name
-                    self.face = name[0]
-                    self.is_inverse = (name[1:] == "'")
-                    self.is_standard = (name[1:] == "")
-                    self.is_180 = (name[1:] == "2")
+                    self.__name = lambda: name
+                    self.__face = lambda: name[0]
+                    self.__is_counter_clockwise = lambda: name[1:] == "'"
+                    self.__is_clockwise = lambda: name[1:] == ""
+                    self.__is_180 = lambda: name[1:] == "2"
                     return
             raise IndexError
         except IndexError:
-            raise ValueError("Invalid action name.")
+            raise ValueError("Invalid action name {0}".format(name))
 
     def __repr__(self):
         """
@@ -189,8 +191,8 @@ def __add__(self, another):
         if type(another) == str:
             another = Step(another)
         if self.face == another.face:
-            status = ((self.is_standard    + self.is_180*2    + self.is_inverse*3) + \
-                      (another.is_standard + another.is_180*2 + another.is_inverse*3)) % 4
+            status = ((self.is_clockwise    + self.is_180*2    + self.is_counter_clockwise*3) + \
+                      (another.is_clockwise + another.is_180*2 + another.is_counter_clockwise*3)) % 4
             try:
                 return Step(self.face + [None, "", "2", "'"][status])
             except TypeError: return None
@@ -234,7 +236,7 @@ def set_face(self, new_face):
         L2
         """
         if new_face in list("LUFDRBlufdrbMSExyz"):
-            return Step(new_face + "'" * self.is_inverse + "2" * self.is_180)
+            return Step(new_face + "'" * self.is_counter_clockwise + "2" * self.is_180)
         else:
             raise ValueError("Invalid name")
 
@@ -253,14 +255,34 @@ def inverse(self):
         >>> s.inverse()
         R2
         """
-        return Step(self.name[0] + ("" if self.is_inverse else "'" if self.is_standard else "2"))
+        return Step(self.name[0] + ("" if self.is_counter_clockwise else "'" if self.is_clockwise else "2"))
 
     def __hash__(self):
         """
         Step object is hashable.
         """
         return hash(self.name)
 
+    @property
+    def name(self):
+        return self.__name()
+
+    @property
+    def is_counter_clockwise(self):
+        return self.__is_counter_clockwise()
+
+    @property
+    def is_clockwise(self):
+        return self.__is_clockwise()
+
+    @property
+    def is_180(self):
+        return self.__is_180()
+
+    @property
+    def face(self):
+        return self.__face()
+
 
 
 class Formula(list):
@@ -653,7 +675,7 @@ def _optimise_rotations(self):
                 self.insert(0, _self[i])
             else:
                 cr_pattern = pattern[_self[i].face]
-                if _self[i].is_inverse:
+                if _self[i].is_counter_clockwise:
                     cr_pattern = cr_pattern[::-1]
                 for j in range(len(self)):
                     if self[j].face in cr_pattern:

pycuber/solver/__init__.py

@@ -4,7 +4,7 @@
 Usage: 
     >>> import pycuber as pc
     >>> from pycuber.solver import CFOPSolver
-    >>> rand_alg = pc.Algo().random()
+    >>> rand_alg = pc.Formula().random()
     >>> cube = pc.Cube()
     >>> cube(rand_alg)
     >>> solver = CFOPSolver(cube)

pycuber/solver/cfop/__init__.py

@@ -12,7 +12,7 @@ def feed(self, cube):
     def solve(self):
         if not self.cube.is_valid():
             raise ValueError("Invalid Cube.")
-        result = pycuber.Algo()
+        result = pycuber.Formula()
         sys.stdout.write("Solver starts....")
         sys.stdout.write("\rSolving Cross ......")
         solver = CrossSolver(self.cube)

pycuber/solver/cfop/cross.py

@@ -34,7 +34,7 @@ def _rotate(edges, step):
             "B": "ULDR", 
             }[step.face]
         movement = {
-            movement[i]: movement[(i + step.is_standard + (-1 * step.is_inverse) + (2 * step.is_180)) % 4]
+            movement[i]: movement[(i + step.is_clockwise + (-1 * step.is_counter_clockwise) + (2 * step.is_180)) % 4]
             for i in range(4)
             }
         for edge in edges:
@@ -147,7 +147,7 @@ def solve(self):
         """
         Solve the cross.
         """
-        result = Algo(path_actions(a_star_search(
+        result = Formula(path_actions(a_star_search(
             ({f: self.cube[f] for f in "LUFDRB"}, 
              self.cube.select_type("edge") & self.cube.has_colour(self.cube["D"].colour)), 
             self.cross_successors, 

pycuber/solver/cfop/f2l.py

@@ -109,7 +109,7 @@ def _rotate(pair, step):
             "B": "ULDR", 
             }[step.face]
         movement = {
-            movement[i]: movement[(i + step.is_standard + (-1 * step.is_inverse) + (2 * step.is_180)) % 4]
+            movement[i]: movement[(i + step.is_clockwise + (-1 * step.is_counter_clockwise) + (2 * step.is_180)) % 4]
             for i in range(4)
             }
         for cubie in pair:
@@ -137,9 +137,9 @@ def combining_successors(state, last_action=()):
         Successors function for finding path of combining F2L pair.
         """
         ((corner, edge), (L, U, F, D, R, B)) = state
-        U_turns = [Algo("U"), Algo("U'"), Algo("U2")] if len(last_action) != 1 else []
-        R_turns = [Algo("R U R'"), Algo("R U' R'"), Algo("R U2 R'")] if "R" not in last_action else []
-        F_turns = [Algo("F' U F"), Algo("F' U' F"), Algo("F' U2 F")] if "F" not in last_action else []
+        U_turns = [Formula("U"), Formula("U'"), Formula("U2")] if len(last_action) != 1 else []
+        R_turns = [Formula("R U R'"), Formula("R U' R'"), Formula("R U2 R'")] if "R" not in last_action else []
+        F_turns = [Formula("F' U F"), Formula("F' U' F"), Formula("F' U2 F")] if "F" not in last_action else []
         for act in (U_turns + R_turns + F_turns):
             new = (corner, edge)
             for q in act:
@@ -164,7 +164,7 @@ def combining_search(self):
         return sum(path_actions(a_star_search(start, 
                        self.combining_successors, 
                        lambda x: len(x), 
-                       self.combining_goal)), Algo())
+                       self.combining_goal)), Formula())
 
     def combining_setup(self):
         """
@@ -173,25 +173,25 @@ def combining_setup(self):
         (slot_type, (corner_slot, edge_slot), (corner, edge)) = self.get_slot()
         cycle = ["FR", "RB", "BL", "LF"]
         if slot_type == "SLOTFREE":
-            return ("FR", Algo(Step("y") * cycle.index(self.pair) or []))
+            return ("FR", Formula(Step("y") * cycle.index(self.pair) or []))
         elif slot_type == "CSLOTFREE":
             return (cycle[-(cycle.index(edge_slot) - cycle.index(self.pair))], 
-                    Algo(Step("y") * cycle.index(edge_slot) or [])) 
+                    Formula(Step("y") * cycle.index(edge_slot) or [])) 
         elif slot_type in ("ESLOTFREE", "WRONGSLOT"):
             return (cycle[-(cycle.index(corner_slot) - cycle.index(self.pair))], 
-                    Algo(Step("y") * cycle.index(corner_slot) or [])) 
+                    Formula(Step("y") * cycle.index(corner_slot) or [])) 
         elif slot_type == "DIFFSLOT":
             if corner_slot != self.pair: corner_slot, edge_slot = edge_slot, corner_slot
-            result = Algo(Step("y") * cycle.index(edge_slot) or [])
-            result += Algo("R U R'")
-            result += Algo(Step("y'") * cycle.index(edge_slot) or [])
-            result += Algo(Step("y") * cycle.index(corner_slot) or [])
+            result = Formula(Step("y") * cycle.index(edge_slot) or [])
+            result += Formula("R U R'")
+            result += Formula(Step("y'") * cycle.index(edge_slot) or [])
+            result += Formula(Step("y") * cycle.index(corner_slot) or [])
             if result[-1].face == "y" and result[-2].face == "y":
                 result[-2] += result[-1]
                 del result[-1]
             return (cycle[-(cycle.index(corner_slot) - cycle.index(self.pair))], result)
         else:
-            return (cycle[-cycle.index(self.pair)], Algo())
+            return (cycle[-cycle.index(self.pair)], Formula())
 
     def combine(self):
         """
@@ -209,14 +209,14 @@ def solve(self):
         """
         cycle = ["FR", "RB", "BL", "LF"]
         combine = self.combine()
-        put = Algo(Step("y") * cycle.index(self.pair) or [])
+        put = Formula(Step("y") * cycle.index(self.pair) or [])
         self.cube(put)
         self.pair = "FR"
         estimated = self.estimated_position()
-        for U_act in [Algo(), Algo("U"), Algo("U2"), Algo("U'")]:
+        for U_act in [Formula(), Formula("U"), Formula("U2"), Formula("U'")]:
             self.cube(U_act)
-            for put_act in [Algo("R U R'"), Algo("R U' R'"), Algo("R U2 R'"), 
-                            Algo("F' U F"), Algo("F' U' F"), Algo("F' U2 F")]:
+            for put_act in [Formula("R U R'"), Formula("R U' R'"), Formula("R U2 R'"), 
+                            Formula("F' U F"), Formula("F' U' F"), Formula("F' U2 F")]:
                 self.cube(put_act)
                 if self.get_pair() == estimated:
                     return combine + put + U_act + put_act

pycuber/solver/cfop/oll.py

@@ -9,10 +9,10 @@
     reader = csv.reader(f, delimiter=",")
     algo_dict = {}
     for line in reader:
-        algo_dict[line[1]] = Algo(line[2])
+        algo_dict[line[1]] = Formula(line[2])
         for i in range(1, 4):
-            algo_dict[line[1][-3*i:] + line[1][:-3*i]] = Algo(line[2]).insert(0, Step("U") * i)
-    algo_dict["000000000000"] = Algo()
+            algo_dict[line[1][-3*i:] + line[1][:-3*i]] = Formula(line[2]).insert(0, Step("U") * i)
+    algo_dict["000000000000"] = Formula()
 
 class OLLSolver(object):
     """
@@ -44,7 +44,7 @@ def recognise(self):
 
     def solve(self):
         """
-        Solve the OLL. Returns an Algo.
+        Solve the OLL. Returns an Formula.
         """
         if not isinstance(self.cube, Cube):
             raise ValueError("Use Solver.feed(cube) to feed the cube to solver.")

pycuber/solver/cfop/pll.py

@@ -10,11 +10,11 @@
     algo_dict = {}
     for name, rec_id, algo in reader:
         for i in range(4):
-            algo_dict[rec_id[-3*i:] + rec_id[:-3*i]] = Algo(algo).insert(0, Step("U") * i)
+            algo_dict[rec_id[-3*i:] + rec_id[:-3*i]] = Formula(algo).insert(0, Step("U") * i)
     rec_id = "LLLFFFRRRBBB"
     algo = []
     for i in range(4):
-        algo_dict[rec_id[-3*i:] + rec_id[:-3*i]] = Algo(algo).insert(0, Step("U") * i)
+        algo_dict[rec_id[-3*i:] + rec_id[:-3*i]] = Formula(algo).insert(0, Step("U") * i)
 
 class PLLSolver(object):
     """
@@ -52,7 +52,7 @@ def solve(self):
             rec_id = self.recognise()
             if rec_id in algo_dict:
                 self.cube(algo_dict[rec_id])
-                return Algo((Step("y") * i) or []) + algo_dict[rec_id]
+                return Formula((Step("y") * i) or []) + algo_dict[rec_id]
             self.cube(Step("y"))
         raise ValueError("Invalid cube.")