fix(reshape): move target check outside and unify calculate_even_odd logic with reduce

- Moved the `target` condition check to outside of the while loop to improve readability and reduce nesting.
- Refactored `_calculate_even_odd` and `calculate_even_odd` to use `functools.reduce`, keeping consistent with other reduce-based implementations in the codebase.
- Improved overall code clarity and consistency.

Author: gausshj

grassmann_tensor/tensor.py

@@ -222,17 +222,15 @@ def _reorder_indices(
         return len(even), len(odd), reorder, sign.flatten()
 
     def _calculate_even_odd(self) -> tuple[int, int]:
-        even, odd = 1, 0
-        for e, o in self.edges:
-            even, odd = even * e + odd * o, even * o + odd * e
-        return even, odd
+        return self.calculate_even_odd(self.edges)
 
     @staticmethod
     def calculate_even_odd(edges: tuple[tuple[int, int], ...]) -> tuple[int, int]:
-        even, odd = 1, 0
-        for e, o in edges:
-            even, odd = even * e + odd * o, even * o + odd * e
-        return even, odd
+        return functools.reduce(
+            lambda acc, eo: (acc[0] * eo[0] + acc[1] * eo[1], acc[0] * eo[1] + acc[1] * eo[0]),
+            edges,
+            (1, 0),
+        )
 
     def reshape(self, new_shape: tuple[int | tuple[int, int], ...]) -> GrassmannTensor:
         """
@@ -287,15 +285,17 @@ def reshape(self, new_shape: tuple[int | tuple[int, int], ...]) -> GrassmannTens
                 "Cannot split none edges into illegal edges"
             )
 
+        if len(new_shape) == 0:
+            assert self._calculate_even_odd() == (1, 0), (
+                "Only pure even edges can be merged into none edges"
+            )
+            tensor = self.tensor.reshape(())
+            return GrassmannTensor(_arrow=(), _edges=(), _tensor=tensor)
+
         cursor_plan: int = 0
         cursor_self: int = 0
         while cursor_plan != len(new_shape) or cursor_self != self.tensor.dim():
-            if len(new_shape) == 0:
-                assert self._calculate_even_odd() == (1, 0), (
-                    "Only pure even edges can be merged into none edges"
-                )
-                cursor_self = self.tensor.dim() - 1
-            elif cursor_plan != len(new_shape) and new_shape[cursor_plan] == -1:
+            if cursor_plan != len(new_shape) and new_shape[cursor_plan] == -1:
                 # Does not change
                 arrow.append(self.arrow[cursor_self])
                 edges.append(self.edges[cursor_self])
@@ -314,16 +314,12 @@ def reshape(self, new_shape: tuple[int | tuple[int, int], ...]) -> GrassmannTens
                 # A trivial self edge
                 cursor_self += 1
                 continue
-            if len(new_shape) == 0:
-                cursor_new_shape = typing.cast(int | tuple[int, int], tuple())
-                total = 1
-            else:
-                cursor_new_shape = new_shape[cursor_plan]
-                total = (
-                    cursor_new_shape
-                    if isinstance(cursor_new_shape, int)
-                    else cursor_new_shape[0] + cursor_new_shape[1]
-                )
+            cursor_new_shape = new_shape[cursor_plan]
+            total = (
+                cursor_new_shape
+                if isinstance(cursor_new_shape, int)
+                else cursor_new_shape[0] + cursor_new_shape[1]
+            )
             # one of total and shape[cursor_self] is not trivial, otherwise it should be handled before
             if total == self.tensor.shape[cursor_self]:
                 # We do not know whether it is merging or splitting, check more
@@ -339,9 +335,6 @@ def reshape(self, new_shape: tuple[int | tuple[int, int], ...]) -> GrassmannTens
                 cursor_self_finding = cursor_self
                 cursor_self_found = False
                 while True:
-                    if len(new_shape) == 0:
-                        cursor_self_found = True
-                        break
                     cursor_self_finding += 1
                     if cursor_self_finding == self.tensor.dim():
                         break
@@ -361,10 +354,6 @@ def reshape(self, new_shape: tuple[int | tuple[int, int], ...]) -> GrassmannTens
                 new_cursor_self = cursor_self
                 self_total = 1
                 while True:
-                    if len(new_shape) == 0:
-                        new_cursor_self += 1
-                        even, odd, reorder, sign = self._reorder_indices(self.edges)
-                        break
                     # Try to include more dimension from self
                     self_total *= self.tensor.shape[new_cursor_self]
                     new_cursor_self += 1
@@ -386,26 +375,19 @@ def reshape(self, new_shape: tuple[int | tuple[int, int], ...]) -> GrassmannTens
                         f"New shape exceeds in merging with edges {self.edges} and new shape {new_shape}."
                     )
                 # The merging block [cursor_self, new_cursor_self) has been determined
-                if len(new_shape) == 0:
-                    arrow = []
-                    edges = []
-                    shape = []
-                    merging_sign.append((cursor_plan, sign))
-                    cursor_self = new_cursor_self
-                else:
-                    arrow.append(self.arrow[cursor_self])
-                    assert all(
-                        self_arrow == arrow[-1]
-                        for self_arrow in self.arrow[cursor_self:new_cursor_self]
-                    ), (
-                        f"Cannot merge edges with different arrows {self.arrow[cursor_self:new_cursor_self]}."
-                    )
-                    edges.append((even, odd))
-                    shape.append(total)
-                    merging_sign.append((cursor_plan, sign))
-                    merging_reorder.append((cursor_plan, reorder))
-                    cursor_self = new_cursor_self
-                    cursor_plan += 1
+                arrow.append(self.arrow[cursor_self])
+                assert all(
+                    self_arrow == arrow[-1]
+                    for self_arrow in self.arrow[cursor_self:new_cursor_self]
+                ), (
+                    f"Cannot merge edges with different arrows {self.arrow[cursor_self:new_cursor_self]}."
+                )
+                edges.append((even, odd))
+                shape.append(total)
+                merging_sign.append((cursor_plan, sign))
+                merging_reorder.append((cursor_plan, reorder))
+                cursor_self = new_cursor_self
+                cursor_plan += 1
             else:
                 # Splitting between [cursor_plan, new_cursor_plan) and the another side contains dimension as plan_total
                 new_cursor_plan = cursor_plan
@@ -469,9 +451,6 @@ def reshape(self, new_shape: tuple[int | tuple[int, int], ...]) -> GrassmannTens
 
         tensor = tensor.reshape(shape)
 
-        if len(new_shape) == 0:
-            return GrassmannTensor(_arrow=tuple(arrow), _edges=tuple(edges), _tensor=tensor)
-
         merging_parity = functools.reduce(
             torch.logical_xor,
             (