To compute the Reduced Row Echelon Form (RREF) of a matrix in Python, we can write a program that performs row operations to transform the matrix into RREF. These operations include:

1. Swapping rows.
2. Scaling a row (multiplying by a constant).
3. Adding or subtracting a multiple of one row to/from another row.

To implement this, we will work with NumPy, a library that simplifies matrix operations. However, for RREF specifically, we will have to manually implement the row reduction steps.

Here's the code for computing the Reduced Row Echelon Form of a matrix:

```python
import numpy as np

def rref(A):
    """Compute the Reduced Row Echelon Form (RREF) of matrix A."""
    A = A.astype(float)  # Ensure the matrix elements are floating-point for division
    rows, cols = A.shape
    row = 0  # Start from the first row
    
    for col in range(cols):
        if row >= rows:
            break
        
        # Find the pivot row
        pivot_row = np.argmax(np.abs(A[row:rows, col])) + row
        if A[pivot_row, col] == 0:
            continue  # Skip this column if all values are zero
        
        # Swap current row and pivot row
        A[[row, pivot_row]] = A[[pivot_row, row]]
        
        # Scale the pivot row to make the pivot element equal to 1
        A[row] = A[row] / A[row, col]
        
        # Eliminate the column below and above the pivot
        for i in range(rows):
            if i != row:
                A[i] -= A[i, col] * A[row]
        
        row += 1  # Move to the next row
    
    return A

# Example usage
A = np.array([[1, 2, -1, -4],
              [2, 4, -3, 1],
              [-1, -2, 3, 3]], dtype=float)

rref_matrix = rref(A)
print("Reduced Row Echelon Form of the matrix:")
print(rref_matrix)
```

### How the Code Works:
1. **Input Matrix**: The matrix is passed as a NumPy array.
2. **Pivoting**: We search for the largest element in each column (pivot element) starting from the current row, and swap it with the current row.
3. **Scaling the Pivot Row**: The pivot element is scaled to 1 by dividing the entire row by the pivot element.
4. **Eliminating Other Rows**: For every other row, we subtract a multiple of the pivot row to make all elements in the column (except for the pivot) equal to zero.
5. **Repeat**: This process is repeated for each column until we have processed all the rows and columns.

### Example Output:
For the matrix:

```
[[ 1,  2, -1, -4],
 [ 2,  4, -3,  1],
 [-1, -2,  3,  3]]
```

The RREF output will be something like:

```
[[ 1.  0.  0.  1.]
 [ 0.  1.  0.  2.]
 [ 0.  0.  1. -3.]]
```

This is the reduced row echelon form of the given matrix.