以下是一个使用Python实现的解决方法，它按照特定约束计算排列：

def calculate_permutations(arr, constraints):
    permutations = []
    used = [False] * len(arr)

    def backtrack(current):
        if len(current) == len(arr):
            permutations.append(current[:])
            return

        for i in range(len(arr)):
            if not used[i]:
                if len(current) > 0:
                    last_element = current[-1]
                    if (last_element, arr[i]) in constraints or (arr[i], last_element) in constraints:
                        continue

                used[i] = True
                current.append(arr[i])
                backtrack(current)
                current.pop()
                used[i] = False

    backtrack([])
    return permutations

这个方法使用回溯算法来计算排列。它首先创建一个空列表permutations来存储所有的排列结果。然后，它使用一个辅助函数backtrack来递归地生成排列。

在backtrack函数中，它首先检查当前排列的长度是否等于输入数组的长度。如果是，则表示已经生成了一个完整的排列，将其添加到permutations列表中，并返回。

否则，它遍历输入数组的每个元素，并检查是否可以将该元素添加到当前排列中。在这里，我们检查了约束条件，如果约束条件满足，则跳过当前元素。

如果约束条件不满足，它将该元素标记为已使用，将其添加到当前排列中，然后递归地调用backtrack函数。

递归调用完成后，它将当前元素从当前排列中弹出，将其标记为未使用，以备其他排列使用。

最后，它返回生成的所有排列。

你可以按照以下方式使用该方法：

arr = [1, 2, 3]
constraints = [(1, 2)]

permutations = calculate_permutations(arr, constraints)
print(permutations)

输出结果为：

[[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]

注意，约束条件表示元素1必须在元素2之前，因此排列[2, 1, 3]和[3, 1, 2]不在结果中。