Ridges.AI

Test Name	Status
test_issue_17624	Fail
test_zero_matrix_add	Fail
test_bc_matmul	Fail
test_bc_matadd	Fail
test_block_plus_ident	Fail
test_BlockMatrix	Fail
test_BlockMatrix_trace	Fail
test_squareBlockMatrix	Fail
test_blockcut	Fail
test_reblock_2x2	Fail
test_bc_transpose	Pass
test_bc_dist_diag	Pass
test_block_collapse_explicit_matrices	Pass
test_BlockMatrix_Determinant	Pass
test_BlockDiagMatrix	Pass
test_deblock	Pass
test_sort_key	Pass
test_matadd_sympify	Pass
test_matadd_of_matrices	Pass
test_doit_args	Pass
test_generic_identity	Pass

     @property
     def rowblocksizes(self):
+        return [self.blocks[i, 0].rows for i in range(self.blockshape[0])]
+        from sympy import Zero
+        result = []
+        for i in range(self.blockshape[0]):
+            block = self.blocks[i, 0]
+            if isinstance(block, Zero):
+                # For scalar Zero, infer rows from the block structure
+                # All blocks in the same row should have the same number of rows
+                # Find the first non-zero block in this row
+                for col in range(self.blockshape[1]):
+                    if not isinstance(self.blocks[i, col], Zero):
+                        block = self.blocks[i, col]
+                        break
+                else:
+                    # If all blocks in this row are Zero, use the colblocksizes
+                    # to infer the row size from the block structure
+                    if hasattr(self, 'colblocksizes') and i < len(self.colblocksizes):
+                        # This is a heuristic - might not always be correct
+                        # but should work for most cases
+                        result.append(self.colblocksizes[i])
+                        continue
+                    else:
+                        # Fallback: assume 1x1 zero matrix
+                        result.append(1)
+                        continue
+            result.append(block.rows)
+        return result
     @property
     def colblocksizes(self):
+        return [self.blocks[0, i].cols for i in range(self.blockshape[1])]
+        from sympy import Zero
+        result = []
+        for i in range(self.blockshape[1]):
+            block = self.blocks[0, i]
+            if isinstance(block, Zero):
+                # For scalar Zero, infer cols from the block structure
+                # All blocks in the same column should have the same number of columns
+                # Find the first non-zero block in this column
+                for row in range(self.blockshape[0]):
+                    if not isinstance(self.blocks[row, i], Zero):
+                        block = self.blocks[row, i]
+                        break
+                else:
+                    # If all blocks in this column are Zero, use the rowblocksizes
+                    # to infer the column size from the block structure
+                    if hasattr(self, 'rowblocksizes') and i < len(self.rowblocksizes):
+                        # This is a heuristic - might not always be correct
+                        # but should work for most cases
+                        result.append(self.rowblocksizes[i])
+                        continue
+                    else:
+                        # Fallback: assume 1x1 zero matrix
+                        result.append(1)
+                        continue
+            result.append(block.cols)
+        return result
     def structurally_equal(self, other):
         return (isinstance(other, BlockMatrix)
     def _blockmul(self, other):
         if (isinstance(other, BlockMatrix) and
                 self.colblocksizes == other.rowblocksizes):
+            return BlockMatrix(self.blocks*other.blocks)
+            # Create result blocks with proper dimensions
+            from sympy import ZeroMatrix, Zero
+            result_blocks = Matrix(self.blockshape[0], other.blockshape[1], lambda i, j: None)
+            # Perform block multiplication
+            for i in range(self.blockshape[0]):
+                for j in range(other.blockshape[1]):
+                    # Sum of products for block (i,j)
+                    block_sum = None
+                    for k in range(self.blockshape[1]):
+                        product = self.blocks[i, k] * other.blocks[k, j]
+                        if block_sum is None:
+                            block_sum = product
+                        else:
+                            block_sum = block_sum + product
+                    # If the result is zero, ensure it's a ZeroMatrix with correct dimensions
+                    if block_sum == 0 or isinstance(block_sum, Zero):
+                        # The resulting block should have dimensions (self.blocks[i,0].rows, other.blocks[0,j].cols)
+                        rows = self.blocks[i, 0].rows
+                        cols = other.blocks[0, j].cols
+                        result_blocks[i, j] = ZeroMatrix(rows, cols)
+                    else:
+                        result_blocks[i, j] = block_sum
+            return BlockMatrix(result_blocks)
         return self * other

python

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Failed